ジェネリクスについてパッとわかったときの考え方

#概要
ジェネリクスは`引数`だよってことです。
ジェネリクスについていまいちしっくり来てなかった時に、「あーなるほどー」って思えた考えをまとめときます。

#参考にしたサイト
先人たちの知恵に感謝です。
http://d.hatena.ne.jp/Nagise/20101105/1288938415

#Javaの環境
java version 1.8.0_181
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)

src
└example
　　└java
　　　　└generics
　　　　　　├ Main.java
　　　　　　└ GenericsSample.java

#値の引数といえばメソッドですよね
##丸括弧 ()←これのことです
メソッドといえばこの丸括弧 `()` です。
この丸括弧()は、メソッド宣言の場所と、メソッド呼び出しの場所で同じ記号なんだけど違う意味で使ってます。
「メソッドで使う値」を示すための情報ですね。

```java:Main.java
package example.java.generics;

public class Main {
    public static void main(String[] args) {
        int result = plus(2, 5); // ここで  「()」は「この引数の値でメソッドを実行しますよ」という宣言(実引数)
        System.out.println(result);
    }

    public static int plus(int T, int S) { // ここで 「()」は「この引数名で引数を受け取りますよ」という宣言(仮引数)
        return T + S;
    } // T, S の 範囲ここまで
}
```

もちろんちゃんと実行できます
![function_2.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/be6d39ef-f4ea-bab7-3f54-9e26441206a0.jpeg)


#型の引数といえばジェネリクスですよね
##山括弧 <>←これのことです
じゃあ山括弧`<>`といえば・・・？そう、ジェネリクスです。
この山括弧<>は、ジェネリクス宣言の場所と、ジェネリクス呼び出し(あえてこういう言い方してます)の場所で同じ記号なんだけど違う意味で使ってます。
「クラスやメソッドで使う型」を示すための情報ですね。

```java:GenericsSsample.java
package example.java.generics;

public class GenericsSample {
    // ここで 「<>」 は「この引数名で型を受け取りますよ」という宣言(仮引数)
    public <T> void callGenerics(T value){
        System.out.println(value); // 引数の値は何かな？
        System.out.println(value.getClass().getName()); // 引数の型は何かな？
    } // T の 範囲ここまで
}
```

```java:Main.java
package example.java.generics;

public class Main {
    public static void main(String[] args) {
        GenericsSample genericsSample = new GenericsSample();
        
        // ここで 「<>」 は「この型の値でメソッドを実行しますよ」という宣言(実引数)
        // ここで  「()」は「この引数の値でメソッドを実行しますよ」という宣言(実引数)
        // 違う種類の実引数をそれぞれの記号で指定しているだけ
        genericsSample.<Integer>callGenerics(1234);
    }
}
```

ちゃんと引数で設定した値と型になっています
![generics_3.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/dd4e81c1-f28b-79c8-c08d-a0692f226c1d.jpeg)
![generics_8.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/023bc8fe-53cd-2b21-e35f-9f46cba7930b.jpeg)


型の値と、引数で渡した値の型(わかりづらいですね、、)が違う場合

```java:Main.java
package example.java.generics;

public class Main {
    public static void main(String[] args) {
        GenericsSample genericsSample = new GenericsSample();
        genericsSample.<String>callGenerics(1234);
    }
}
```

不穏な空気
![generics_6.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/18a10a82-1b0a-b0fe-f508-ed0290e6e36b.jpeg)

無事失敗します
![generics_7.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/8ef40db5-a1f2-1365-92aa-fda675fe6640.jpeg)

##型 → 値の順番で書くよね
そもそもJavaでは

```java
//型 変数の順番
String variable;
```

のように「型 → 順番」で書くので、型を表す引数のジェネリクス・値を表す引数の順番も「ジェネリクス → 値」になるのも納得感がある。

```java
// 型 → 値
// voidの前に型を表すジェネリクスが来ているのは、戻り値の型がジェネリクスで指定した引数になる可能性(この場合は「T」)があるから(たぶん)
public <T> void callGenerics(T value)

// 型 → 値
genericsSample.<String>callGenerics(1234);
```

#クラスに指定するジェネリクス
メソッドと同じく、クラスに「この引数名で型を受け取りますよ」という宣言(仮引数) がついているだけです。

```java:GenericsSample.java
package example.java.generics;

// ここで 「<>」 は「この引数名で型を受け取りますよ」という宣言(仮引数)
public class GenericsSample<T> {

    // クラスで指定した型の引数T のスコープがクラス内のメソッドまで続いている
    public void callGenerics(T value){
        System.out.println(value); // 引数の値は何かな？
        System.out.println(value.getClass().getName()); // 引数の型は何かな？
    }
} // <T> の 範囲ここまで
```

