public class Container<T> { private T item; public void set(T t) {
item = t;
} public T get() { return item;
}
}复制代码
Salin selepas log masuk
Salin selepas log masuk
然后写出如下代码：
Container<Object> c = new Container<String>(); // (1)编译报错Container<? extends Object> c = new Container<String>(); // (2)编译通过c.set("sss"); // (3)编译报错Object o = c.get();// (4)编译通过复制代码
Salin selepas log masuk
代码 (1)，Container<Object> c = new Container<String>(); 编译报错，因为泛型是不型变的，所以 Container 并不是 Container
Container<String> c = new Container<Object>(); // (1)编译报错Container<? super String> c = new Container<Object>(); // (2)编译通过
c.set("sss");// (3) 编译通过
String s = c.get();// (4) 编译报错复制代码
class Container<out T> { // (1)
private var item: T? = null
fun get(): T? = item
}
val c: Container<Any> = Container<String>()// （2）编译通过，因为 T 是一个 out-参数复制代码
Salin selepas log masuk
(1) 处直接使用 指定 T 类型只能出现在生产者的位置上。虽然多了一些限制，但是，在 kotlin 编译器在知道了 T 的角色以后，就可以像 (2) 处一样将 Container 直接赋值给 Container，好像泛型直接可以协变了一样，而不需要再使用 Java 当中的通配符 。
同样的，对于消费者来说，
class Container<in T> { // (1)
private var item: T? = null
fun set(t: T) {
item = t
}
}val c: Container<String> = Container<Any>() // (2) 编译通过,因为 T 是一个 in-参数复制代码
Salin selepas log masuk
代码 (1) 处使用 指定 T 类型只能出现在消费者的位置上。代码 (2) 可以编译通过， Any > String，但是 Container 可以被 Container 赋值，意味着 Container 大于 Container ，即它看上去就像 T 直接实现了泛型逆变，而不需要借助 通配符来实现逆变。如果是 Java 代码，则需要写成 Container<? super String> c = new Container<Object>(); 。
这就是声明处型变，在类声明的时候使用 out 和 in 关键字，在使用时可以直接写出泛型型变的代码。
而 Java 在使用时必须借助通配符才能实现泛型型变，这是使用处型变。
类型投影
有时一个类既可以作生产者又可以作消费者，这种情况下，我们不能直接在 T 前面加 in 或者 out 关键字。比如：
class Container<T> { private var item: T? = null
fun set(t: T？) {
item = t
} fun get(): T? = item
}复制代码
Salin selepas log masuk
考虑这个函数：
fun copy(from: Container<Any>, to: Container<Any>) {
to.set(from.get())
}复制代码
Salin selepas log masuk
当我们实际使用该函数时：
val from = Container<Int>()val to = Container<Any>()
copy(from, to) // 报错，from 是 Container<Int> 类型，而 to 是 Container<Any> 类型复制代码
Salin selepas log masuk
这样使用的话，编译器报错，因为我们把两个不一样的类型做了赋值。用 kotlin 官方文档的话说，copy 函数在”干坏事“， 它尝试写一个 Any 类型的值给 from， 而我们用 Int 类型来接收这个值，如果编译器不报错，那么运行时将会抛出一个 ClassCastException 异常。
所以应该怎么办？直接防止 from 被写入就可以了！
将 copy 函数改为如下所示：
fun copy(from: Container<out Any>, to: Container<Any>) { // 给 from 的类型加了 out
to.set(from.get())
}val from = Container<Int>()val to = Container<Any>()
copy(from, to) // 不会再报错了复制代码
同理，如果 from 的泛型是用 in 来修饰的话，则 from 只能被当作消费者使用，它只能调用 set() 方法，上述代码就会报错：
fun copy(from: Container<in Any>, to: Container<Any>) { // 给 from 的类型加了 in
to.set(from.get())
}val from = Container<Int>()val to = Container<Any>()
copy(from, to) // 报错复制代码
Salin selepas log masuk
其实从上面可以看到，类型投影和 Java 的通配符很相似，也是一种使用时型变。
为什么要这么设计？
为什么 Java 的数组是默认型变的，而泛型默认不型变呢？其实 kolin 的泛型默认也是不型变的，只是使用 out 和 in 关键字让它看起来像泛型型变。
// Illegal code - because otherwise life would be BadList<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs; // Awooga awoogaanimals.add(new Cat());// (1)Dog dog = dogs.get(0); //(2) This should be safe, right?复制代码
Salin selepas log masuk
如果上述代码可以通过编译，即 List 可以赋值给 List，List 是协变的。接下来往 List 中 add 一个 Cat()，如代码 (1) 处。这样就有可能造成代码 (2) 处的接收者 Dog dog 和 dogs.get(0) 的类型不匹配的问题。会引发运行时的异常。所以 Java 在编译期就要阻止这种行为，把泛型设计为默认不型变的。
总结
1、Java 泛型默认不型变，所以 List 不是 List<Object> 的子类。如果要实现泛型型变，则需要 与 通配符，这是一种使用处型变的方法。使用 通配符意味着该类是生产者，只能调用 get(): T 之类的方法。而使用 通配符意味着该类是消费者，只能调用 set(T t)、add(T t) 之类的方法。
2、Kotlin 泛型其实默认也是不型变的，只不过使用 out 和 in 关键字在类声明处型变，可以达到在使用处看起来像直接型变的效果。但是这样会限制类在声明时只能要么作为生产者，要么作为消费者。
使用类型投影可以避免类在声明时被限制，但是在使用时要使用 out 和 in 关键字指明这个时刻类所充当的角色是消费者还是生产者。类型投影也是一种使用处型变的方法。
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
