这是代码。 Java 7和8的错误和警告都包含在注释中。
可以更改takeCollection(...)的签名，以便调用者可以调用它并传递SubRoot / Foo / Bar个集合并对其进行编译Java 7和8，虽然不必通过重载将方法签名专门引用到SubRoot / Foo / Bar类型（可能有很多这样的，一些依赖项目不可见这个）？如果是这样，怎么样？
package generics;
import java.util.Collection;
// -------------------------------------------------------------------------------
// Cannot change this (start)
//-------------------------------------------------------------------------------
interface Root<F extends Foo<F,B>, B extends Bar<F,B>> {}
class Foo <F extends Foo<F,B>, B extends Bar<F,B>> implements Root<F,B> {}
class Bar <F extends Foo<F,B>, B extends Bar<F,B>> implements Root<F,B> {}
interface SubRoot extends Root<SubFoo, SubBar> {}
class SubFoo extends Foo <SubFoo, SubBar> implements SubRoot {}
class SubBar extends Bar <SubFoo, SubBar> implements SubRoot {}
//-------------------------------------------------------------------------------
// End of cannot change block.
//-------------------------------------------------------------------------------
public class GenericsTest {
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void takeOne(R one) {}
// The following method signature can be changed a bit, but it has to accept a collection
// of Roots, or ANY of its subtypes.
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>, C extends Collection<R>>
void takeCollection(C collection) {}
// ------------------------------------------
// Test/illustration code that compiles well
// ------------------------------------------
@SuppressWarnings("rawtypes") // Warnings understood
void testOneRoot1(Root root, Foo foo, Bar bar) {
takeOne(root);
// Java 1.7 and 1.8 agree about the warning, as expected.
//
// generics\GenericsTest.java:35: warning: [unchecked] unchecked method invocation: method takeOne in class GenericsTest is applied to given types
// takeOne(root);
// ^
// required: R
// found: Root
// where R,F,B are type-variables:
// R extends Root<F,B> declared in method <R,F,B>takeOne(R)
// F extends Foo<F,B> declared in method <R,F,B>takeOne(R)
// B extends Bar<F,B> declared in method <R,F,B>takeOne(R)
takeOne(foo);
// Java 1.7 and 1.8 agree about the warning, as expected.
//
// generics\GenericsTest.java:48: warning: [unchecked] unchecked method invocation: method takeOne in class GenericsTest is applied to given types
// takeOne(foo);
// ^
// required: R
// found: Foo
// where R,F,B are type-variables:
// R extends Root<F,B> declared in method <R,F,B>takeOne(R)
// F extends Foo<F,B> declared in method <R,F,B>takeOne(R)
// B extends Bar<F,B> declared in method <R,F,B>takeOne(R)
takeOne(bar);
// Java 1.7 and 1.8 agree about the warning, as expected.
//
// generics\GenericsTest.java:61: warning: [unchecked] unchecked method invocation: method takeOne in class GenericsTest is applied to given types
// takeOne(bar);
// ^
// required: R
// found: Bar
// where R,F,B are type-variables:
// R extends Root<F,B> declared in method <R,F,B>takeOne(R)
// F extends Foo<F,B> declared in method <R,F,B>takeOne(R)
// B extends Bar<F,B> declared in method <R,F,B>takeOne(R)
}
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void testOneRoot2(R root, F foo, B bar) {
takeOne(root); // All fine
takeOne(foo); // All fine
takeOne(bar); // All fine
}
void testOneSubRoot(SubRoot subRoot, SubFoo subFoo, SubBar subBar) {
takeOne(subRoot); // All fine
takeOne(subFoo); // All fine
takeOne(subBar); // All fine
}
void testRootCollectionRaw(@SuppressWarnings("rawtypes") Collection<? extends Root> collection) {
takeCollection(collection);
// Java 1.7 quiet (not expected). Java 1.8 produces a warning, as expected:
//
// generics\GenericsTest.java:89: warning: [unchecked] unchecked method invocation: method takeCollection in class GenericsTest is applied to given types
// takeCollection(collection);
// ^
// required: C
// found: Collection<CAP#1>
// where C,R,F,B are type-variables:
// C extends Collection<R> declared in method <R,F,B,C>takeCollection(C)
// R extends Root<F,B> declared in method <R,F,B,C>takeCollection(C)
// F extends Foo<F,B> declared in method <R,F,B,C>takeCollection(C)
// B extends Bar<F,B> declared in method <R,F,B,C>takeCollection(C)
// where CAP#1 is a fresh type-variable:
// CAP#1 extends Root from capture of ? extends Root
}
// --------------------------------------------
// Test/illustration code that does NOT compile
// --------------------------------------------
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void testRootCollection1(Collection<? extends R> collection) {
takeCollection(collection);
// JDK 1.8 quiet (as expected). JDK 1.7 yields an error (not expected):
//
// generics\GenericsTest.java:112: error: invalid inferred types for R#1,F#1,B#1; inferred type does not conform to declared bound(s)
// takeCollection(collection);
// ^
// inferred: CAP#1
// bound(s): Root<CAP#2,CAP#3>
// where R#1,F#1,B#1,C,R#2,F#2,B#2 are type-variables:
// R#1 extends Root<F#1,B#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// F#1 extends Foo<F#1,B#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// B#1 extends Bar<F#1,B#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// C extends Collection<R#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// R#2 extends Root<F#2,B#2> declared in method <R#2,F#2,B#2>testRootCollection1(Collection<? extends R#2>)
// F#2 extends Foo<F#2,B#2> declared in method <R#2,F#2,B#2>testRootCollection1(Collection<? extends R#2>)
// B#2 extends Bar<F#2,B#2> declared in method <R#2,F#2,B#2>testRootCollection1(Collection<? extends R#2>)
// where CAP#1,CAP#2,CAP#3 are fresh type-variables:
// CAP#1 extends R#2 from capture of ? extends R#2
// CAP#2 extends Foo<CAP#2,CAP#3> from capture of ?
// CAP#3 extends Bar<CAP#2,CAP#3> from capture of ?
}
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void testRootCollection2(Collection<R> collection) {
takeCollection(collection);
// JDK 1.8 quiet (as expected). JDK 1.7 yields an error (not expected):
//
// generics\GenericsTest.java:136: error: invalid inferred types for R#1,F#1,B#1; inferred type does not conform to declared bound(s)
// takeCollection(collection);
// ^
// inferred: R#2
// bound(s): Root<CAP#1,CAP#2>
// where R#1,F#1,B#1,C,R#2,F#2,B#2 are type-variables:
// R#1 extends Root<F#1,B#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// F#1 extends Foo<F#1,B#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// B#1 extends Bar<F#1,B#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// C extends Collection<R#1> declared in method <R#1,F#1,B#1,C>takeCollection(C)
// R#2 extends Root<F#2,B#2> declared in method <R#2,F#2,B#2>testRootCollection2(Collection<R#2>)
// F#2 extends Foo<F#2,B#2> declared in method <R#2,F#2,B#2>testRootCollection2(Collection<R#2>)
// B#2 extends Bar<F#2,B#2> declared in method <R#2,F#2,B#2>testRootCollection2(Collection<R#2>)
// where CAP#1,CAP#2 are fresh type-variables:
// CAP#1 extends Foo<CAP#1,CAP#2> from capture of ?
// CAP#2 extends Bar<CAP#1,CAP#2> from capture of ?
}
void testSubRootCollection1(Collection<SubRoot> collection) {
takeCollection(collection);
// JDK 1.8 quiet (as expected). JDK 1.7 yields an error (not expected):
//
// generics\GenericsTest.java:158: error: invalid inferred types for R,F,B; inferred type does not conform to declared bound(s)
// takeCollection(collection);
// ^
// inferred: SubRoot
// bound(s): Root<CAP#1,CAP#2>
// where R,F,B,C are type-variables:
// R extends Root<F,B> declared in method <R,F,B,C>takeCollection(C)
// F extends Foo<F,B> declared in method <R,F,B,C>takeCollection(C)
// B extends Bar<F,B> declared in method <R,F,B,C>takeCollection(C)
// C extends Collection<R> declared in method <R,F,B,C>takeCollection(C)
// where CAP#1,CAP#2 are fresh type-variables:
// CAP#1 extends Foo<CAP#1,CAP#2> from capture of ?
// CAP#2 extends Bar<CAP#1,CAP#2> from capture of ?
}
void testSubRootCollection2(Collection<? extends SubRoot> collection) {
takeCollection(collection);
// JDK 1.8 quiet. JDK 1.7 yields an error:
//
// generics\GenericsTest.java:177: error: invalid inferred types for R,F,B; inferred type does not conform to declared bound(s)
// takeCollection(collection);
// ^
// inferred: CAP#1
// bound(s): Root<CAP#2,CAP#3>
// where R,F,B,C are type-variables:
// R extends Root<F,B> declared in method <R,F,B,C>takeCollection(C)
// F extends Foo<F,B> declared in method <R,F,B,C>takeCollection(C)
// B extends Bar<F,B> declared in method <R,F,B,C>takeCollection(C)
// C extends Collection<R> declared in method <R,F,B,C>takeCollection(C)
// where CAP#1,CAP#2,CAP#3 are fresh type-variables:
// CAP#1 extends SubRoot from capture of ? extends SubRoot
// CAP#2 extends Foo<CAP#2,CAP#3> from capture of ?
// CAP#3 extends Bar<CAP#2,CAP#3> from capture of ?
}
}
答案 0 :(得分：3)
如果我将takeCollection的签名更改为：
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void takeCollection(Collection<? extends R> collection) {}
但是，有未经检查/不安全的操作警告，都与原始类型有关。
答案 1 :(得分：2)
我会更改以下签名：
void takeOne(Root<?,?> one) {}
void takeCollection(Collection<? extends Root<?,?>> collection) {}
void testOneRoot1(Root<?,?> root, Foo<?,?> foo, Bar<?,?> bar) {}
<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void testOneRoot2(R root, F foo, B bar) {}
void testOneSubRoot(SubRoot subRoot, SubFoo subFoo, SubBar subBar) {}
@SuppressWarnings("unchecked")
void testRootCollectionRaw(@SuppressWarnings("rawtypes") Collection<? extends Root> collection) {
takeCollection((Collection<? extends Root<?,?>>)collection);
}
void testRootCollection1(Collection<? extends Root<?,?>> collection) {}
void testRootCollection2(Collection<? extends Root<?,?>> collection) {}
您的代码应该使用Java 7和Java 8的签名进行编译，而不会出现错误或警告。您的代码中有几个地方用通配符替换泛型类型参数是有意义的。例如，<R extends Root<F,B>, F extends Foo<F,B>, B extends Bar<F,B>>
void takeOne(R one) {}几乎等同于void takeOne(Root<?,?> one) {}，因为绑定F和B的方式已由Root的签名定义。 testRootCollectionRaw是一种特殊情况，因为它将rawtype作为upperbound。我希望在testRootCollectionRaw方法中使用未经检查的强制转换来解决此问题，而不是通过调整takeCollection签名来使其工作。
原始代码不能为Java 7编译的原因是Java 7中的类型推断不像Java 8中那样先进.Java 8将考虑类型推断上表达式的目标类型。通常，在可能的情况下用通配符替换显式类型参数是个好主意。实现这一点的一个副作用是Java 7处理通配符比使用泛型方法中的显式类型参数更容易。