Javaジェネリックのまとめ(3) ～ワイルドカードの使い方を詳しく解説～

ジェネリックの使用には、ワイルドカードと呼ばれるもう 1 つの重要な機能があります。この記事では、ワイルドカードの使用について紹介します。非常に良い基準値を持っています。以下のエディターで見てみましょう

はじめに

最初の 2 つの記事では、ジェネリックス、型消去、ジェネリック配列の基本的な使用法を紹介しました。ジェネリックの使用には、ワイルドカードと呼ばれるもう 1 つの重要な機能があります。この記事では、ワイルドカードの使用について紹介します。

配列の共分散

ワイルドカードを理解する前に、まず配列を理解しましょう。 Java の配列は共変ですが、これは何を意味しますか?次の例を見てください。

class Fruit {}
class Apple extends Fruit {}
class Jonathan extends Apple {}
class Orange extends Fruit {}
public class CovariantArrays {
 public static void main(String[] args) { 
 Fruit[] fruit = new Apple[10];
 fruit[0] = new Apple(); // OK
 fruit[1] = new Jonathan(); // OK
 // Runtime type is Apple[], not Fruit[] or Orange[]:
 try {
  // Compiler allows you to add Fruit:
  fruit[0] = new Fruit(); // ArrayStoreException
 } catch(Exception e) { System.out.println(e); }
 try {
  // Compiler allows you to add Oranges:
  fruit[0] = new Orange(); // ArrayStoreException
 } catch(Exception e) { System.out.println(e); }
 }
} /* Output:
java.lang.ArrayStoreException: Fruit
java.lang.ArrayStoreException: Orange
*///:~

main メソッドの最初の行は、Apple 配列を作成し、それを Fruit 配列への参照に割り当てます。これは当然のことであり、Apple は Fruit のサブクラスであり、Apple オブジェクトも Fruit オブジェクトであるため、Apple 配列も Fruit の配列です。これは 配列の共分散 と呼ばれます。Java は配列が共変になるように設計されていますが、これが欠陥であると考える人もいます。

Apple[] は Fruit[] に「アップキャスト」できますが、配列要素の実際の型は依然として Apple であり、Apple または Apple のサブクラスのみを配列に入れることができます。上記のコードでは、Fruit オブジェクトと Orange オブジェクトが配列に配置されます。コンパイラではこれをコンパイルできますが、実行時に JVM は配列の実際の型が Apple[] であることを認識できるため、他のオブジェクトが配列に追加されると例外がスローされます。 ジェネリック設計の目的の 1 つは、そのようなランタイム エラーをコンパイル時に検出できるようにすることです。配列の代わりにジェネリック コンテナ クラスが使用された場合に何が起こるかを見てください:

// Compile Error: incompatible types:
ArrayList<Fruit> flist = new ArrayList<Apple>();

上記のコードは単純にコンパイルできません。ジェネリックに関しては、Apple は Fruit のサブタイプですが、ArrayList は ArrayList のサブタイプではなく、ジェネリックは共分散をサポートしません。

上記のことから、Integer は Number のサブタイプですが、List<Number> list = ArrayList<Integer> などのステートメントはコンパイルできないことがわかります。では、この「上向きの変革」関係が必要な場合はどうすればよいでしょうか?ここでワイルドカードが活躍します。

List<Number> list = ArrayList<Integer> 这样的语句是无法通过编译的，尽管 Integer 是 Number 的子类型。那么如果我们确实需要建立这种 “向上转型” 的关系怎么办呢？这就需要通配符来发挥作用了。

上边界限定通配符

利用 <? extends Fruit> 形式的通配符，可以实现泛型的向上转型：

public class GenericsAndCovariance {
 public static void main(String[] args) {
 // Wildcards allow covariance:
 List<? extends Fruit> flist = new ArrayList<Apple>();
 // Compile Error: can&#39;t add any type of object:
 // flist.add(new Apple());
 // flist.add(new Fruit());
 // flist.add(new Object());
 flist.add(null); // Legal but uninteresting
 // We know that it returns at least Fruit:
 Fruit f = flist.get(0);
 }
}

上面的例子中， flist 的类型是 List<? extends Fruit> 我们可以把它读作：一个类型的 List， 这个类型可以是继承了 Fruit 的某种类型。注意，这并不是说这个 List 可以持有 Fruit 的任意类型。通配符代表了一种特定的类型，它表示 “某种特定的类型，但是 flist 没有指定”。这样不太好理解，具体针对这个例子解释就是，flist 引用可以指向某个类型的 List，只要这个类型继承自 Fruit，可以是 Fruit 或者 Apple，比如例子中的 new ArrayList<Apple> 但是为了向上转型给 flist，flist 并不关心这个具体类型是什么。

