泛型
//此种写法不允许！！
//不允许将子类直接赋值给它的父类
//java不允许把一个子类的泛型对象，赋值给一个父类的泛型类型声明
List<View> textViews = new ArrayList<>(TextView);
由于上方在java中不允许，所以在java中使用通配符？的解决方案
//可以通过？通配符实现上面的问题
List<? extends View> textViews = new Arraylist<TextView>();
//使用时不能调用它的参数包含类型参数的方法
//类型参数为<>中的内容
//也不能给他的包含类型参数的字段赋值
//只能用不能修改
TextView textView = new TextView();
textViews.add(textView); //这种写法会报错，不正确
以下View是TextView的父类，TextView继承于View
协变
使用场景：只能输出不能输入，只能读，不能写（covariant，协变）
public void printTexts(List<? extends TextView> textViews){
for(TextView textView: textViews){
System.out.println(textView.getText());
}
}
...
List<Button> buttons = ...;
printTexts(buttons);
producer extends: list本身去生产，就是提供给别人用，（只能整体赋值，取出来用）
//也可以让变量或者参数的接受范围扩大，扩大方向与extends相反
//可以把父类的泛型对象，赋值给子类的泛型声明，（contravariant，逆变）
//使用变量的时候不能调用返回值包含类型参数的方法，也不能获得包含类型参数的字段值
List<? super TextView> textViews = new ArrayList<View>();
逆变
使用场景：只能输入不能输出，只能写，不能读 (contravariant, 逆变)
public void addTextView(List<TextView> textViews){
TextView textView = ...;
textViews.add(textView);
}
...
List<View> views = new ArrayList<View>();
addTextView(views); //这样写会报错，不可以！！！
//如果将views传入下面方法就不会报错
public void addTextView(List<? super TextView> textViews){
TextView textView = ...;
textViews.add(textView);
}
consumer super: list本身去消费，买来给自己用，自己保存内容 （不能整体的赋值，只能单独的添加）
java与kotlin中协变逆变的比较
//java写法
List<? extends View> textViews;
//kotlin写法
var textViews: List<out View> //只能输出不能输入，只能读，不能写
//java写法
List<? super TextView> textViews;
//kotlin写法
var textViews: List<in TextView> //只能输入不能输出，只能写，不能读
//以上的java写法与kotlin写法是相等的
<? extends View> 等价于 <out View>
<? super View> 等价于 <in View>
java中的<?>可以用<? extends Object> 替换，两者是相等的
kotlin中<*>与<out Any> 是相等的
//以下两个是相等的
List<?> objectList;
List<? extends Object> objectList;
//相当于kotlin中的
var objectList: List<*>
var objectList: List<out Any>
interface Counter<out T: Number>{
fun count():T
}
...
//Counter使用时，加星号相当于out Number由于上面声明的是<out T: Number>
var counter: Counter<*> = ...
var counter: Counter<out Number> = ...
//java中
//类型声明时的上界 通过&符号设置多重上界
class Monster<T extends Animal & Food>{
...
}
//kotlin中
//通过where关键字,设置多重上界
class Monster<T> where T: Animal, T: Food{
...
}
java与kotlin中的对象比较（instanceof）的区别
java不可以比较泛型，kotlin可以比较，但是需要增加关键字
//java
<T> void printIfTypeMatch(Object item){
//java中不允许直接比较泛型
if(item instanceof T){
System.out.println(item);
}
}
//kotlin中通过reified关键字，可以实现泛型和对象的比较
//但是reified自身有个限制，只能用再inline函数上
inline fun <reified T> printIfTypeMatch(item: Any){
if(item is T){
println(item)
}
}
类型擦除:
如在代码中定义List<Object>和List<String>等类型，在编译后都会变成List，JVM看到的只是List，而由泛型附加的类型信息对JVM是看不到的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法在运行时刻出现的类型转换异常的情况，类型擦除也是Java的泛型与C++模板机制实现方式之间的重要区别。
//原始类型相等
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<String>();
list1.add("abc");
ArrayList<Integer> list2 = new ArrayList<Integer>();
list2.add(123);
System.out.println(list1.getClass() == list2.getClass());
/**
在这个例子中，我们定义了两个ArrayList数组，
不过一个是ArrayList<String>泛型类型的，只能存储字符串；一个是ArrayList<Integer>泛型类型的，只能存储整数;
最后，我们通过list1对象和list2对象的getClass()方法获取他们的类的信息，最后发现结果为true。
说明泛型类型String和Integer都被擦除掉了，只剩下原始类型。
*/
}
//通过反射添加其它类型元素
public static void main(String[] args) throws Exception {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1); //这样调用 add 方法只能存储整形，因为泛型类型的实例为 Integer
list.getClass().getMethod("add", Object.class).invoke(list, "asd");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
/**
在程序中定义了一个ArrayList泛型类型实例化为Integer对象，
如果直接调用add()方法，那么只能存储整数数据，
不过当我们利用反射调用add()方法的时候，却可以存储字符串，
这说明了Integer泛型实例在编译之后被擦除掉了，只保留了原始类型。
*/
}
类型擦除会导致类型的不安全。
