【通用开发】JVM泛型
本文介绍了JVM的泛型实现原理
根据《Java编程思想》中的描述，泛型出现的动机：
有很多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。
泛型的本质就是”参数化类型”。一提到参数，最熟悉的就是定义方法的时候需要形参，调用方法的时候，需要传递实参。那”参数化类型”就是将原来具体的类型参数化。泛型的出现避免了强转的操作，在编译器完成类型转化，也就避免了运行的错误。
现在的程序开发大都是面向对象的，平时会用到各种类型的对象，一组对象通常需要用集合来存储它们，因而就有了一些集合类，比如 List、Map 等。
这些集合类里面都是装的具体类型的对象，如果每个类型都去实现诸如 TextViewList、ActivityList 这样的具体的类型，显然是不可能的。
因此就诞生了「泛型」，它的意思是把具体的类型泛化，编码的时候用符号来指代类型，在使用的时候，再确定它的类型。
实例
Java泛型也是一种语法糖，在编译阶段完成类型的转换的工作，避免在运行时强制类型转换而出现 ClassCastException ，类型转化异常。
不使用泛型：
public static void main(String[] args) {
List list = new ArrayList();
list.add(11);
list.add("ssss");
for (int i = 0; i < list.size(); i++) {
System.out.println((String)list.get(i));
}
}
因为list类型是Object。所以int,String类型的数据都是可以放入的，也是都可以取出的。但是上述的代码，运行的时候就会抛出 类型转化异常 ，这个相信大家都能明白。
使用泛型：
public static void main(String[] args) {
List<String> list = new ArrayList();
list.add("hahah");
list.add("ssss");
for (int i = 0; i < list.size(); i++) {
System.out.println((String)list.get(i));
}
}
在上述的实例中，我们只能添加String类型的数据，否则编译器会报错。
泛型的使用
泛型的三种使用方式：泛型类，泛型方法，泛型接口
泛型类
即把泛型定义在类上：
public class 类名 <泛型类型1,...> {
}
注意事项：泛型类型必须是引用类型（非基本数据类型）
泛型方法
泛型方法概述：把泛型定义在方法上
public <泛型类型> 返回类型 方法名（泛型类型 变量名） {
}
注意要点：
方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则可以在整个接口、类中使用。当调用 fun() 方法时，根据传入的实际对象，编译器就会判断出类型形参 T 所代表的实际类型。
class Demo{
public <T> T fun(T t){ // 可以接收任意类型的数据
return t ; // 直接把参数返回
}
};
public class GenericsDemo26{
public static void main(String args[]){
Demo d = new Demo() ; // 实例化Demo对象
String str = d.fun("汤姆") ; // 传递字符串
int i = d.fun(30) ; // 传递数字，自动装箱
System.out.println(str) ; // 输出内容
System.out.println(i) ; // 输出内容
}
};
泛型接口
泛型接口概述：把泛型定义在接口
public interface 接口名<泛型类型> {
}
实例：
public interface Inter<T> {
public abstract void show(T t) ;
}
/**
* 子类是泛型类
*/
public class InterImpl<E> implements Inter<E> {
@Override
public void show(E t) {
System.out.println(t);
}
}
Inter<String> inter = new InterImpl<String>() ;
inter.show("hello") ;
源码中泛型的使用
下面是List接口和ArrayList类的代码片段。
//定义接口时指定了一个类型形参，该形参名为E
public interface List<E> extends Collection<E> {
//在该接口里，E可以作为类型使用
public E get(int index) {}
public void add(E e) {}
}
//定义类时指定了一个类型形参，该形参名为E
public class ArrayList<E> extends AbstractList<E> implements List<E> {
//在该类里，E可以作为类型使用
public void set(E e) {
.......................
}
}
泛型类派生子类
父类派生子类的时候不能在包含类型形参，需要传入具体的类型
错误的方式：
public class A extends Container<K, V> {}
正确的方式：
public class A extends Container<Integer, String> {}
也可以不指定具体的类型，系统就会把K,V形参当成Object类型处理
public class A extends Container {}
泛型构造器
构造器也是一种方法，所以也就产生了所谓的泛型构造器。 和使用普通方法一样没有区别，一种是显示指定泛型参数，另一种是隐式推断
class Person {
public <T> Person(T t) {
System.out.println(t);
}
}
使用：
public static void main(String[] args) {
new Person(22);// 隐式
new <String> Person("hello");//显示
}
特殊说明：
如果构造器是泛型构造器，同时该类也是一个泛型类的情况下应该如何使用泛型构造器：因为泛型构造器可以显式指定自己的类型参数（需要用到菱形，放在构造器之前），而泛型类自己的类型实参也需要指定（菱形放在构造器之后），这就同时出现了两个菱形了，这就会有一些小问题，具体用法再这里总结一下。
以下面这个例子为代表
public class Person<E> {
public <T> Person(T t) {
System.out.println(t);
}
}
正确用法：
public static void main(String[] args) {
Person<String> person = new Person("sss");
}
PS：编译器会提醒你怎么做的
高级通配符
<? extends T> 上界通配符
上界通配符顾名思义， <? extends T> 表示的是类型的上界【包含自身】，因此通配的参数化类型可能是 T 或 T 的子类。
正因为无法确定具体的类型是什么，add方法受限（可以添加null，因为null表示任何类型），但可以从列表中获取元素后赋值给父类型。如上图中的第一个例子，第三个add()操作会受限，原因在于 List 和 List 是 List<? extends Animal> 的子类型。
它表示集合中的所有元素都是Animal类型或者其子类
List<? extends Animal>
这就是所谓的上限通配符，使用关键字extends来实现，实例化时，指定类型实参只能是extends后类型的子类或其本身。
例如： 这样就确定集合中元素的类型，虽然不确定具体的类型，但最起码知道其父类。然后进行其他操作。
这种赋值由于类型擦除机制，在编译器就会提示报错。
List<Button> buttons = new ArrayList<Button>();
List<TextView> textViews = buttons;
使用通配符：
List<Button> buttons = new ArrayList<Button>();
List<? extends TextView> textViews = buttons;
上界通配符可以使 Java 泛型具有「协变性 Covariance」，协变就是允许上面的赋值是合法的。
前面说到 List<? extends TextView> 的泛型类型是个未知类型 ?，编译器也不确定它是啥类型，只是有个限制条件。
由于它满足 ? extends TextView 的限制条件，所以 get 出来的对象，肯定是 TextView 的子类型，根据多态的特性，能够赋值给 TextView，啰嗦一句，赋值给 View 也是没问题的。
到了 add 操作的时候，我们可以这么理解：
List<? extends TextView>由于类型未知，它可能是List<Button>，也可能是List<TextView>。- 对于前者，显然我们要添加 TextView 是不可以的。
实际情况是编译器无法确定到底属于哪一种，无法继续执行下去，就报错了。
由于 add 的这个限制，使用了 ? extends 泛型通配符的 List，只能够向外提供数据被消费，从这个角度来讲，向外提供数据的一方称为「生产者 Producer」。对应的还有一个概念叫「消费者 Consumer」，对应 Java 里面另一个泛型通配符 ? super。
<? super T> 下界通配符
下界通配符 <? super T> 表示的是参数化类型是 T 的超类型（包含自身），层层至上，直至Object。下界通配符可以使 Java 泛型具有「逆变性 Contravariance」。
与上界通配符对应，这里 super 限制了通配符 ? 的子类型，所以称之为下界。
它也有两层意思：
- 通配符 ? 表示 List 的泛型类型是一个未知类型。
- super 限制了这个未知类型的下界，也就是泛型类型必须满足这个 super 的限制条件。
- super 我们在类的方法里面经常用到，这里的范围不仅包括 Button 的直接和间接父类，也包括下界 Button 本身。
- super 同样支持 interface。
List<? super Button> buttons = new ArrayList<Button>();
List<? super Button> buttons = new ArrayList<TextView>();
List<? super Button> buttons = new ArrayList<Object>();
使用下界通配符 ? super 的泛型 List，只能读取到 Object 对象，一般没有什么实际的使用场景，通常也只拿它来添加数据，也就是消费已有的 List<? super Button>，往里面添加 Button，因此这种泛型类型声明称之为「消费者 Consumer」。
<?> 无界通配符
任意类型，如果没有明确，那么就是Object以及任意的Java类了 无界通配符用 <?> 表示，?代表了任何的一种类型，能代表任何一种类型的只有null（Object本身也算是一种类型，但却不能代表任何一种类型，所以List和List的含义是不同的，前者类型是Object，也就是继承树的最上层，而后者的类型完全是未知的）
泛型擦除
Java 泛型擦除（Type Erasure）是 Java 语言实现泛型的一种机制。简单来说，它意味着在编译时期，所有泛型类型信息都会被“擦除”掉，替换成它们的上界类型（如果存在）或 Object 类型（如果不存在上界）。在运行时，JVM 实际上并不知道泛型的具体类型参数。
编译器编译带类型说明的集合时会去掉类型信息
3.2 验证实例：
public class GenericTest {
public static void main(String[] args) {
new GenericTest().testType();
}
public void testType(){
ArrayList<Integer> collection1 = new ArrayList<Integer>();
ArrayList<String> collection2= new ArrayList<String>();
System.out.println(collection1.getClass()==collection2.getClass());
//两者class类型一样,即字节码一致
System.out.println(collection2.getClass().getName());
//class均为java.util.ArrayList,并无实际类型参数信息
}
}
输出结果：
true
java.util.ArrayList
分析：
这是因为不管为泛型的类型形参传入哪一种类型实参，对于Java来说，它们依然被当成同一类处理，在内存中也只占用一块内存空间。从Java泛型这一概念提出的目的来看，其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用类型形参。由于系统中并不会真正生成泛型类，所以instanceof运算符后不能使用泛型类
泛型与反射
把泛型变量当成方法的参数，利用Method类的 getGenericParameterTypes 方法来获取泛型的实际类型参数
例子：
public class GenericTest {
public static void main(String[] args) throws Exception {
getParamType();
}
/*利用反射获取方法参数的实际参数类型*/
public static void getParamType() throws NoSuchMethodException{
Method method = GenericTest.class.getMethod("applyMap",Map.class);
//获取方法的泛型参数的类型
Type[] types = method.getGenericParameterTypes();
System.out.println(types[0]);
//参数化的类型
ParameterizedType pType = (ParameterizedType)types[0];
//原始类型
System.out.println(pType.getRawType());
//实际类型参数
System.out.println(pType.getActualTypeArguments()[0]);
System.out.println(pType.getActualTypeArguments()[1]);
}
/*供测试参数类型的方法*/
public static void applyMap(Map<Integer,String> map){
}
}
输出结果：
java.util.Map<java.lang.Integer, java.lang.String>
interface java.util.Map
class java.lang.Integer
class java.lang.String
通过反射绕开编译器对泛型的类型限制
public static void main(String[] args) throws Exception {
//定义一个包含int的链表
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(1);
al.add(2);
//获取链表的add方法，注意这里是Object.class，如果写int.class会抛出NoSuchMethodException异常
Method m = al.getClass().getMethod("add", Object.class);
//调用反射中的add方法加入一个string类型的元素，因为add方法的实际参数是Object
m.invoke(al, "hello");
System.out.println(al.get(2));
}
泛型的限制
模糊性错误
对于泛型类 User<K,V> 而言，声明了两个泛型类参数。在类中根据不同的类型参数重载show方法。
public class User<K, V> {
public void show(K k) { // 报错信息：'show(K)' clashes with 'show(V)'; both methods have same erasure
}
public void show(V t) {
}
}
由于泛型擦除，二者本质上都是Obejct类型。方法是一样的，所以编译器会报错。
换一个方式：
public class User<K, V> {
public void show(String k) {
}
public void show(V t) {
}
}
可以正常的使用
不能实例化类型参数
编译器也不知道该创建那种类型的对象
public class User<K, V> {
private K key = new K(); // 报错：Type parameter 'K' cannot be instantiated directly
}
对静态成员的限制
静态方法无法访问类上定义的泛型；如果静态方法操作的类型不确定，必须要将泛型定义在方法上。
如果静态方法要使用泛型的话，必须将静态方法定义成泛型方法。
public class User<T> {
//错误
private static T t;
//错误
public static T getT() {
return t;
}
//正确
public static <K> void test(K k) {
}
}
对泛型数组的限制
不能实例化元素类型为类型参数的数组，但是可以将数组指向类型兼容的数组的引用
public class User<T> {
private T[] values;
public User(T[] values) {
//错误，不能实例化元素类型为类型参数的数组
this.values = new T[5];
//正确，可以将values 指向类型兼容的数组的引用
this.values = values;
}
}
对泛型异常的限制
泛型类型不能用于 catch 语句，例如
try { ... } catch (MyGenericException<T> e) { ... }
是不允许的。
Kotlin中的泛型
本节摘自扔物线的文章：
Kotlin 中的 out 和 in
和 Java 泛型一样，Kolin 中的泛型本身也是不可变的。
使用关键字 out 来支持协变，等同于 Java 中的上界通配符 ? extends。 使用关键字 in 来支持逆变，等同于 Java 中的下界通配符 ? super。
var textViews: List<out TextView>
var textViews: List<in TextView>
换了个写法，但作用是完全一样的。out 表示，我这个变量或者参数只用来输出，不用来输入，你只能读我不能写我；in 就反过来，表示它只用来输入，不用来输出，你只能写我不能读我。
* 号
前面讲到了 Java 中单个 ? 号也能作为泛型通配符使用，相当于 ? extends Object。 它在 Kotlin 中有等效的写法：* 号，相当于 out Any。
var list: List<*>
和 Java 不同的地方是，如果你的类型定义里已经有了 out 或者 in，那这个限制在变量声明时也依然在，不会被 * 号去掉。
比如你的类型定义里是 out T : Number 的，那它加上 <*> 之后的效果就不是 out Any，而是 out Number。
where 关键字
Java 中声明类或接口的时候，可以使用 extends 来设置边界，将泛型类型参数限制为某个类型的子集：
// T 的类型必须是 Animal 的子类型
class Monster<T extends Animal>{
}
注意这个和前面讲的声明变量时的泛型类型声明是不同的东西，这里并没有 ?。
同时这个边界是可以设置多个，用 & 符号连接：
// T 的类型必须同时是 Animal 和 Food 的子类型
class Monster<T extends Animal & Food>{
}
Kotlin 只是把 extends 换成了 : 冒号。
class Monster<T : Animal>
设置多个边界可以使用 where 关键字：
class Monster<T> where T : Animal, T : Food
reified 关键字
由于 Java 中的泛型存在类型擦除的情况，任何在运行时需要知道泛型确切类型信息的操作都没法用了。
比如你不能检查一个对象是否为泛型类型 T 的实例：
<T> void printIfTypeMatch(Object item) {
if (item instanceof T) { // 👈 IDE 会提示错误，illegal generic type for instanceof
System.out.println(item);
}
}
Kotlin 里同样也不行：
fun <T> printIfTypeMatch(item: Any) {
if (item is T) { // 👈 IDE 会提示错误，Cannot check for instance of erased type: T
println(item)
}
}
这个问题，在 Java 中的解决方案通常是额外传递一个 Class<T> 类型的参数，然后通过 Class#isInstance 方法来检查：
<T> void check(Object item, Class<T> type) {
if (type.isInstance(item)) {
System.out.println(item);
}
}
Kotlin 中同样可以这么解决，不过还有一个更方便的做法：使用关键字 reified 配合 inline 来解决：
inline fun <reified T> printIfTypeMatch(item: Any) {
if (item is T) {
println(item)
}
}
