Java ジェネリック: ジェネリック クラス、ジェネリック インターフェイス、およびジェネリック メソッド

「Java Programming Thoughts (4th Edition)」の説明によると、ジェネリックの出現の動機は次のとおりです:

ジェネリックの出現には多くの理由がありますが、最も目を引く理由の 1 つは次のとおりです。コンテナクラスを作成します。

ジェネリック クラス

コンテナ クラスは、最も再利用可能なクラス ライブラリの 1 つと見なされるべきです。まず、ジェネリックを使用せずにコンテナー クラスを定義する方法を見てみましょう:

public class Container {    
private String key;    
private String value;    
public Container(String k, String v) {
        key = k;        
        value = v;
    }    
    public String getKey() {        
        return key;
    }    
    public void setKey(String key) {        
        this.key = key;
    }    
    public String getValue() {        
        return value;
    }    
    public void setValue(String value) {        
       this.value = value;
    }
}

コンテナー クラスはキーと値のペアのペアを保存しますが、型は固定されています。つまり、キーと値のペアを作成したい場合は、はい、型は String-Integer です。現在のコンテナではこれを行うことができないため、カスタマイズする必要があります。したがって、これは明らかに再利用性が非常に低いです。

もちろん、String の代わりに Object を使用することもできます。Java SE5 より前では、これしかできませんでした。Object はすべての型の基本クラスであるため、直接変換できます。ただし、型が指定されているため、この柔軟性はまだ十分ではありませんが、今回は型を指定しないことは可能でしょうか。実行時に特定の型を知ることはできますか?

そこで、ジェネリック医薬品が登場しました。

public class Container<K, V> {    
private K key;    
private V value;    
public Container(K k, V v) {
        key = k;        
        value = v;
    }    
    public K getKey() {        
       return key;
    }    
    public void setKey(K key) {        
        this.key = key;
    }    
    public V getValue() {        
         return value;
    }    
    public void setValue(V value) {        
        this.value = value;
    }
}

コンパイル時に、K と V の特定の型を知ることは不可能です。実行時にのみ、型に基づいてメモリが実際に構築され、割り当てられます。 Container クラスによるさまざまなタイプの現在のサポートを確認できます。

public class Main {    
     public static void main(String[] args) {
        Container<String, String> c1 = new Container<String, String>("name", "findingsea");
        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}

出力:

name : findingsea
age : 24
1.1 : 2.2

ジェネリック インターフェイス

ジェネリック インターフェイスでは、ジェネレーターは次のジェネレーター インターフェイスの定義を参照してください。

次に、このインターフェイスを実装するジェネレーター クラスを定義します。

public interface Generator<T> {    
   public T next();
}

Call:

public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override    
    public String next() {
        Random rand = new Random();        
        return fruits[rand.nextInt(3)];
    }
}

Output:

public class Main {    
      public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}

Generic メソッド

基本原則は、できる限り、可能な限り汎用メソッドを使用する必要があります。つまり、ジェネリック メソッドの使用がクラス全体の一般化を置き換えることができる場合は、ジェネリック メソッドの使用を制限する必要があります。単純なジェネリック メソッドの定義を見てみましょう:

Banana
Banana
Pear
Banana

メソッドのパラメーターが完全に一般化されていることがわかります。このプロセスには、コンパイラーの型導出と自動パッケージ化が含まれます。つまり、本来は型導出を自分たちで実行する必要があります。 . 判断と処理、今度はコンパイラがやってくれます。このようにして、メソッドを定義するときに、将来どのような種類のパラメータを処理する必要があるかを考慮する必要がなくなり、プログラミングの柔軟性が大幅に向上します。

ジェネリック メソッドと変数パラメーターの別の例を見てください:

public class Main {    
     public static <T> void out(T t) {
        System.out.println(t);
    }    
    public static void main(String[] args) {        
       out("findingsea");        
       out(123);        
       out(11.11);        
       out(true);
    }
}

出力は前のコードと同じです。ジェネリックは変数パラメーターと完全に組み合わせることができることがわかります。