Android 泛型
什么是泛型？
泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。
泛型的用处？
一些强类型编程语言支持泛型，其主要目的是加强类型安全及减少类转换的次数，但一些支持泛型的编程语言只能达到部分目的。
Java早期是使用Object类型来接收任意的对象类型。但是在实际的运用中会有类型转换的问题，即：向上转型没有任何问题，但是向下转型时其实隐含了类型转换的问题，这就是程序不安全的原因，也就是因为存在这种安全隐患，所以Java在JDK5以后就提供了泛型来解决这个安全问题。
使用泛型定义的可以防止在运行时强转类型导致出现ClassCastExecption，把所有的因为类型不明确的问题都在编译时指出。
有了泛型以后：
1、代码更加简洁【不用强制转换】
2、程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
3、可读性和稳定性更强【在编写集合的时候，就限定了类型】
泛型的分类
泛型类
- 泛型类就是把泛型定义在类上，创建类或使用类时，需要提前把类型明确，这样的话提前明确了类型表示该类就是什么类型。不用担心强转或者运行时类型不安全问题。
泛型方法
- 定义在方法上表示使用方法时传入或者取出的参数类型需要明确。
泛型接口
- 说白了就是泛型类，因为接口需要类来实现才能使用。
泛型类派生的子类
- 分为明确类型的子类和不明确类型的子类。
不明确类型的就需要在下一层的子类或者创建的实例类来明确类型 - 注意
重写父类方法，返回值的类型要和父类一样
类声明的泛型只对非静态成员有效
因为静态成员在dex装载时就会把所有静态修饰的字段全部初始化了，并不是运行时再去明确类型。
类型通配符
通配符以 ？修饰的，表示未知类型。
通配符可用作各种情况：作为参数，字段或局部变量的类型；有时也作为返回类型；通配符从不用作泛型方法调用、泛型类实例创建或超类型的类型参数。
为什么要用通配符？
例子：你要遍历并打印外界传入的一个List，但是你不知道这个List的类型是什么？你可以使用Object修饰泛型，但是泛型中的<Object>并不是像以前那样有继承关系的，也就是说List<Object>和List<String>是毫无关系的！我们只能遍历装载object的集合。
所以Java泛型提供了类型通配符
？号通配符可以表示可以匹配任意类型，但是使用？通配符只能调用和类型无关的方法，不能调用于类型有关的方法。也就是说，在上面的List集合，我是不能使用add()方法的。因为add()方法是把对象丢进集合中，而现在我是不知道对象的类型是什么。
private void demo(List<?> list){
list.get(index);//这是没问题的
list.add(任意元素);//提示：in List cannot be applied to XX类型
}
上界通配符
表示设定类型的上限，也就是说是明确他的类型最多是定义的类型自身和它的子类
例子：现在，我想接收一个List集合，它只能操作数字类型的元素【Float、Integer、Double、Byte等数字类型都行】，怎么做？？？
List<? extends Number>
这样你就把元素类型给明确了，List装载的对象只能是Number的子类或自身。
下界通配符
表示设定类型的下限，表示设定的类型只能是它自身或者它的父类
例子：
<? super Type>
那它有什么用呢？？我们来想一下，当我们想要创建一个TreeSet<String>类型的变量的时候，并传入一个可以比较String大小的Comparator。
那么这个Comparator的选择就有很多了，它可以是Comparator<String>，还可以是类型参数是String的父类，比如说Comparator<Objcet>....
这样做，就非常灵活了。也就是说，只要它能够比较字符串大小，就行了
PECS原则
如果从集合中读取类型T的元素，但是不能写入，可以使用? extends 通配符
如果从集合中写入类型T的元素，但是不能读取，可以使用? super 通配符
如果既要读也要写，那么就不要使用任何通配符
例子：
? extends T
public class Test {
static class Food {}
static class Fruit extends Food {}
static class Apple extends Fruit {}
public static void main(String[] args) throws IOException {
List<? extends Fruit> fruits = new ArrayList<>();
fruits.add(new Food()); // compile error
fruits.add(new Fruit()); // compile error
fruits.add(new Apple()); // compile error
fruits = new ArrayList<Fruit>(); // compile success
fruits = new ArrayList<Apple>(); // compile success
fruits = new ArrayList<Food>(); // compile error
fruits = new ArrayList<? extends Fruit>(); // compile error: 通配符类型无法实例化
Fruit object = fruits.get(0); // compile success
}
}
存入数据
- 赋值是参数化类型为 Fruit 的集合和其子类的集合都可以成功，通配符类型无法实例化。
- 编译器会阻止将任何类加入fruits。在向fruits中添加元素时，编译器会检查类型是否符合要求。因为编译器只知道fruits是Fruit某个子类的List，但并不知道这个子类具体是什么类，为了类型安全，只好阻止向其中加入任何子类。
- 那么可不可以加入Fruit呢？很遗憾，也不可以。事实上，不能往使用了? extends的数据结构里写入任何的值。
读取数据
但是，由于编译器知道它总是Fruit的子类型，因此我们总可以从中读取出Fruit对象：
Fruit fruit = fruits.get(0);
? super T
public class Test {
static class Food {}
static class Fruit extends Food {}
static class Apple extends Fruit {}
public static void main(String[] args) throws IOException {
List<? super Fruit> fruits = new ArrayList<>();
fruits.add(new Food()); // compile error
fruits.add(new Fruit()); // compile success
fruits.add(new Apple()); // compile success
fruits = new ArrayList<Fruit>(); // compile success
fruits = new ArrayList<Apple>(); // compile error
fruits = new ArrayList<Food>(); // compile success
fruits = new ArrayList<? super Fruit>(); // compile error: 通配符类型无法实例化
Fruit object = fruits.get(0); // compile error
}
}
存入数据
- super 通配符类型同样不能实例化，Fruit 和其超类的集合均可赋值
- 这里 add 时 Fruit 及其子类均可成功，为啥呢？因为已知 fruits 的参数化类型必定是 Fruit 或其超类 T，那么 Fruit 及其子类肯定可以赋值给 T。
- 出于对类型安全的考虑，我们可以加入Apple对象或者其任何子类（如RedApple）对象（因为编译器会自动向上转型），但由于编译器并不知道List的内容究竟是Apple的哪个超类，因此不允许加入特定的任何超类型。
读取数据
编译器在不知道这个超类具体是什么类，只能返回Object对象，因为Object是任何Java类的最终祖先类。
Object fruit = fruits.get(0);
泛型方法和类型通配符的区别？
例子：
a. 类型通配符：void func(List<? extends A> list);
b. 完全可以用泛型方法完美解决：<T extends A> void func(List<T> list);
1）你会发现所有能用类型通配符（?）解决的问题都能用泛型方法解决，并且泛型方法可以解决的更好。
上面两种方法可以达到相同的效果（?可以代表范围内任意类型，而T也可以传入范围内的任意类型实参），并且泛型方法更进一步，?泛型对象是只读的，而泛型方法里的泛型对象是可修改的，即List<T> list中的list是可修改的！！
- 要说两者最明显的区别就是：
- ?泛型对象是只读的，不可修改，因为?类型是不确定的，可以代表范围内任意类型；
- 而泛型方法中的泛型参数对象是可修改的，因为类型参数T是确定的（在调用方法时确定），因为T可以用范围内任意类型指定；
注意：前者是代表，后者是指定，指定就是确定的意思，而代表却不知道代表谁，可以代表范围内所有类型。
- 这样好像说的通配符?一无是处，但是并不是这样，Java设计类型通配符?是有道理的，首先一个最明显的优点就是?的书写要比泛型方法简洁，无需先声明类型参数，其次它们有各自的应用场景：
- 一般只读就用?，要修改就用泛型方法，例如一个进行修改的典型的泛型方法的
例子：
public <T> void func(List<T> list, T t) {
list.add(t);
}
- 在多个参数、返回值之间存在类型依赖关系就应该使用泛型方法，否则就应该是通配符?：
具体讲就是，如果一个方法的返回值、某些参数的类型依赖另一个参数的类型就应该使用泛型方法，因为被依赖的类型如果是不确定的?，那么其他元素就无法依赖它）。
例如：
<T> void func(List<? extends T> list, T t);
即第一个参数依赖第二个参数的类型（第一个参数list的类型参数必须是第二个参数的类型或者其子类）；
可以看到，Java支持泛型方法和?混用;
这个方法也可以写成：
<T, E extends T> void func(List<E> list, T t);
明显意义是一样的，只不过这个list可以修改，而上一个list无法修改。
总之就是一旦返回值、形参之间存在类型依赖关系就只能使用泛型方法；
否则就应该使用? ；
- 对泛型方法的类型参数进行规约：即有时候可能不必使用泛型方法的地方你不小心麻烦地写成了泛型方法，而此时你可以将其规约成使用?的最简形式
- 总结地来讲就是一句话：只出现一次 & 对它没有任何依赖
例如：
<T, E extends T> void func(List<T> l1, List<E> l2);
这里E只在形参中出现了一次（类型参数声明不算），并且没有任何其他东西（方法形参、返回值）依赖它，那么就可以把E规约成?
！！最终规约的结果就是：
<T> void func(List<T> l1, List<? extends T> l2);
- 一个最典型的应用就是容器赋值方法（Java的API）：
public static <T> void Collections.copy(List<T> dest, List<? extends T> src) { ... }
！！从src拷贝到dest，那么dest最好是src的类型或者其父类，因为这样才能类型兼容，并且src只是读取，没必要做修改，因此使用?还可以强制避免你对src做不必要的修改，增加的安全性。
原则
- 如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法。
- 如果没有依赖关系的，就使用通配符，通配符会灵活一些。
kotlin 泛型协变和泛型约束
out T 与 in T
out T 等价于 ? extends T in T 等价于 ? super T 此外, 还有 * 等价于 ?
val list:ArrayList<out Number> = arrayListOf()
val lisat:ArrayList<in Number> = arrayListOf()
泛型约束
//表示T泛型参数约束为Number和其子类
private fun Demo(T: Number) {
val list: ArrayList<in Number> = arrayListOf()
list.add(T)
}
什么是泛型擦除
JDK5提出了泛型这个概念，但是JDK5以前是没有泛型的。也就是泛型是需要兼容JDK5以下的集合的。
Java中的泛型都是伪泛型，意思是在Java虚拟机中不存在泛型类型对象，所有对象都是普通类。
泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。
比如限定一个Animals类型，那么在虚拟机中所存的就是Animals类，不存在其子类。
无论何时定义一个泛型类型，都会自动提供一个相应的 原始类型 (raw type)(不存在泛型 )。原始类型的名字就是删去类型参数后泛型类的类型名,擦除类型变量，并替换为 限定类型（没有限定的变量就用 Object ）。
类擦除后如何保证类型限定符的类型？
Java 编译器通过先检查代码中泛型的类型，然后再进行类型擦除，再进行编译。
翻译泛型表达式
当程序调用泛型方法时，因为虚拟机进行了泛型擦除，所以这个时候获取到的类型应该是其类型上限，但是在虚拟机中会进行强制转换成对应类型。
那么它是怎么知道什么时候转换成哪个类型呢？
看下ArrayList.get()方法
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}
可以看到，在return之前，会根据泛型变量进行强转。假设泛型类型变量为Date，虽然泛型信息会被擦除掉，但是会将(E) elementData[index]，编译为(Date)elementData[index]。所以我们不用自己进行强转。当存取一个泛型域时也会自动插入强制类型转换。假设Pair类的value域是public的，那么表达式：
Date date = pair.value;
类型擦除与多态的冲突和解决方法
例子：
现在有这样一个泛型类：
class Pair<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
然后我们想要一个子类继承它。
class DateInter extends Pair<Date> {
@Override
public void setValue(Date value) {
super.setValue(value);
}
@Override
public Date getValue() {
return super.getValue();
}
}
在这个子类中，我们设定父类的泛型类型为Pair<Date>，在子类中，我们覆盖了父类的两个方法，我们的原意是这样的：将父类的泛型类型限定为Date，那么父类里面的两个方法的参数都为Date类型。
public Date getValue() {
return value;
}
public void setValue(Date value) {
this.value = value;
}
所以，我们在子类中重写这两个方法一点问题也没有，实际上，从他们的@Override标签中也可以看到，一点问题也没有，实际上是这样的吗？
分析：实际上，类型擦除后，父类的的泛型类型全部变为了原始类型Object，所以父类编译之后会变成下面的样子：
class Pair {
private Object value;
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}
再看子类的两个重写的方法的类型：
@Override
public void setValue(Date value) {
super.setValue(value);
}
@Override
public Date getValue() {
return super.getValue();
}
先来分析setValue方法，父类的类型是Object，而子类的类型是Date，参数类型不一样，这如果实在普通的继承关系中，根本就不会是重写，而是重载。
为什么会这样呢？
原因是这样的，我们传入父类的泛型类型是Date，Pair<Date>，我们的本意是将泛型类变为如下：
class Pair {
private Date value;
public Date getValue() {
return value;
}
public void setValue(Date value) {
this.value = value;
}
}
然后再子类中重写参数类型为Date的那两个方法，实现继承中的多态。
可是由于种种原因，虚拟机并不能将泛型类型变为Date，只能将类型擦除掉，变为原始类型Object。这样，我们的本意是进行重写，实现多态。可是类型擦除后，只能变为了重载。这样，类型擦除就和多态有了冲突。JVM知道你的本意吗？知道！！！可是它能直接实现吗，不能！！！如果真的不能的话，那我们怎么去重写我们想要的Date类型参数的方法啊。
于是JVM采用了一个特殊的方法，来完成这项功能，那就是桥方法。
首先，我们用javap -c className的方式反编译下DateInter子类的字节码，结果如下：
class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {
com.tao.test.DateInter();
Code:
0: aload_0
1: invokespecial #8 // Method com/tao/test/Pair."<init>":()V
4: return
public void setValue(java.util.Date); //我们重写的setValue方法
Code:
0: aload_0
1: aload_1
2: invokespecial #16 // Method com/tao/test/Pair.setValue:(Ljava/lang/Object;)V
5: return
public java.util.Date getValue(); //我们重写的getValue方法
Code:
0: aload_0
1: invokespecial #23 // Method com/tao/test/Pair.getValue:()Ljava/lang/Object;
4: checkcast #26 // class java/util/Date
7: areturn
public java.lang.Object getValue(); //编译时由编译器生成的巧方法
Code:
0: aload_0
1: invokevirtual #28 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法;
4: areturn
public void setValue(java.lang.Object); //编译时由编译器生成的巧方法
Code:
0: aload_0
1: aload_1
2: checkcast #26 // class java/util/Date
5: invokevirtual #30 // Method setValue:(Ljava/util/Date; 去调用我们重写的setValue方法)V
8: return
}
从编译的结果来看，我们本意重写setValue和getValue方法的子类，竟然有4个方法，其实不用惊奇，最后的两个方法，就是编译器自己生成的桥方法。可以看到桥方法的参数类型都是Object，也就是说，子类中真正覆盖父类两个方法的就是这两个我们看不到的桥方法。而打在我们自己定义的setvalue和getValue方法上面的@Oveerride只不过是假象。而桥方法的内部实现，就只是去调用我们自己重写的那两个方法。
所以，虚拟机巧妙的使用了桥方法，来解决了类型擦除和多态的冲突。
不过，要提到一点，这里面的setValue和getValue这两个桥方法的意义又有不同。
setValue方法是为了解决类型擦除与多态之间的冲突。
而getValue却有普遍的意义，怎么说呢，如果这是一个普通的继承关系：
那么父类的setValue方法如下：
public Object getValue() {
return super.getValue();
}
而子类重写的方法是：
其实这在普通的类继承中也是普遍存在的重写，这就是协变。
并且，还有一点也许会有疑问，子类中的桥方法Object getValue()和Date getValue()是同 时存在的，可是如果是常规的两个方法，他们的方法签名是一样的，也就是说虚拟机根本不能分别这两个方法。如果是我们自己编写Java代码，这样的代码是无法通过编译器的检查的，但是虚拟机却是允许这样做的，因为虚拟机通过参数类型和返回类型来确定一个方法，所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情，然后交给虚拟器去区别。
泛型类型变量不能是基本数据类型
不能用类型参数替换基本类型。就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类型变为Object，但是Object类型不能存储double值，只能引用Double的值。
编译时集合的instanceof
ArrayList<String> arrayList = new ArrayList<String>();
因为类型擦除之后，ArrayList<String>只剩下原始类型，泛型信息String不存在了。
那么，编译时进行类型查询的时候使用下面的方法是错误的
if( arrayList instanceof ArrayList<String>)
泛型在静态方法和静态类中的问题
泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数
public class Test2<T> {
public static T one; //编译错误
public static T show(T one){ //编译错误
return null;
}
}
因为泛型类中的泛型参数的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。
但是要注意区分下面的一种情况：
public class Test2<T> {
public static <T>T show(T one){ //这是正确的
return null;
}
}
因为这是一个泛型方法，在泛型方法中使用的T是自己在方法中定义的 T，而不是泛型类中的T。
