2021.6.2：擦拭法、泛型继承

1、擦拭法

泛型是一种类似“模板代码”的技术，不同语言的泛型实现方式不一定相同。

Java的泛型实现方式是擦拭法（Type Erasure）——JVM对泛型一无所知，所有的代码都是编译器做的。

例如，我们编写了一个泛型类Pair<T>，这是编译器看到的代码：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而这是JVM执行的代码：

public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

由此可见，Java使用擦拭法实现泛型，导致了：

编译器把<T>视为Object；
编译器根据<T>实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair<String> p = new Pair<>("Hello","World");
String first = p.getFirst();
String last = p.getLast();

而JVM执行的代码是：

Pair p = new Pair("Hello","World")
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以，Java泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型时，编译器会根据T的类型自动为我们实行安全的强制类型转换。

了解Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：

<T>不能是基本类型，例如int，因为实际类型是Object，而Object无法持有基本类型：
```
Pair <int> p = new Pair<>(1,2);//编译错误
```
无法取得带泛型的Class。因为T是Object，所以对所有的泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>。
无法判断带泛型类中的泛型类型
```
Pair <Integer> p =new Pair<>(123,456);
if(p instanceof Pair<String>){...}//编译错误
```
原因和前边一样，不存在Pair<String>.class，而是只有唯一的Pair.class。
不能实例化T类型：
```
public class Pair<T>{
    private T first;
    private T last;
    public Pair(){
        //编译错误
        first = new T();
        last = new T();
    }
}
```
上述代码无法通过编译，因为构造方法的两行语句：
```
first = new first();
last = new last();
```
擦拭后实际上变成了：
```
first = new Object();
last = new Object();
```
这样一来，创建new Pair<String>()和创建new Pair<Integer>()就全部成了Object，显然编译器要阻止这种类型不对的代码。要实例化T类型，我们必须借助额外的Class<T>参数：
```
public class Pair<T>{
    private T first;
    private T last;
    public Pair(Class<T> cls){
        first = cls.newInstance();
        last = cls.newInstance();    
    }
}
```
上述代码借助Class<T>参数并通过反射来实例化T类型，使用的时候，也必须传入Class<T>。例如：
```
Pair<String> pair = new Pair<>(String.class);
```
因为传入Class<String>的实例，所以我们借助String.class就可以实例化String类型。

不恰当的覆写方法

有时候，一个看似正确定义的方法会无法通过编译，例如：

public class Pair<T> {
    public boolean equals(T t){
        return this==t;
    }
}

这是因为，定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自Object，编译器会阻止一个实际上会变成覆写的泛型方法定义。

换个方法名，避开与Object.equals(Object)的冲突就可以成功编译：

public class Pair<T>{
    public boolean same(T t){
        return this == t;
    }
}

泛型继承

一个类可以继承自一个泛型类。

例如，父类是Pair<Integer>，子类的类型是IntPair，可以这么继承：

public class IntPair extends Pair<Integer>{...}

使用的时候，因为子类IntPair并没有泛型类型，所以，正常使用即可：

IntPair ip = new IntPair(1,2);

前面讲了，我们无法获取Pair<T>的T类型，即给定一个变量Pair<Integer>p，无法从p中获取到Integer类型。

但是，在父类是泛型类型情况下，编译器就必须把类型T（对上一段来说，就是Integer类型）保存到子类class文件中，不然编译器就不知道IntPair只能存取Integer这种类型。

在继承了泛型类型的情况下，子类可以获取父类的泛型类型，不过获取父类的泛型类型代码比较复杂：

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first , T last){
        this.first = first;
        this.last = last;
    }
    public T getFirst(){
        return first;    
    }
    public T getLast(){
        return last;
    }
}

class IntPair extends Pairs<Integer>{
    public IntPair(Integer first,Integer last){
        super(first,last);
    }
}

Class<IntPair> cls = IntPair.class;
Type t = cls.getGenericSuperclass();
if(t instanceof ParameterizedType){
    ParameterizedType pt = (ParameterizedType) t;
    Type[] types = pt.getActualTypeArguments();//可能有多个泛型类型
    Type firstType = types[0];//取第一个泛型类型
    Class <?> typeClass = (Class<?>) firstType;
    System.out.println(typeClass);//Integer
}

因为Java引入了泛型，所以只用Class来标识类型已经不够了。实际上，Java的类型系统结构如下：

小结

Java泛型用擦拭法实现
擦拭法的局限性，对<T>来说：
1. 不能是基本类型，如int
2. 不能获取带泛型类型的Class
3. 不能判断带泛型类型的类型
4. 不能实例化T类型，如new T()
泛型的方法要防止覆写方法，如：public boolean equals(T obj)
子类可以获取父类的泛型类型<T>

总结

1、擦拭法——编译器看到的代码就是我们所写的、包含<T>的源代码；而JVM运行程序时，编译器把其中的所有<T>都视为Object，编译器根据我们写入的T进行强制转型：

//编写的代码
Pair <String> p = new Pair<> ("Hello","World");
String first = p.getFirst();

//执行时的代码
Pair p = new Pair("Hello","World");
String first = (String) p.getFirst();

2、对小结部分，第二部分擦拭法局限性的解释：

T不能是基本类型，因为转型时是转成Object类型；
不能获取泛型类型T的Class，因为不管T是什么，所有getClass()都返回同一个Class实例，因为编译后其实都是Pair<Object>；
无法判断泛型类对象的实际类型，例如：
```
if (p instanceof Pair<String>){...}//编译错误
```
因为不管T是什么，p在编译时都是Pair<Object>.class；
不能new T()，即使T是一个引用类型，因为编译时会编译成：
```
o = new Object();
```

3、 不能覆写父类中的方法，如果要实现相同功能，可以定义一个不同名的方法；

posted @ 2021-06-02 14:35 ShineLe 阅读(50) 评论(0) 收藏举报

刷新页面返回顶部

ShineLee

2021.6.2：擦拭法、泛型继承

1、擦拭法

不恰当的覆写方法

泛型继承

小结

总结

公告