多級別通用類型的Java通配符

Question

爲什麼Bar.go是OK帶有參數f2但不帶參數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) { 
    } 
} 

不應該編譯器自動推斷T類型，在兩種情況下capture of ?？

Answer 1

偉大的問題！

（在下面的評論，WRT一類通用的在E像Foo<E>，定義「協變方法」，其不使用E具有任何參數返回一個E的方法，以及「逆變方法」爲相反：一個其需要一個E類型的形式參數，但不返回涉及E的類型[這些術語的真正定義比較複雜，但現在不用介意]）

似乎編譯器試圖綁定T到Object在f1的情況下，因爲如果你做

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)沒有，因爲即使Foo<String> <: Foo< ? extends String >，這並不意味着Foo< Foo<String> > <: Foo< Foo< ? extends String > >。

這裏有兩個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>>();將其傳遞給Bar.go，您明確提到所有類型都是Object。

Answer 3

一個好的閱讀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,?>>是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>超，這也是超類型的ArrayList<Integer>，這意味着你可以做main以下：

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

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

現在，我們假設編譯器允許您使用f1作爲參數調用go()。 推斷T的選項是：

1. T = Object，但ArrayList<ArrayList<Object>>不是ArrayList<ArrayList<?>>因爲ArrayList<Object>是不一樣的類型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) { 
}