Java 8 中三元运算符的泛型编译错误，但 Java 7 中没有

该类在 Java 7 中编译正常，但在 Java 8 中编译失败：

public class Foo {

    public static void main(String[] args) throws Exception {
        //compiles fine in Java 7 and Java 8:
        Class<? extends CharSequence> aClass = true ? String.class : StringBuilder.class;
        CharSequence foo = foo(aClass);

        //Inlining the variable, compiles in Java 7, but not in Java 8:
        CharSequence foo2 = foo(true ? String.class : StringBuilder.class);

    }

    static <T> T foo(Class<T> clazz) throws Exception {
        return clazz.newInstance();
    }
}

编译错误：

错误:(9, 29) java: 类 Foo 中的方法 foo 无法应用于给定 类型；必需：java.lang.Class 找到：true ？ Str[...]类
原因：推断的类型不符合等式约束 推断：java.lang.StringBuilder 等式约束：java.lang.StringBuilder、java.lang.String

为什么这在 Java 8 中停止工作了？这是故意的/其他功能的副作用，还是只是一个编译器错误？

我要冒险说这个错误（虽然它可能符合也可能不符合更新的 JLS，我承认我没有详细阅读）是由于 JDK 的类型处理不一致造成的8 编译器。

一般来说，三元运算符使用与双参数方法相同的类型推断，该方法的形式参数都基于相同的类型参数。例如：

static <T> T foo(Class<? extends T> clazz, Class<? extends T> clazz2) { return null; }

public static void main(String[] args) {
    CharSequence foo2 = foo(String.class, StringBuilder.class);
}

在这个例子中，T可以推断为捕获? extends Object & Serializable & CharSequence。现在类似地，在 JDK 7 中，如果我们回到原来的示例：

CharSequence foo2 = foo(true ? String.class : StringBuilder.class);

这与上面几乎完全相同的类型推断，但在这种情况下，将三元运算符视为这样的方法：

static <T> T ternary(boolean cond, T a, T b) {
    if (cond) return a;
    else return b;
}

所以在这种情况下，如果您传递 String.class 和 StringBuilder.class 作为参数，则 T 的推断类型是（粗略地说）Class<? extends Object & Serializable & CharSequence>，这就是我们想要的。

事实上，您可以用此方法替换原始代码片段中三元运算符的使用，因此：

public class Foo {

    public static void main(String[] args) throws Exception {
        //compiles fine in Java 7 and Java 8:
        Class<? extends CharSequence> aClass = true ? String.class : StringBuilder.class;
        CharSequence foo = foo(aClass);

        //Inlining the variable using 'ternary' method:
        CharSequence foo2 = foo(ternary(true, String.class, StringBuilder.class));

    }

    static <T> T foo(Class<T> clazz) throws Exception {
        return clazz.newInstance();
    }

    static <T> T ternary(boolean cond, T a, T b) {
        if (cond) return a;
        else return b;
    }
}

... And now it compiles in Java 7 and 8 (edit: actually it also fails with Java 8! edit again: it now works, Jdk 8u20). What gives? for some reason an equality constraint is now being imposed on T (in the foo method), rather than a lower-bounds constraint. The relevant section of the JLS for Java 7 is 15.12.2.7 http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.7; for Java 8 there's a whole new chapter on type inference (chapter 18 http://docs.oracle.com/javase/specs/jls/se8/html/jls-18.html).

Note that explicitly typing T in the call to 'ternary' does allow compilation with Java 7 and 8, but this doesn't seem like it should be necessary. Java 7 does the right thing, where Java 8 gives an error even though there is an appropriate type that can be inferred for T.