マルチレベルジェネリックタイプのJavaワイルドカード

Question

なぜBar.goがf2の引数を持つOKですが、引数がf1でないのはなぜですか？

public class HelloWorld { 
    public static void main(String[] args) { 
     Foo<Foo<?>> f1 = new Foo<Foo<?>>(); 
     Foo<Foo<String>> f2 = new Foo<Foo<String>>(); 
     Bar.go(f1);  // not OK 
     Bar.go(f2);  // OK 
    } 

    public static void p(Object o) { 
     System.out.println(o); 
    } 
} 

class Foo<E> { 
} 

class Bar { 
    public static <T> void go(Foo<Foo<T>> f) { 
    } 
} 

は、コンパイラが自動的に両方のケースでcapture of ?ようなタイプTを推測するべきではないでしょうか。

Answer 1

大きな質問！以下のコメントで

（Foo<E>等EにおけるジェネリックWRTクラス、反対としてEを使用して任意のパラメータを有することなく、Eを返すメソッドとして「共変法」、および「反変法」を定義する：一つはタイプEの仮パラメータを取りますが、Eを伴うタイプを返しません。[これらの用語の本当の定義はより複雑ですが、今のところそれを気にしない。]）

これは、コンパイラがバインドしようとしているようです〜Objectの場合はf1とすると、

たとえ Foo<String> <: Foo< ? extends String >、 Foo< Foo<String> > <: Foo< Foo< ? extends String > >ことを意味するものではありませんのでので

class Bar0 { 
    public static <T> void go(Foo< Foo< ? extends T > > f) { 
     // can pass a Foo<T> to a contravariant method of f; 
     // can use any result r of any covariant method of f, 
     // but can't pass T to any contravariant method of r 
    } 
} 

そしてgo(f1)作品が、今go(f2)は、しません。ここで

はf1とf2の両方のためにコンパイルし、いくつかの変更が加えられたものです：

class Bar1 { 
    public static <T> void go(Foo< ? super Foo<T> > f) { 
     // can't properly type the results of any covariant method of f, 
     // but we can pass a Foo<T> to any contravariant method of f 
    } 
} 

class Bar2 { 
    public static <T> void go(Foo< ? extends Foo< ? extends T > > f) { 
     // can't pass a Foo<T> to a contravariant method of f; 
     // can use result r of any covariant method of f; 
     // can't pass a T to a contravariant method of r; 
     // can use result of covariant method of r 
    } 
} 

Answer 2

Foo<Foo<?>> f1 = new Foo<Foo<?>>(); 

これはタイプが不明であり、任意の型のオブジェクトが不均一であり、コンパイラはFoo<Foo<?>>内のすべてのオブジェクトが同じタイプであることを保証することはできませんFoo<Foo<?>>に追加することができることを意味します。したがって、パラメータとして境界型をとるBar.goに渡すことはできません。

代わりにFoo<Foo<Object>> f1 = new Foo<Foo<Object>>();と宣言して、すべてObjectと明示的に言及するBar.goに渡すことができます。

Answer 3

Aニース読むWhat do multi-level wildcards mean?

例：もちろん

Collection< Pair<String,Long> >  c1 = new ArrayList<Pair<String,Long>>(); 

Collection< Pair<String,Long> >  c2 = c1; // fine 
Collection< Pair<String,?> >   c3 = c1; // error 
Collection< ? extends Pair<String,?> > c4 = c1; // fine 

、我々はCollection<Pair<String,Long>>へCollection<Pair<String,Long>>を割り当てることができます。ここには何も驚くべきことはありません。

Collection<Pair<String,Long>>をCollection<Pair<String,?>>に割り当てることはできません。パラメータ化された型Collection<Pair<String,Long>>は、StringとLongのペアの同種のコレクションです。パラメータ化された型Collection<Pair<String,?>>は、文字列と不明な型の何らかの組の異種のコレクションです。異種のCollection<Pair<String,?>>は、例えばPair<String,Date>を含むことができ、それは明らかにCollection<Pair<String,Long>>に属しません。このため、割り当ては許可されません。

Answer 4

私は、コンパイラがBar.go(f1);を許可する場合、型システム（安全性）が壊れてしまうことを証明します：

Javaの文法を変数を宣言する型としてTをgo()に使用することができます。何かのように：T t = <something>。

さて、ArrayList代わりのFooを使用してみましょう、

その後、我々が持っている：

class HW { 
public static void main(String[] args) { 
     ArrayList<ArrayList<?>> f1 = new ArrayList<ArrayList<?>>(); 
     go(f1);  // not OK 
    } 

    public static <T> void go(ArrayList<ArrayList<T>> f) { 
    } 
} 

ArrayList<?>はArrayList<String>のスーパータイプである、それはあなたがmainで次の操作を行うことができることを意味し、またArrayList<Integer>のスーパータイプであります：

ArrayList<?> s = new ArrayList<String>(); 
f1.add(s); 

ArrayList<?> i = new ArrayList<Integer>(); 
f1.add(i); 

次に、コンパイラではf1を引数としてgo()を呼び出すことができます。 Tを推測するためのオプションがあります：ArrayList<Object>はArrayList<?> だからそれが許可されていないオプションと同じタイプではないので

1. T = Objectが、ArrayList<ArrayList<Object>>がArrayList<ArrayList<?>>ではありません。

2. T = ?、そして我々が行うことができるだろう：

   public static <T> void go(ArrayList<ArrayList<T>> f) { 
       ArrayList<T> alt1 = f.get(0); // ArrayList<String> 
       T str = alt1.get(0); 
       ArrayList<T> alt2 = f.get(1); // ArrayList<Integer> 
       alt2.add(str); // We have added String to List<Integer> 
       // ... type system broken 
   } 
   

go()あなたがしなければならない両方のケースで動作するように：

public static void go(ArrayList<? extends ArrayList<?>> f) { 
}