Java Silver SE11の個人的な要点4選

JavaSilverSE11の黒本を読み込んでこれは大事だなって思ったこと4選をまとめます。
- オーバーライドとオーバーロード
- 配列の初期化方法いろいろ
- clone()メソッド
- 関数型インターフェース

# オーバーライドとオーバーロード
まずここで一番引っかかったポイントは継承したメソッドをどのように使うかでした。
基本的にサブクラスはスーパークラスのメソッドを扱えますが、宣言する型によって使えたり使えなかったりします。

#### パターン①：最も基本的なパターン
```java
public class A{
    public void sample(){};
}

public class B extends A{
    public void test(){};
}

public class Main{
    public static void main(String[] args){
        A a1 = new A(); //１　A型にAのインスタンスを代入
        A a2 = new B(); //２　A型にBのインスタンスを代入
        B b1 = new A(); //３　B型にAのインスタンスを代入
        B b2 = new B(); //４　B型にBのインスタンスを代入
    }
}
```

例えばこのようなサンプルコードがあった場合、
１は割愛。２はA型のローカル変数a2にBのインスタンスを渡しているのでtest()メソッドも使えそうな気もしますが、`a2.test()`はコンパイルエラーになります。A型で宣言しているのでa2のスコープはAクラス内のメソッドに限定されます。
３はコンパイルエラーになります。
４も自明なので割愛。

じゃあこういう場合はどうなんだっていうパターンがあります。
#### パターン②：サブクラスでオーバーライドしているパターン
```java
public class A{
    public void sample(){
        System.out.println("A");
    };
}

public class B extends A{
    @Override
    public void sample(){
        System.out.println("B");
    };
    public void test(){};
}

public class Main{
    public static void main(String[] args){
        A a2 = new B();
        a2.sample();
    }
}
```
この時、コンソールには以下のように表示されます。
```
B
```
基本的なパターンで、A型の変数はAクラス内のメソッドしか扱えないはずなのにと思いましたが、以下のような流れで決まるとのこと（黒本曰く）
- 呼び出されたメソッド`sample()`がオーバーライドされているかどうかをインスタンス内で探す
- あればオーバーライドしているメソッド、すなわちBクラスで定義されている`sample()`を実行
- なければA型の`sample()`を実行

つまり、オーバーライドのメソッドを優先的に実行する流れであるようです。
次にこういう場合はどうでしょう？
#### パターン③：スーパークラスとサブクラスに同名のメソッドがあるパターン
```java
public class A{
    public void sample(){
        System.out.println("A");
    };
}

public class B extends A{
    public void sample(String str){
        System.out.println(str);
    };
    public void test(){};
}

public class Main{
    public static void main(String[] args){
        A a2 = new B();
        a2.sample();
    }
}
```
この場合は次のようになります。
```
A
```
Bクラスで定義している`sample()`はオーバーライドの条件を満たしていないため、同名の別のメソッドとして認識されます。従って、mainメソッドで`sample()`に引数を渡していなくてもコンパイルエラーになることはありません。ちなみにこの時、サブクラスBの`sample()`に「@Override」アノテーションを付けたらコンパイルエラーになります。

**オーバーライドの条件**
1. 戻り値型が同じかそのサブクラス（共変戻り値）
1. シグニチャが同じ
1. アクセス修飾子が同じかより緩いもの
1. 例外がある場合、同じ型かそのサブクラス

