泛型
泛型是在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。
- 最后，根据需要生成一些桥接方法。这是由于擦除了类型之后的类可能缺少某些必须的方法。这个时候就由编译器来动态生成这些方法。
