Java和Kotlin使用泛型进行铸造。 丢失类型安全
当在Kotlin / Java中编码时，我偶然发现了使用投射和泛型的东西。 似乎有可能让类型系统相信列表的类型是List<Foo> ，而它实际上是一个List<Object> 。
任何人都可以向我解释为什么这是可能的？
以下是Kotlin和Java中的一个例子：
在Kotlin的例子
fun <T> test(obj: Any): List<T> { val ts = ArrayList<T>() ts.add(obj as T) return ts } fun <T> test2(obj: Any): T { return obj as T } fun <T> test3(obj: Any): List<T> { val ts = ArrayList<T>() ts.add(test2(obj)) return ts } fun main(args: Array<String>) { val x = test<Double>(1) // Returns a list of Integers and doesn't error println(x) val y = test2<Double>(1) // Casts the Int object to a Double. println(y) val z = test3<Double>(1) // Returns a list of Integers and doesn't error. println(z) }
Java中的示例
public class Test { public static <T> List<T> test(Object obj){ ArrayList<T> ts = new ArrayList<>(); ts.add((T) obj); return ts; } public static <T> T test2(Object obj){ return (T) obj; } public static <T> List<T> test3(Object obj){ ArrayList<T> ts = new ArrayList<>(); ts.add(test2(obj)); return ts; } public static void main(String[] args) { List<Double> x = test(1); // Returns a list of Integers and doesn't error System.out.println(x); // Double y = test2(1); // Errors in java an Integers cannot be converted into a Double. // System.out.println(y); List<Double> z = test3(1); // Returns a list of Integers and doesn't error. System.out.println(z); } }
Java没有具体的泛型。 也就是说，通用信息在运行时不存在，所有泛型代码都被称为擦除的进程“简化”。 当通用类型已知可确保正确性时，编译器会引发强制转换。 因为泛型类型不足以让运行时知道值是否为1，所以你不能转换为泛型类型，这就是为什么javac会这么叫你，因为它知道你是要求JVM做一些不可能做的事情，引入运行时的不安全性。
public class Test { public static List test(Object obj) { // generic types => erasure = raw types ArrayList ts = new ArrayList(); ts.add(obj); // No cast: List.add has erasure (Ljava.lang.Object;)V return ts; } public static Object test2(Object obj) { // T is unbounded => erasure = Object return obj; // No cast: all types <: Object } public static List test3(Object obj) { ArrayList ts = new ArrayList(); ts.add(test2(obj)); // Note: we don't know what T is, so we can't cast to it and ensure test2 returned one. return ts; } public static void main(String[] args) { List x = test(1); // Returns a list and doesn't error System.out.println(x); Double y = (Double) test2(1); // Errors in java as an Integer cannot be converted into a Double // This is because the compiler needs to insert casts to make generics work System.out.println(y); List z = test3(1); // Unlike y, there isn't a cast in test3 because test3 doesn't know what T is, so the Integer passes through, uncast, into a List<Double>. // The JVM can't detect this, because it doesn't even know what a List<Double> is. System.out.println(z); } }
请注意test2如何擦除一个荣耀的身份函数，导致test3与test1完全相同，但具有间接级别。
编译器发出一个警告，当执行未经检查转换为T. 当程序中有这样的警告时，不能保证安全。 所以你看到的行为是预料之中的。
尝试改变这样的第二个测试：
Double y = test2(1.0); System.out.println(y);
在你的代码test2(1) ，自变量1被自动装箱到一个Integer ，不能被转换成双精度。