次にIFを実装したらどうなるでしょう？
#### パターン④：インターフェースを実装したパターン
```java
interface C{
    public void method();
}

public class A{
    public void sample(){
        System.out.println("A");
    };

    public void method(){
        System.out.println("C");
    };
}

public class B extends A implements C{
    @Override
    public void sample(){
        System.out.println("B");
    };
    public void test(){};
}

public class Main{
    public static void main(String[] args){
        A a2 = new B();
        a2.method();
    }
}
```
コンソールはこんな感じ
```
C
```
インターフェース、または抽象クラスに定義された抽象メソッドは**直近の具象クラスで必ず実装しなければいけない**という決まりごとがあります。
→これやらないとコンパイルエラーになります。
クラス図で表すとこうなります。
![クラス図.drawio.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3762025/27d654fa-bcdb-653e-0f3c-eeef275d2139.png)
一見、Cインタフェースの`method()`をBクラスで実装していないように見えますが、コンパイルエラーになりません。理由は、BクラスがAクラスを継承しているため、Aクラスの`method()`がCインタフェースの実装とみなされるためです。

最後に、複雑なパターンを考えます。
#### パターン⑤：オーバーライドとオーバーロードが混在しているパターン
```java
public class A{
    public void sample(object obj){
        System.out.println("A");
    };
}

public class B extends A{
    @Override
    public void sample(Object obj){
        System.out.println("B");
    };

    public void sample(String str){
        System.out.println("C");
    };
    
    public void test(){};
}

public class Main{
    public static void main(String[] args){
        B b = new B();
        b.sample("sample");
    }
}
```
次のように表示されます。
```
C
```
BクラスではAクラスの`sample()`をオーバーライドしつつ、オーバーロードもしています。mainメソッドではB型の変数bにBインスタンスを渡しています。この場合、`b.sample("sample")`で渡している引数がString型なのでObject型でも受け取れますが、JVMはより厳密に定義している方を優先するため、オーバーロードされているメソッドが実行されます。

継承、オーバーロード、オーバーライドが絡むと複雑な挙動を示すように思いますが、JVMが処理する優先事項とアクセス修飾子、クラスの関係性に注意すれば大丈夫かと思います。

# 配列・リストの初期化式いろいろ
次に、配列の初期化方法についてまとめます。これも最初は混乱しましたが整理しました。
```java
Integer[] list1 = {1,2,3}; //パターン1
List<Integer> list2 = List.of(1,2,3); //パターン2
List<Integer> list3 = Arrays.asList(1,2,3); //パターン3
List<Integer> list4 = new ArrayList<Integer>(list1); //パターン4
List<Integer> list5 = new ArrayList<Integer>(list2); //パターン5
List<Integer> list6 = new ArrayList<Integer>(Arrays.asList(new Integer[]{1,2,3})); //パターン6
```

黒本で見かけた配列、およびリストの初期化式はこんな感じです。
パターン1~3は配列なので要素数の追加・削除はできません。特にList型で宣言しているパターン2,3の配列に`add()`を使って要素の追加を書くと**コンパイルエラーにはならず、UnsapportOperationExceptionが発生します。**
new ArrayListのインスタンスを渡しているパターン4~6はリストなので要素の追加・削除ができます。

# clone()メソッド
配列を複製する時に使うメソッドですが、どれが共通要素で何がオリジナルなのかが全く分からなかったので理解した内容をまとめます。

```java
int[] array1 = {1,2,3};
int[] array2 = array1.clone();

System.out.println(array1[0] == array2[0]);
System.out.println(array1 == array2);
System.out.println(array1.equales(array2));
```
実行すると結果はこうなります。
```
true
false
false
```

`array1.clone()`は具体的に以下の流れ
1. メモリ空間に{1,2,3}が複製される
1. 複製されたアドレスを返す
1. array2にアドレスが渡される

図で表すとこうなります。
![clone.drawio.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3762025/f8f22333-f5ef-3b38-fb74-bbb6736e9855.png)

従って、array1とarray2が参照しているアドレスは異なりますが、配列要素の内容は同じです。
"=="は同一性を評価するため、`array1 == array2`は**false**になります。Object型の`equals()`も同様に同一性を評価するため、`array1.equales(array2)`も**false**になります。

