Java泛型，你都了解了吗？

大纲
一、为什么需要泛型？泛型的优点
二、泛型定义
三、限定"类型变量"
四、泛型中的约束和局限性
五、泛型类型的继承规则和通配符类型
六、虚拟机是如何实现泛型的？-类型擦除
七、类型擦除与多态的冲突和解决方法

一、 为什么需要泛型？泛型的优点

1. 适用于多种类型执行相同的代码

2. 比如int相加 float相加 可以抽取出一个泛型方法

public static   T add(T x, T y)  {
}

2. 比如SharedPreference set get操作 对于不同类型 可以抽取一个公用的方法

public static  T getPrefValue(@NonNull SharedPreferences pref, @NonNull String key, @NonNull T t) {
    Objects.requireNonNull(pref);
    Objects.requireNonNull(key);
    Objects.requireNonNull(t);
    if (t instanceof String) {
        String str = pref.getString(key, (String) t);
        t = (T) str;
    } else if (t instanceof Integer) {
        Integer in = pref.getInt(key, (Integer) t);
        t = (T) in;
    } else if (t instanceof Long) {
        Long lon = pref.getLong(key, (Long) t);
        t = (T) lon;
    } else if (t instanceof Float) {
        Float fl = pref.getFloat(key, (Float) t);
        t = (T) fl;
    } else if (t instanceof Boolean) {
        Boolean bl = pref.getBoolean(key, (Boolean) t);
        t = (T) bl;
    } else if (t instanceof Set) {
        t = (T) pref.getStringSet(key, (Set) t);
    } else {
        throw new IllegalArgumentException("getPrefValue fail ! Value Type not supported");
    }
    return t;
}

2. 指定限制的类型，插入错误的数据类型，能够在编译期间就发现错误。不至于在运行时才发现异常。

List list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add(800);
for (int i = 0; i < list.size(); i++) {
    System.out.println((String)list.get(i));
}
运行时抛出异常：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

二、泛型定义

1. 泛型类和泛型接口

   在类名或接口后加一个

public class NormalGeneric {

    private T mData;
}
public interface IGeneric {

    T getData();
}
//也可声明多个泛型
public class MultiGeneric {

    private K mKey;

    private V mValue;

    public void setKeyValue(K key, V value) {
        mKey = key;
        mValue = value;
    }
}

2. 泛型方法

• 在返回值前用尖括号声明泛型 同样可定义多个

public  T getZ(T t) {
    //泛型方法
    return null;
}
publid  void setKeyValue(K key,V value){
    //todo
}

注意泛型方法

public T get(T t){}//注意 这不是一个泛型方法 这里的T 没有在方法中声明，是属于类声明的泛型。

public T get(){}//这才是一个泛型方法

3. 泛型类以及其内部泛型方法同时声明泛型T,但泛型方法的T可以是个全新的类型，可与泛型类中的声明T不是一个类型。

public class GenericType {

    private T mData;
    //备注  T可以是全新的类型，与类声明的T不冲突
    public  void test(T t) {
    }
}

三、限定"类型变量"

对传入的方法做限定。（看图示理解）

image

支持多个限定，T 可以继承类也可以实现接口，但只能有一个类，并要放在最前面，后面的接口用&分割

public  void set(K k, V value) {
}
ArrayList是类，Comparable和Iterable是接口

ArrayList是类，Comparable和Iterable是接口

四、泛型中的约束和局限性

编译器强制规定：

1. 不能实例化类型变量 new T() 不可以
2. 静态域或者方法里不能引用类型变量

privete state T getInstance();//不可以

为什么？泛型的类型在对象创建时，才知道具体的类型。而static在类加载就被执行了 在构造方法之前，所以这时还不知道具体类型，但如果静态方法本身就是一个泛型方法就可以。

public static T getInstance(){

}//可行

3. 泛型不能用instance of

image

4. 由于泛型擦除导致判断类名一致等（详情看底部类型擦除的详情介绍）
5. 可以定义泛型数组，但不能给泛型数组初始化
6. 泛型类不能继承Exception或Throwable，不能捕获泛型类对象

image

7. 泛型类型变量不能是基本数据类型 比如GenericType是不行的

五、泛型类型的继承规则和通配符类型

定义三个类：子类Apple继承父类Fruit Fruit类继承Food 三个类是这样一个关系

public class GenericType {

    private T mData;
    //省略 get set方法
}

尽管Apple继承父类Fruit ，但注意 GenericType 和 GenericType 之间没有继承关系。所以如果想让其有继承关系，引入--通配符

通配符--使用方法时定义

//apple-fruit-food
GenericType fruitGenericType = new GenericType<>();
GenericType appleGenericType = new GenericType<>();
GenericType foodGenericType=new GenericType<>();
print(appleGenericType);//不可以，因为没有继承关系
print2(appleGenericType);//可以 因为 ? extends Fruit  限定Fruit的子类都可以
print2(foodGenericType);//不可以 food是fruit的父类
print3(foodGenericType);//可以 ? super Fruit 限定Fruit的父类都可以

public static void print(GenericType type) {
}

public static void print2(GenericType type) {
}

public static void print3(GenericType type) {
}

extend --规定了传入参数的访问上限 主要用于安全的“访问”数据。不能set

GenericType type=new GeneicType<>();
type.setData();// 不可以
Fruit fruit=type.getData();//可以
GenericType type2=new GenericType<>();
type.setData(new Fruit());//可
type.setData(new Apply());//可
type.setData(new Food())//不可以 需要限定Fruit的子类! 
type.getData();//可以 但返回类型只能是Object

super --规定了传入参数的下限,主要用于安全的写入数据，写入数据限定在x的子类

六、虚拟机是如何实现泛型的？-类型擦除

1. 在编译时，类型擦除，会用一个原生类型代替泛型T

比如 会将定义的T替换成Object

但如果 将T替换为ArrayList

即有限定类型用限定类型（第一个边界）替换，无限定类型用Object替换

生成字节码时，里面是不包含泛型具体对象的，比如List List都要被转化为List

public class GenericType{
    private T mData;
}
//查看.class字节码文件为
public class GenericType