我对此有麻烦:
public class Test {
static class TestType {}
static class Pair<A,B>{}
public static void main( String [] args ) throws Exception {
Collection<? extends TestType> val = null;
List<? extends TestType> single =
testSingle( val ); // OK
Pair<String,List<? extends TestType>> pair =
testPair( val ); // ERROR
}
static <T extends TestType> List<T> testSingle( Collection<T> val ){
return null;
}
static <T extends TestType> Pair<String,List<T>> testPair( Collection<T> val ){
return null;
}
}
为什么第一个无效，而第二个无效？
错误消息:
Type mismatch: cannot convert from Test.Pair<String,List<capture#3-of ? extends Test.TestType>> to Test.Pair<String,List<? extends Test.TestType>>
编辑:
使用Braj的答案，我在不使用泛型T时设置了此问题，以解决问题:
public class Test {
static class TestType {}
static class Implementation extends TestType {}
static class Pair<A,B>{}
public static void main( String [] args ) throws Exception {
Collection<Implementation> val = null;
List<Implementation> sinle = testSingle( val ); // OK
Pair<String,List<Implementation>> pair = testPair( val ); // OK
Pair<String,List<Implementation>> pair2 = testPair2( val ); // ERROR
Pair<String,List<Implementation>> pair3 = testPair3( val ); // ERROR
Pair<String,? extends List<Implementation>> pair4 = testPair4( val ); // ERROR
run( val );
}
private static void run( Collection<? extends TestType> val ){
List<? extends TestType> single = testSingle( val ); // OK
Pair<String,List<? extends TestType>> pair = testPair( val ); // ERROR
Pair<String,List<? extends TestType>> pair2 = testPair2( val ); // ERROR
Pair<String,List<? extends TestType>> pair3 = testPair3( val ); // OK
Pair<String,? extends List<? extends TestType>> pair4 = testPair4( val ); // OK
Pair<String,? extends List<? extends TestType>> pairX = testPair( val ); // OK
//My-Name-Is
@SuppressWarnings( "unchecked" )
Pair<String,List<? extends TestType>> fixed =
(Pair<String,List<? extends TestType>>)
(Pair<String,?>) testPair( val ); // OK but ugly and stupid(?)
}
private static <T extends TestType> List<T> testSingle( Collection<T> val ){
return null;
}
private static <T extends TestType> Pair<String,List<T>> testPair( Collection<T> val ){
return null;
}
// Braj1
private static <T extends TestType> Pair<String, List<TestType>> testPair2(Collection<T> val) {
return null;
}
// Braj2
private static <T extends TestType> Pair<String, List<? extends TestType>> testPair3(Collection<T> val) {
return null;
}
// Seelenvirtuose
private static <T extends TestType> Pair<String, ? extends List<? extends TestType>> testPair4(Collection<T> val) {
return null;
}
// This one works in the way I wanted.
private static <T extends TestType> void runOK( Collection<T> val ){
List<T> single = testSingle( val ); // OK
Pair<String,List<T>> pair = testPair( val ); // OK
}
}
EDIT2:我可以使用以下方法在run()中解决此问题:
@SuppressWarnings( "unchecked" )
Pair<String,List<? extends TestType>> fixed =
(Pair<String,List<? extends TestType>>)
(Pair<String,?>) testPair( val );
但这是丑陋且愚蠢的(？)。
EDIT3:我对以上内容进行了编辑，以包含Seelenviruose的答案，但它仍然变得越来越奇怪。
我仍然不知道为什么需要这样做...
EDIT4:最终在没有丑陋的转换的情况下正常工作:如果我使用
<T extends TestType> run(...)，编译器不会抱怨。我在上面改了 最佳答案
为什么第一个无效，而第二个无效？
因为List<ASpecificSubTypeOfTestType>(第一个方法的返回)是List<? extends TestType>的子类型，但是Pair<String, List<ASpecificSubTypeOfTestType>>(第二个方法的返回)不是Pair<String, List<? extends TestType>>的子类型。
让我们暂时将您的示例从Pair更改为List，将TestType更改为Object:
public class Test {
public static void main( String [] args ) throws Exception {
Collection<?> val = null;
List<?> single = testSingle( val ); // OK
List<List<?>> pair = testList( val ); // ERROR
}
static <T> List<T> testSingle( Collection<T> val ){
return null;
}
static <T> List<List<T>> testList( Collection<T> val ){
return null;
}
}
从技术角度来看，
List<SomeSpecificType>是List<?>的子类型，但是List<List<SomeSpecificType>>不是List<List<?>>的子类型，出于同样的原因，List<String>不是List<Object>的子类型-类型参数是不同的具体类型(一种是List<SomeSpecificType>，其他是List<?>)。为了更实际的推理，
testList返回一些List<List<T>>的T。我们不知道T是什么，但是我们知道它是某种具体类型。返回的这个List<List<T>>是一个只能包含List<T>的列表。如果S不是T，则它不能包含List<S>，因为List<S>和List<T>不是彼此的子类型。即使我们不知道T是什么，我们也知道存在T的选择，并且所有元素列表都必须以T作为类型参数。另一方面，您要为其分配的类型
List<List<?>>是一个列表，可以同时包含每种类型的列表。因此，您可以同时输入List<Integer>和List<String>等，这样就可以了。无论选择哪种List<List<T>>，都永远无法使用T做到这一点。因此，这两种类型显然不兼容。
有什么问题吗？使用
List<List<?>>参考，您可以将List<Integer>和List<String>插入列表中。然后，使用函数内部的List<List<T>>引用，您可以将所有元素提取为List<T>，而它们不是。因此，这是不安全的。您可能会说，如果我从不将内容放到
List<List<?>>参考中怎么办？这样安全吗？但是，在这种情况下，您应该改为使用List<? extends List<?>>。 ? extends通配符使其成为使用者，因此除了null之外，您不能在其中插入任何内容；并且还使类型兼容(List<List<SomeSpecificType>>是List<? extends List<?>>的子类型)。这个故事的寓意是，更深层的参数中的通配符并不意味着您认为它们会做什么。