《Kotlin入门实战》CH8 | 泛型

关注

原创最新推荐文章于 2026-07-05 16:54:11 发布 164 阅读 AI 写同款· GEO 优化 ›

Kotlin协程高并发服务器：四种核心模式与性能优化实战并发编程是现代服务端开发的核心技术，通过合理利用计算资源提升系统吞吐量。Kotlin协程基于挂起函数和状态机机制，在用户态实现轻量级线程切换，避免了传统线程模型的内存开销和上下文切换成本。这种非阻塞并发模型特别适合I/O密集型场景，能够显著提升资源利用率和系统性能。在实际工程实践中，开发者需要掌握每请求一协程、生产者-消费者等核心模式，并注意调度器选择和资源管理。针对高并发服务器场景，Kotlin协程提供了结构化并发和背压处理等机制，帮助构建稳定高效的服务端应用，解决传统多线程模型在应对高并发请求时的性能瓶阅读详情

泛型

泛型是在Java5中引入的，泛型让集合框架可以重用代码，在没有泛型时候，集合框架中存储数据的类型都是Object，也就是说存入和取出数据都需要对对象进行强制类型转换。这就很可能出现错误。

1 类接口函数上使用泛型

泛型接口

interface Send<T>{
    fun handleMessage(t : T) : T;
}

fun main() {
    val h = object : Send<String>{
        override fun handleMessage(t: String): String {
            println(t)
            return "收到消息$t"
        }
    }
    println(h.handleMessage("hello"))
}

/*
hello
收到消息hello
*/

泛型类

class TClass<T>(var t : T){
    override fun toString(): String {
        return t.toString()
    }
}

fun main() {
    val t = TClass<Int>(1)
    println(t)
}

泛型函数

fun <T> handleT(t: T){
    println(t)
}

fun main() {   
    handleT<String>("nihao")
}

2 泛型上界

fun <T : Comparable<T>> gt(x: T, y: T): Boolean

<>中的T : Comparable<T>表示实现Comparable接口的类型

3 协变和逆变

协变

java中不支持协变，使用了通配符来解决的问题。

Number类型（简记为F）是Integer类型（简记为C）的父类型，我们把这种父子类型关系简记为C=>F（C继承F）；而List,List代表的泛型类型信息分别简记为f(F),f(C)。那么我们可以这样描述协变和逆变：
当C =>F时，如果有f(C) => f(F)，那么f叫做协变；
当C => F时，如果有f(F) => f(C)，那么f叫做逆变。如果上面两
种关系都不成立则叫做不变。

协变和逆变都是安全的。

Java中数组是可以协变的

        Integer[] ints = new Integer[3];
        ints[0] = 0;
        ints[1] = 1;
        ints[2] = 2;
        Number[] numbers = new Number[3];
        numbers = ints; //数组是协变的，可以正确赋值
        for (Number n : numbers) {
            System.out.println(n);
        }

java中泛型是不可以协变的

public class Test {
    static class A{

    }
    static class B extends A{

    }

    public static void main(String[] args) {
        List<B> bs = new ArrayList<>();
        bs.add(new B());
        List<A> as = (List<A>) bs; // Error Java泛型是不变的
    }
}

Error:(17, 32) java: 不兼容的类型: java.util.List<Test.B>无法转换为java.util.List<Test.A>

所以下面代码也是不合法的

List<Integer> integerList = new ArrayList<>();
integerList.add(0);
integerList.add(1);
integerList.add(2);
List<Number> numberList = new ArrayList<>();
numberList = integerList; //编译错误：类型不兼容

Java中泛型和数组的不同行为的确引起了许多混乱，就算我们使用通配符这样写：

List<? extends Number> list = new ArrayList<Number>();
list.add(new Integer(1)); //error

还是报错，不是说通配符可以解决协变问题吗

这个情况需要特殊说明，如果可以向List<? extends Number>中添加Integer，Float等，则意味着，List中存取的数据可以是integer, Float, Double等等，着就导致了List存储的元素类型混乱，所以Java禁止向List<? extends Number>中添加任意Number子类型的对象。但是可以添加Null指针。

逆变

java对逆变是支持的

逆变

    List<? super Integer> list = new ArrayList<Object>();
    list.add(Integer.valueOf(1));

PECS

总结 ? extends 和 the ? super 通配符的特征，我们可以得出以下结论：

如果你想从一个数据类型里获取数据，使用 ? extends 通配符
如果你想把对象写入一个数据结构里，使用 ? super 通配符
如果你既想存，又想取，那就别用通配符。

这就是Maurice Naftalin在他的《Java Generics and Collections》这本书中所说的存取原则，以及Joshua Bloch在他的《Effective Java》这本书中所说的PECS法则。

Bloch提醒说，这PECS是指”Producer Extends, Consumer Super”，这个更容易记忆和运用。

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator(); // 写入数据
            ListIterator<? extends T> si=src.listIterator(); // 读取数据
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

在kotlin中直接使用in和out来代替super和extends

out T等价于? extends T；
in T等价于? super T。

4 类型擦除

对于JVM来说并不存在List<Integer> ，JVM中只存在List，Kotlin也是这样的。

类型擦除的基本过程也比较简单：

首先，找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话，则使用这个上界。
其次，把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明，即去掉<>的内容。例如，Tget()就变成了Objectget()，List就变成了List。
最后，根据需要生成一些桥接方法。这是由于擦除了类型之后的类可能缺少某些必须的方法。这个时候就由编译器来动态生成这些方法。