泛型知识：擦除，extend和super

约定不等于承诺〃 2022-05-17 10:45 155阅读 0赞

## **一：擦除** ##

要理解super和extends的边界问题，首先要理解消除。   
先看一个有趣的例子：

public class Abrasion {
        public static void main(String[] args) {
            Class a = new ArrayList<Integer>().getClass();
            Class b = new ArrayList<String>().getClass();
    
            System.out.println(a == b);
        }
    }

结果如下：

true

明明a是Integer的，b是String的，为什么打印出他们是同一种类型呢？   
**因为在泛型代码内部，无法获取任何有关泛型参数类型的任何信息！，Java的泛型就是使用擦除来实现的**，当你在使用泛型的时候，任何信息都被擦除，你所知道的就是你在使用一个对象。所以List< Integer>和List< String>在运行时，会被擦除成他们的原生类型List。

再通过这个例子加深一下擦除的理解：

class Hello{
        public void hello(){
            System.out.println("hello");
        }
    }
    
    class TestHello<T>{
        private T t;
        public TestHello(T t){
            this.t = t;
        }
        public void callHello(){
            t.hello();//这里不能编译
        }
    }
    
    public class Abrasion {
        public static void main(String[] args) {
            Hello hello = new Hello();
            TestHello<Hello> testHello = new TestHello<>(hello);
            testHello.callHello();
        }
    }

我们可以看到，t.hello()这里是不能够编译的。因为擦除的存在，main中传入的泛型，在TestHello中编程了Object，因此并不能跟Hello这个类绑定，也就调用不了hello方法。   
那能够怎么让object调用hello的方法？   
可以给定泛型的边界，把类TestHello< T>改为TestHello< T extends Hello>，这个边界声明了T必须具有类型Hello或者从Hello导出的类型。

## **二：擦除带来的问题** ##

泛型不能用于显性地引用运行时类型的操作之中，例如转型，instanceof和new操作（包括new一个对象，new一个数组），因为所有关于参数的类型信息都在运行时丢失了，所以任何在运行时需要获取类型信息的操作都无法进行工作。

如下：

if(obj instanceof T);
    T t = new T();
    T[] ts = new T[10];

## **三：解决擦除带来的问题** ##

### **1.解决instanceof** ###

使用instanceof会失败，是因为类型信息已经被擦除，因此我们可以引入类型标签Class< T>，就可以转用动态的isInstance()。

class A{}
    class B extends A{}
    
    public class TestInstance<T> {
        private Class<T> t;
        public TestInstance(Class<T> t){
            this.t = t;
        }
    
        public boolean compare(Object obj){
            return t.isInstance(obj);
        }
    
        public static void main(String[] args) {
            TestInstance<A> ti = new TestInstance<A>(A.class);
            System.out.println(ti.compare(new A()));
            System.out.println(ti.compare(new B()));
        }
    }

结果如下：

true
    true

### **2.解决创建类型实例** ###

解决办法是使用工厂

interface Factory<T>{
        T create();
    }
    
    class Product<T>{
        public <F extends Factory<T>> Product(F factory){
            factory.create();
        }
    }
    
    class ProductFactory implements Factory<Integer>{
        public Integer create(){
            Integer integer = new Integer(10);
            System.out.println(integer);
            return integer;
        }
    }
    public class TestNew {
        public static void main(String[] args) {
            new Product(new ProductFactory());
        }
    }

结果如下：

*  1

### **3.解决创建泛型数组** ###

不能创建泛型数组的情况下，一般的解决方案是使用ArrayList代替泛型数组。因为ArrayList内部就是使用数组，因此使用ArrayList能够获取数组的行为，和由泛型提供的编译器的类型安全。   
但是假如，某种特定的场合，你仍然要使用泛型数组，推荐的方式是使用类型标签＋Array.newInstance来实现，并用注解@SuppressWarnings(“unchecked”)抑制住警告

public class TestInstance<T> {
        private Class<T> t;
        public TestInstance(Class<T> t){
            this.t = t;
        }
    
        @SuppressWarnings("unchecked")
        T[] create(int size){
            return (T[]) Array.newInstance(t, 10);
        }
    
        public static void main(String[] args) {
            TestInstance<Integer> ti = new TestInstance<Integer>(Integer.class);
            Integer[] as = ti.create(10);
            System.out.println(as.length);
        }
    }