# 関数型インターフェース、ラムダ式、メソッド参照
ラムダ式については黒本著者が語るやさしくないJavaの動画を見てとても理解が深まった記憶があります。是非、見ていただきたい。
初見では理解できない書き方ですが、段階的にコード量が短くなっていく過程で深く理解できます。

代表的な関数型インタフェースにConsumer<>インタフェースがあります。
Consumer<>は`abstract accept()`という抽象メソッドが一つ定義されています。
これを使って、リストの中身を表示するためには以下のように書いていました。
#### 第一段階
```java
import java.util.List;
import java.util.ArrayList;
import java.util.function.Consumer;

class Sample implements Consumer<Integer> {
    @Override 
    public void accept(Integer num){
        System.out.println(num);
    }
}

class Main{
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>(List.of(1,2,3,4)); // リストを生成
        Sample sample = new Sample();
        for(Integer i : list){
            sample.accept(i);
        };
    }
}
```

ここでSampleクラスにComsumer<>を実装する無駄を省くためにMainクラスへ直接書き込むようにします。その際、Consumer型で`accept()`を定義します。

#### 第二段階
```java
import java.util.List;
import java.util.ArrayList;
import java.util.function.Consumer;

class Main{
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>(List.of(1,2,3,4)); // リストを生成
        Consumer<Integer> sample = new Consumer<Integer>() {
            @Override
            public void accept(Integer num){
                System.out.println(num);
            }
        }; 
        for(Integer i : list){
            sample.accept(i);
        };
    }
}
```
これで割とすっきりしましたがまだです。ここでラムダ式を導入します。

#### 第三段階
```java
import java.util.List;
import java.util.ArrayList;
import java.util.function.Consumer;

class Main{
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>(List.of(1,2,3,4)); // リストを生成
        Consumer<Integer> sample = num -> System.out.println(num);
        for(Integer i : list){
            sample.accept(i);
        };
    }
}
```

かなりすっきりしてきました。ちなみにラムダ式の書き方もかなり省略しています。
引数の型を省略したり、`{}`も省略できますが本来はこちらの書き方です。
```java
Consumer<Integer> sample = (Integer num) -> {
    System.out.println(num);
};
```
ここからまだいけます。次は拡張for文を簡略化していきます。
#### 第４段階
```java
import java.util.List;
import java.util.ArrayList;
import java.util.function.Consumer;

class Main{
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>(List.of(1,2,3,4)); // リストを生成
        Consumer<Integer> sample = num -> System.out.println(num);
        list.forEach(sample);
    }
}
```
だいぶ良くなってきました。Listインタフェースにある、`forEach(Consumer<> c)`を使います。このメソッドはConsumer型の変数を引数にするため使えます。ちょうど、Listインタフェースの`compare()`がComparator型の変数を引数にするみたいな感じです。
ここで注目すべきは`forEach()`にsampleを渡しているところです。ここも省略できそうなのでします。

#### 第５段階
```java
import java.util.List;
import java.util.ArrayList;

class Main{
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>(List.of(1,2,3,4)); // リストを生成
        list.forEach(num -> System.out.println(num));
    }
}
```
これで行数は最大に省略できました。もはや関数型インタフェースのConsumerも必要なくなりました。次で最後です。

#### 最終段階
```java
import java.util.List;
import java.util.ArrayList;

class Main{
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>(List.of(1,2,3,4)); // リストを生成
        list.forEach(System.out::println);
    }
}
```
メソッド参照を使いました。もはや引数も必要なくなりました。
第１段階の頃とくらべると原型が無いほどすっきりしましたが、表示される結果は同じなので不思議な気もします。
黒本ではこの流れで説明されており、改めて自分でコードを書くとより深く理解することができます。内容は黒本と一緒ですが、自分なりにまとめてみました。


# おわり
今回取り上げた4つ以外にも大切なポイントはたくさんありますが、だいたいは暗記なので覚えていれば大丈夫って感じですね。ロジックを理解しておくといいものだけまとめました。