大纲
一、为什么需要泛型？泛型的优点
二、泛型定义
三、限定"类型变量"
四、泛型中的约束和局限性
五、泛型类型的继承规则和通配符类型
六、虚拟机是如何实现泛型的？-类型擦除
七、类型擦除与多态的冲突和解决方法
一、 为什么需要泛型？泛型的优点
适用于多种类型执行相同的代码
比如int相加 float相加 可以抽取出一个泛型方法
public static <T> T add(T x, T y) {
}
- 比如SharedPreference set get操作 对于不同类型 可以抽取一个公用的方法
public static <T> 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<String>) t);
} else {
throw new IllegalArgumentException("getPrefValue fail ! Value Type not supported");
}
return t;
}
- 指定限制的类型，插入错误的数据类型，能够在编译期间就发现错误。不至于在运行时才发现异常。
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
二、泛型定义
-
泛型类和泛型接口
在类名或接口后加一个<T>
public class NormalGeneric<T> {
private T mData;
}
public interface IGeneric<T> {
T getData();
}
//也可声明多个泛型
public class MultiGeneric<K, V> {
private K mKey;
private V mValue;
public void setKeyValue(K key, V value) {
mKey = key;
mValue = value;
}
}
- 泛型方法
- 在返回值前用尖括号声明泛型 同样可定义多个
public <T> T getZ(T t) {
//泛型方法
return null;
}
publid <K,V> void setKeyValue(K key,V value){
//todo
}
注意泛型方法
public T get(T t){}//注意 这不是一个泛型方法 这里的T 没有在方法中声明，是属于类声明的泛型。
public <T> T get(){}//这才是一个泛型方法
- 泛型类以及其内部泛型方法同时声明泛型T,但泛型方法的T可以是个全新的类型，可与泛型类中的声明T不是一个类型。
public class GenericType<T> {
private T mData;
//备注 T可以是全新的类型，与类声明的T不冲突
public <T> void test(T t) {
}
}
三、限定"类型变量"
对传入的方法做限定。（看图示理解）
支持多个限定，T 可以继承类也可以实现接口，但只能有一个类，并要放在最前面，后面的接口用&分割
public <K, V extends ArrayList & Comparable & Iterable> void set(K k, V value) {
}
ArrayList是类，Comparable和Iterable是接口
ArrayList是类，Comparable和Iterable是接口
四、泛型中的约束和局限性
编译器强制规定：
- 不能实例化类型变量 new T() 不可以
- 静态域或者方法里不能引用类型变量
privete state T getInstance();//不可以
为什么？泛型的类型在对象创建时，才知道具体的类型。而static在类加载就被执行了 在构造方法之前，所以这时还不知道具体类型，但如果静态方法本身就是一个泛型方法就可以。
public static <T> T getInstance(){
}//可行
- 泛型不能用instance of
- 由于泛型擦除导致判断类名一致等（详情看底部类型擦除的详情介绍）
- 可以定义泛型数组，但不能给泛型数组初始化
- 泛型类不能继承Exception或Throwable，不能捕获泛型类对象
- 泛型类型变量不能是基本数据类型 比如GenericType<double>是不行的
五、泛型类型的继承规则和通配符类型
定义三个类：子类Apple继承父类Fruit Fruit类继承Food 三个类是这样一个关系
public class GenericType<T> {
private T mData;
//省略 get set方法
}
尽管Apple继承父类Fruit ，但注意 GenericType<Apple> 和 GenericType<Fruit> 之间没有继承关系。所以如果想让其有继承关系，引入--通配符
通配符--使用方法时定义
//apple-fruit-food
GenericType<Fruit> fruitGenericType = new GenericType<>();
GenericType<Apple> appleGenericType = new GenericType<>();
GenericType<Food> foodGenericType=new GenericType<>();
print(appleGenericType);//不可以，因为没有继承关系
print2(appleGenericType);//可以 因为 ? extends Fruit 限定Fruit的子类都可以
print2(foodGenericType);//不可以 food是fruit的父类
print3(foodGenericType);//可以 ? super Fruit 限定Fruit的父类都可以
public static void print(GenericType<Fruit> type) {
}
public static void print2(GenericType<? extends Fruit> type) {
}
public static void print3(GenericType<? super Fruit> type) {
}
extend --规定了传入参数的访问上限 主要用于安全的“访问”数据。不能set
GenericType<? extends Fruit> type=new GeneicType<>();
type.setData();// 不可以
Fruit fruit=type.getData();//可以
GenericType<? super Fruit> type2=new GenericType<>();
type.setData(new Fruit());//可
type.setData(new Apply());//可
type.setData(new Food())//不可以 需要限定Fruit的子类!
type.getData();//可以 但返回类型只能是Object
super --规定了传入参数的下限,主要用于安全的写入数据，写入数据限定在x的子类
六、虚拟机是如何实现泛型的？-类型擦除
- 在编译时，类型擦除，会用一个原生类型代替泛型T
比如<T> 会将定义的T替换成Object
但如果<T extends ArrayList> 将T替换为ArrayList
即有限定类型用限定类型（第一个边界）替换，无限定类型用Object替换
生成字节码时，里面是不包含泛型具体对象的，比如List<String> List<Integer>都要被转化为List
public class GenericType<T>{
private T mData;
}
//查看.class字节码文件为
public class GenericType<Object>{
private Object mData;
}
- 在调用泛型方法时，可以指定泛型，也可以不指定泛型
- 在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到Object
- 在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类
public class Test {
public static void main(String[] args) {
/**不指定泛型的时候*/
int i = Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型
Number f = Test.add(1, 1.2); //这两个参数一个是Integer，一个是Float，所以取同一父类的最小级，为Number
Object o = Test.add(1, "asd"); //这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object
/**指定泛型的时候*/
int a = Test.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类
int b = Test.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float
Number c = Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
}
//这是一个简单的泛型方法
public static <T> T add(T x,T y){
return y;
}
}
- 证明泛型被擦除:
验证1:
ImplGeneric<String> stringImplGeneric = new ImplGeneric<>();
ImplGeneric<Integer> integerImplGeneric = new ImplGeneric<>();
final Class stringImplGenericClass = stringImplGeneric.getClass();
final Class integerImplGenericClass = integerImplGeneric.getClass();
boolean equal = stringImplGenericClass == integerImplGenericClass;
System.out.println(equal);
输出true
ImplGeneric<String> 和ImplGeneric<Integer>打印其class文件 发现相同，如果打印其className,最终都是ImplGeneric类
验证2:
重载--需要保证方法名相同，参数不同，但以上图来看，说明List<String> 和 List<Integer> 相同，因为类型擦除，擦除后都是List,所以编译器编译不通过的。所以不符合重载，编译不通过。
验证3:
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泛型实例在编译之后被擦除掉了，只保留了原始类型。
七、类型擦除与多态的冲突和解决方法
父类
public class GenericType<T> {
private T mData;
public T getData() {
return mData;
}
public void setData(T data) {
mData = data;
}
}
子类
public class IntegerType extends GenericType<Integer> {
private Integer mData;
@Override
public Integer getData() {
return 100;
}
@Override
public void setData(Integer data) {
mData = data;
}
}
看起来是正常的，子类限定泛型类型为Integer，重写了get set方法
但要知道父类类型擦除后原生类型Object代替了T那么将变成
public class GenericType<Object> {
private Object mData;
public Object getData() {
return mData;
}
public void setData(Object data) {
mData = data;
}
}
父类的setData(Object data) 子类为setData(Integer data)，这样看并不符合重写规则，因为重写是要求父类和子类方法参数一致的？类型擦除和多态特性有了冲突：
本意是将IntegerType变为这样
public class IntegerType {
private Integer mData;
@Override
public Integer getData() {
return 100;
}
@Override
public void setData(Integer data) {
mData = data;
}
}
正常编译器做不到，只能变为Object。但为了实现这个需求，JVM做了特殊优化，通过使用桥方法。
反编译IntegerType.class的字节码文件（javap -c IntegerType.class 命令 ），结果如下：
public class IntegerType extends GenericType<java.lang.Integer> {
public com.study.java.generic.IntegerType();
Code:
0: aload_0
1: invokespecial #1 // Method com/study/java/generic/GenericType."<init>":()V
4: return
public java.lang.Integer getData();
Code:
0: bipush 100
2: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: areturn
public void setData(java.lang.Integer);
Code:
0: aload_0
1: aload_1
2: putfield #3 // Field mData:Ljava/lang/Integer;
5: return
public void setData(java.lang.Object);
Code:
0: aload_0
1: aload_1
2: checkcast #4 // class java/lang/Integer
5: invokevirtual #5 // Method setData:(Ljava/lang/Integer;)V
8: return
public java.lang.Object getData();
Code:
0: aload_0
1: invokevirtual #6 // Method getData:()Ljava/lang/Integer;
4: areturn
}
可以发现除了我们已知的setData(java.lang.Integer)和java.lang.Integer getData()还有两个JVM生成的两个桥方法setData(java.lang.Object)和java.lang.Object getData()。在setData(java.lang.Object)里第25行，实际调用的是setData(java.lang.Integer) 在java.lang.Object getData()里的第32行，实际调用的Integer getData()。这就是桥方法。桥方法的内部实现，就只是去调用我们自己重写的那两个方法。
虚拟机巧妙的使用了桥方法，来解决了类型擦除和多态的冲突。
这时候又会有一个疑问，如图编译器提示，在一个类中，已经重写了getData[返回值为Integer]，此时再加一个getData[返回值为Object]，在常规编程中是不允许的，不能通过编译器检查的。因为在编译时我们判断一个方法是否相同主要是判断方法名和参数，但！虚拟机内部判断方法是否相同是判断方法名 参数，外加返回值。所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情，然后交给虚拟器去区别。
八、其他
-
既然说类型变量会在编译的时候擦除掉，那为什么我们往 ArrayList<String>添加int值会错误呢?
Java编译器是通过先检查代码中泛型的类型，然后在进行类型擦除，再进行编译。
既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？
//看一下ArrayList.get()方法
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}
在获取时会根据泛型类型做一个强制类型转化
- 注意，在虚拟机里，泛型信息虽然擦除，但会保留在Signature。
- 为什么要擦除？jdk1.5之后加入的泛型，为了兼容之前的版本，才要做擦除。
- .......有遇到的新知识点继续补充