结果如下：

*  1

## **四：边界** ##

正是因为有了擦除，把类型信息擦除了，所以，用无界泛型参数调用的方法只是那些可以用object调用的方法。但是，如果给定边界，将这个参数限制为某个类型的子集，就可以使用这些类型子集来调用方法。

interface Dog{
        void shout();
    }
    
    public class TestBorder<T extends Dog> {
        T t;
        public TestBorder(T t){
            this.t = t;
        }
        public void test(){
            t.shout();
        }
    }

可见，类型T已经可以调用Dog的shout方法了。

当然，也可以指定多个边界

interface Dog{
        void shout();
    }
    
    interface Cat{
        void run();
    }
    
    interface Pig{
        void eat();
    }
    
    public class TestBorder<T extends Dog & Cat & Pig> {
        T t;
        public TestBorder(T t){
            this.t = t;
        }
        public void test(){
            t.shout();
            t.run();
            t.eat();
        }
    }

这里需要注意的是，extends 后面跟的第一个边界，可以为类或接口，之后的均为接口。

## **五：通配符和泛型上界和下界** ##

### **1.上界< ? extends Class>** ###

class Fruit{}
    class Apple extends Fruit{}
    class Orange extends Fruit{}
    
    public class TestBuChang<T>{
    
        public static void main(String[] args) {
            List<? extends Fruit> list = new ArrayList<>();
            //list.add(new Apple());
            //list.add(new Orange());
            //list.add(new Fruit());
            list.add(null);
    
            list.contains(new Apple());
            list.indexOf(new Apple());
    
            Apple apple = list.get(0);
        }
    }

可见，指定了下边界，却不能add任何类型，甚至Object都不行，除了null，因为null代表任何类型。List< ? extends Fruit>可以解读为，“具有任何从Fruit继承的类型”，但实际上，它意味着，它没有指定具体类型。对于编译器来说，当你指定了一个List< ? extends Fruit>，add的参数也变成了“? extends Fruit”。因此编译器并不能了解这里到底需要哪种Fruit的子类型，因此他不会接受任何类型的Fruit。

然而，contain和indexof却能执行，这是因为，这两个方法的参数是Object，不涉及任何的通配符，所以编译器允许它调用。

list.get(0)能够执行是因为，当item在此list存在时，编译器能够确定他是Apple的子类，所以能够安全获得。

### **2.下界< ? super Class>** ###

< ? super Class>表示，指定类的基类。

class Fruit{}
    class Apple extends Fruit{}
    class Apple1 extends Apple{}
    class Orange extends Fruit{}
    
    public class TestBuChang<T>{
    
        public static void main(String[] args) {
            List<? super Apple> list = new ArrayList<>();
            list.add(new Apple());
            list.add(new Apple1());
            //list.add(new Fruit());
    
            Object apple = list.get(0);
        }
    }

这里可以看到，list.add(new Fruit())这句不能编译成功，这是因为，List< ? super Apple>表示“具有Apple的父类的列表”。但是为什么add(new Fruit())不能成功呢？正是因为？代表Apple的父类，但是编译器不知道你要添加哪种Apple的父类，因此不能安全地添加。   
对于super，get返回的是Object，因为编译器不能确定列表中的是Apple的哪个子类，所以只能返回Object。   
**有网友不能理解这里， 重新再解释一下：**

> 1.  List < ? super Apple>， 代表容器内存放的是Apple的所有父类，所以有多态和上转型，这个容器时可以接受所有Apple父类的子类的。（多态的定义：父类可以接受子类型对象）Apple和Apple1都直接或间接继承了Fruit，所以Apple和Apple1是能够加入List < ? super Apple>这个容器的。
> 2.  list.add(new Fruit())不能添加，正是因为第1点解释的，容器内存放的是Apple的**所有父类**，注意 **所有** 这个词，正是因为能存放所有，Apple的父类可能有Fruit1， Fruit2， Fruit3 ， 所以编译器根本不能识别你要存放哪个Apple的父类，因为这不能保证类型安全的原则。这从最后的Object apple = list.get(0)可以看出。

### **3.PECS原则** ###

如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)   
如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)   
如果既要存又要取，那么就不要使用任何通配符。