```java:Main.java
package example.java.generics;

public class Main {
    public static void main(String[] args) {
        // ここで 「<>」 は「この型の値でクラスをインスタンス化しますよ」という宣言(実引数)
        // new GenericsSample<Integer> は new GenericsSample<> に省略しても大丈夫(GenericsSample<Integer> なんだからIntegerなんでしょ？と推論してくれる)
        GenericsSample<Integer> genericsSample = new GenericsSample<Integer>();

        // ここで  「()」は「この引数の値でメソッドを実行しますよ」という宣言(実引数)
        genericsSample.callGenerics(1234);
    }
}
```

![generics_15.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/8b0d0ee8-a03b-f480-cb12-8fdb92222e94.jpeg)
![generics_9.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/3b7fcb1d-915e-82f8-ecdb-72372de6b2ea.jpeg)

もちろん違う型をメソッドに指定すると。。。

```Main.java
package example.java.generics;

public class Main {
    public static void main(String[] args) {
        // ここで 「<>」 は「この型の値でクラスをインスタンス化しますよ」という宣言(実引数)
        // new GenericsSample<Integer> は new GenericsSample<> に省略しても大丈夫(GenericsSample<Integer> なんだからIntegerなんでしょ？と推論してくれる)
        GenericsSample<Integer> genericsSample = new GenericsSample<Integer>();

        // ここで  「()」は「この引数の値でメソッドを実行しますよ」という宣言(実引数)
        genericsSample.callGenerics("test");
    }
}
```

不穏な空気
![generics_10.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/f9a57895-8ffc-4e73-f374-3422beeebb7b.jpeg)

無事失敗します
![generics_11.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/c5cdd825-d18b-9bcc-d526-fbc7beb61dcb.jpeg)

##<>がクラスにもメソッドにも同じ引数名でついてると。。

```java:GenericsSample.java
package example.java.generics;

// ここで 「<>」 は「この引数名で型を受け取りますよ」という宣言(仮引数)
public class GenericsSample<T> {

    // ここで 「<>」 は「この引数名で型を受け取りますよ」という宣言(仮引数)
    // クラスで指定した型の引数T のスコープがクラス内のメソッドまで続いている ... ？？
    public <T> void callGenerics(T value){
        System.out.println(value); // 引数の値は何かな？
        System.out.println(value.getClass().getName()); // 引数の型は何かな？
    }
} // <T> の 範囲ここまで ... ？？
```

```java:Main.java
package example.java.generics;

public class Main {
    public static void main(String[] args) {
        // ここで 「<>」 は「この型の値でクラスをインスタンス化しますよ」という宣言(実引数)
        // new GenericsSample<Integer> は new GenericsSample<> に省略しても大丈夫(GenericsSample<Integer> なんだからIntegerなんでしょ？と推論してくれる)
        GenericsSample<Integer> genericsSample = new GenericsSample<Integer>();

        // ここで  「()」は「この引数の値でメソッドを実行しますよ」という宣言(実引数)
        genericsSample.callGenerics("test");
    }
}
```

全然不穏じゃない
![generics_12.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/e140ebdc-11df-d14d-99ba-c69f558a79fa.jpeg)
![generics_13.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/360db7e3-4c2c-d348-4a36-b3d899432cf4.jpeg)

失敗しま...せん
![generics_14.JPG](https://qiita-image-store.s3.amazonaws.com/0/275553/f0c4dd2b-e96a-c524-ab01-6c9d6720499d.jpeg)


この原因は、**ここで 「<>」 は「この引数名で型を受け取りますよ」という宣言(仮引数)** を

+ クラス宣言時に<T>
+ メソッド宣言時に<T>

と、同じ引数名で指定してしまったため。メソッド内では新しいローカルの型の変数で上書きしてしまった。
↓のような感じ。

```java:GenericsSample.java
package example.java.generics;

// ここで 「<>」 は「この引数名で型を受け取りますよ」という宣言(仮引数)
public class GenericsSample<T> {

    // クラス内では、クラスのインスタンス時に指定したジェネリクスの実引数(new GenericsSample<Integer> のInteger)が有効

    // クラスで指定した型の引数T のスコープがメソッド時に指定したジェネリクスの実引数(今回はString)で上書きされてしまった
    // genericsSample.callGenerics("test"); の"test" から 「"test"はStringだから<T> のTはStringだ！」と推論された)
    public <T> void callGenerics(T value){
        System.out.println(value); // 引数の値は何かな？
        System.out.println(value.getClass().getName()); // 引数の型は何かな？
    }
}
```

#staticなクラス宣言時には指定できないの？
**できません。**
staticじゃないクラスの時は

```java
// ここで 「<>」 は「この型の値でクラスをインスタンス化しますよ」という宣言(実引数)
// new GenericsSample<Integer> は new GenericsSample<> に省略しても大丈夫(GenericsSample<Integer> なんだからIntegerなんでしょ？と推論してくれる)
```

とできましたが、staticクラスの時はクラスのインスタンス化とかできないですよね？
実引数を指定して作り出すタイミングがないので無理です。。
(でもstaticなメソッドの単位なら呼び出し時に実引数指定できるからジェネリクスの型引数を指定できるよ！)

#結論
ただの引数だからあわてずに。