Kotlin 协变与逆变 #

class Box<T>(val value: T)

val intBox: Box<Int> = Box(10)
// val numberBox: Box<Number> = intBox  // 编译错误！

class Box<T>(var value: T)

// Box<Int> 和 Box<Number> 没有任何关系

class Box<T>(var value: T) {
    fun get(): T = value
    fun set(value: T) { this.value = value }
}

// 如果 Box<Int> 是 Box<Number> 的子类型：
val intBox: Box<Int> = Box(10)
val numberBox: Box<Number> = intBox  // 假设允许
numberBox.set(10.5)  // 问题：Box<Int> 存入了 Double！

interface Producer<out T> {
    fun produce(): T
}

interface Producer<out T> {
    fun produce(): T  // 正确：作为返回值
    
    // fun consume(value: T)  // 错误：不能作为参数
}

interface Producer<out T> {
    fun produce(): T
}

class NumberProducer : Producer<Number> {
    override fun produce(): Number = 10
}

fun main() {
    val numberProducer: Producer<Number> = NumberProducer()
    val anyProducer: Producer<Any> = numberProducer  // 正确！
}

// Kotlin 标准库中的 List 是协变的
interface List<out E> : Collection<E> {
    fun get(index: Int): E
    // 没有 add(E) 方法
}

val ints: List<Int> = listOf(1, 2, 3)
val numbers: List<Number> = ints  // 正确！

interface Consumer<in T> {
    fun consume(value: T)
}

interface Consumer<in T> {
    fun consume(value: T)  // 正确：作为参数
    
    // fun produce(): T  // 错误：不能作为返回值
}

interface Consumer<in T> {
    fun consume(value: T)
}

class NumberConsumer : Consumer<Number> {
    override fun consume(value: Number) {
        println(value)
    }
}

fun main() {
    val numberConsumer: Consumer<Number> = NumberConsumer()
    val intConsumer: Consumer<Int> = numberConsumer  // 正确！
}

// Comparable 是逆变的
interface Comparable<in T> {
    fun compareTo(other: T): Int
}

class NumberComparator : Comparable<Number> {
    override fun compareTo(other: Number): Int = 0
}

fun main() {
    val numberComparator: Comparable<Number> = NumberComparator()
    val intComparator: Comparable<Int> = numberComparator  // 正确！
}

协变:    Producer<out T>
         Producer<Int> 是 Producer<Number> 的子类型
         
逆变:    Consumer<in T>
         Consumer<Number> 是 Consumer<Int> 的子类型
         
不变:    Box
         Box<Int> 和 Box<Number> 没有关系

interface Producer<out T> {
    fun produce(): T           // 返回值位置
    
    val value: T               // 属性 getter
    
    fun process(): List<T>     // 泛型返回值
}

interface Consumer<in T> {
    fun consume(value: T)      // 参数位置
    
    var value: T               // 属性 setter（需要 var）
    
    fun process(list: List<T>) // 泛型参数
}

// 使用类型投影
fun <T> copy(source: Array<out T>, destination: Array<in T>) {
    for (i in source.indices) {
        destination[i] = source[i]
    }
}

fun printList(list: List<*>) {
    list.forEach { println(it) }
}

// 对于 Producer<out T>：
// Producer<*> 等价于 Producer<out Any?>
val producer: Producer<*> = Producer<Int>()
val value: Any? = producer.produce()  // 可以读取

// 对于 Consumer<in T>：
// Consumer<*> 等价于 Consumer<in Nothing>
val consumer: Consumer<*> = Consumer<Number>()
// consumer.consume(value)  // 错误：不能写入任何值

// 当不关心具体类型时
fun getSize(collection: Collection<*>): Int {
    return collection.size
}

// 当只需要读取时
fun printElements(list: List<*>) {
    list.forEach { println(it) }
}

fun <T> copy(from: Array<out T>, to: Array<T>) {
    for (i in from.indices) {
        to[i] = from[i]
    }
}

val ints = arrayOf(1, 2, 3)
val numbers = arrayOfNulls<Number>(3)
copy(ints, numbers)  // 正确

fun fill(array: Array<in Number>, value: Number) {
    for (i in array.indices) {
        array[i] = value
    }
}

val numbers: Array<Number> = arrayOf(1, 2, 3)
fill(numbers, 10.5)  // 正确

val anys: Array<Any> = arrayOf("", "", "")
fill(anys, 10)  // 正确

interface Subscriber<in T> {
    fun onNext(value: T)
    fun onError(error: Throwable)
    fun onComplete()
}

interface Publisher<out T> {
    fun subscribe(subscriber: Subscriber<in T>)
}

fun <T> List<T>.addAll(elements: Collection<out T>): Boolean {
    // elements 是协变的，可以安全读取
    return elements.all { this.add(it) }
}

interface Comparator<in T> {
    fun compare(a: T, b: T): Int
}

fun <T> List<T>.sortedWith(comparator: Comparator<in T>): List<T> {
    // comparator 是逆变的，可以安全写入
    return this.sortedWith { a, b -> comparator.compare(a, b) }
}

// 生产者（只读）→ out
fun <T> copy(source: List<out T>): List<T>

// 消费者（只写）→ in
fun <T> fill(destination: Array<in T>, value: T)

// 如果同时读写，使用不变
class Box<T>(var value: T)

// 当类型不重要时
fun printSize(list: List<*>) = println(list.size)