泛型

//此种写法不允许！！
//不允许将子类直接赋值给它的父类
//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泛型实例在编译之后被擦除掉了，只保留了原始类型。
    */
}

类型擦除会导致类型的不安全。