如上所述，通配符 List<? extends Fruit> 表示某种特定类型 ( Fruit 或者其子类 ) 的 List，但是并不关心这个实际的类型到底是什么，反正是 Fruit 的子类型，Fruit 是它的上边界。那么对这样的一个 List 我们能做什么呢？其实如果我们不知道这个 List 到底持有什么类型，怎么可能安全的添加一个对象呢？在上面的代码中，向 flist 中添加任何对象，无论是 Apple 还是 Orange 甚至是 Fruit 对象，编译器都不允许，唯一可以添加的是 null。所以如果做了泛型的向上转型 (List<? extends Fruit> flist = new ArrayList<Apple>())，那么我们也就失去了向这个 List 添加任何对象的能力，即使是 Object 也不行。

另一方面，如果调用某个返回 Fruit 的方法，这是安全的。因为我们知道，在这个 List 中，不管它实际的类型到底是什么，但肯定能转型为 Fruit，所以编译器允许返回 Fruit。

了解了通配符的作用和限制后，好像任何接受参数的方法我们都不能调用了。其实倒也不是，看下面的例子：

public class CompilerIntelligence {
 public static void main(String[] args) {
 List<? extends Fruit> flist =
 Arrays.asList(new Apple());
 Apple a = (Apple)flist.get(0); // No warning
 flist.contains(new Apple()); // Argument is ‘Object&#39;
 flist.indexOf(new Apple()); // Argument is ‘Object&#39;
 //flist.add(new Apple()); 无法编译
 }
}

在上面的例子中，flist 的类型是 List<? extends Fruit>上限ワイルドカード

public boolean add(E e)
public boolean contains(Object o)
public int indexOf(Object o)

public class Holder<T> {
 private T value;
 public Holder() {}
 public Holder(T val) { value = val; }
 public void set(T val) { value = val; }
 public T get() { return value; }
 public boolean equals(Object obj) {
 return value.equals(obj);
 }
 public static void main(String[] args) {
 Holder<Apple> Apple = new Holder<Apple>(new Apple());
 Apple d = Apple.get();
 Apple.set(d);
 // Holder<Fruit> Fruit = Apple; // Cannot upcast
 Holder<? extends Fruit> fruit = Apple; // OK
 Fruit p = fruit.get();
 d = (Apple)fruit.get(); // Returns ‘Object&#39;
 try {
  Orange c = (Orange)fruit.get(); // No warning
 } catch(Exception e) { System.out.println(e); }
 // fruit.set(new Apple()); // Cannot call set()
 // fruit.set(new Fruit()); // Cannot call set()
 System.out.println(fruit.equals(d)); // OK
 }
} /* Output: (Sample)
java.lang.ClassCastException: Apple cannot be cast to Orange
true
*///:~

public boolean add(E e)
public boolean contains(Object o)
public int indexOf(Object o)

public class Holder<T> {
 private T value;
 public Holder() {}
 public Holder(T val) { value = val; }
 public void set(T val) { value = val; }
 public T get() { return value; }
 public boolean equals(Object obj) {
 return value.equals(obj);
 }
 public static void main(String[] args) {
 Holder<Apple> Apple = new Holder<Apple>(new Apple());
 Apple d = Apple.get();
 Apple.set(d);
 // Holder<Fruit> Fruit = Apple; // Cannot upcast
 Holder<? extends Fruit> fruit = Apple; // OK
 Fruit p = fruit.get();
 d = (Apple)fruit.get(); // Returns ‘Object&#39;
 try {
  Orange c = (Orange)fruit.get(); // No warning
 } catch(Exception e) { System.out.println(e); }
 // fruit.set(new Apple()); // Cannot call set()
 // fruit.set(new Fruit()); // Cannot call set()
 System.out.println(fruit.equals(d)); // OK
 }
} /* Output: (Sample)
java.lang.ClassCastException: Apple cannot be cast to Orange
true
*///:~

public class SuperTypeWildcards {
 static void writeTo(List<? super Apple> apples) {
 apples.add(new Apple());
 apples.add(new Jonathan());
 // apples.add(new Fruit()); // Error
 }
}

public class Collections { 
 public static <T> void copy(List<? super T> dest, List<? extends T> src) 
 {
 for (int i=0; i<src.size(); i++) 
 dest.set(i,src.get(i)); 
 } 
}