笔试题总结——泛型通配符与类型擦除

川长思鸟来 2023-08-17 15:23 90阅读 0赞

## 笔试题总结——泛型通配符与类型擦除 ##

####   关于泛型通配符的相关概念，网上随便一搜一大堆，这里简单的说一下概念即可。 ####

>    ？ extends 类：取得泛型上限——可用在类或方法上，只能取得值，不能修改值  
>      用在类上：T extends 类：T必须为类或者类的子类（不能用？）  
>      用在方法上：？ extends 类：只能接收类或者其子类的泛型类，只能取得类中属性值，不能修改值  
>    ？ super 类：取得泛型下限——只能用于方法中，可以取得值，也可以修改值  
>      用在方法上：除了可以取值，也可以设置属性值  
>    ？：相当于是第一种情况的一个特例，实际上为? extends Object，但只能用于方法上，同样不能修改值。  
>      用在方法上：表示参数可以接收任意类型的泛型类，只能取得类中数据，不能修改数据。

####   这些概念是比较容易理解的。这里`特别说明一下`：取得值表现在类上就是getXX()方法，表现在方法上就是返回值，而设置值表现在类上就是setXX()方法，表现在方法上就是调用方法时的实参。 ####

####   但是，有没有想过下面几个问题： ####

>   **为什么使用上限(上界)通配符后，只能取得值而不能设置值？什么类型的值才能被设置？**  
>   **为什么使用下限(下界)通配符后，既能取得值也能设置值？取得的值是什么类型的？什么类型的值才能被设置**

####   解决上面几个问题前，先来看看类型擦除： ####

>   类型擦除：泛型信息只存在于代码编译阶段，在进⼊ JVM 之前，与泛型相关的信息会被擦除掉。（通俗地讲：**泛型类只存在于敲代码期间，当程序编译后泛型类就和普通类一模一样了**）

####   由于存在类型擦除的存在，我们可以得知：泛型的存在仅仅是为了编写阶段相对简单，实际上在进入JVM前就被类型擦除了。 ####

####   类型擦除的规则如下： ####

>   **若泛型类的类型参数若没有指定上限，会被擦除为Object类型。**  
>   **若指定了上限，则类型参数被替换为相应的类型上限。**

####   有了类型擦除的概念及规则，接下来一步步分析解答上面提出的几个问题。 ####

####   举例说明： ####

#####   先定义定义一个Eat类及其子类Fruit，以及Fruit的两个子类Apple和Banana。 #####

class Eat{
    	    public void description(){
    	        System.out.println("this is Eat");
        	}
    	}
    	
    	class Fruit extends Eat{
    	    public void description(){
    	        System.out.println("this is Fruit");
    	    }
    	}
    	
    	class Apple extends Fruit{
    	    public void description(){
    	        System.out.println("this is Apple");
    	    }
    	}
    	
    	class Banana extends Fruit{
    	    public void description(){
    	        System.out.println("this is Banana");
    	    }
    	}

####   再直面这些问题前，先看看当上下界泛型出现在集合中的情形。 ####

#####   创建一个addMethod1()函数测试泛型上限 #####

public static void addMethod1(List<? extends Fruit> list){
    		//	list.add(new Apple());
            Fruit fruit = list.get(0);
        }

#####   此时不能给list中添加值，由于类型参数已经指定了上界Fruit，只要是Fruit类或其子类都可以添加到List中，但编译器并不知道具体是哪个类的元素被添加进入，若允许添加在类型擦除后可能会导致类型错误。此时List的add()方法即为： #####

void add(? extends Fruit value)

#####   而当类型擦除后，实际上add()方法就变为了: #####

void add(Fruit value)

#####   这也就说明，此时只要是Fruit类及其子类的对象都可以加到该集合中，这明显与集合的定义矛盾。因此此时不允许对集合进行添加。 #####

#####   举个栗子：若先添加10个Apple对象，则该List在泛型擦除后就是一个包含10个Apple对象的集合，但若再添加1个Banana对象，Banana对象也是Fruit的子类，按照逻辑也是能添加进来的，但此时，这个List集合中既有Apple对象又有Banana对象，严重违背了集合的定义，因此不允许进行值的添加。 #####

#####   而从list中取得元素是没有问题的，由于编译器并不知道当前类到底是Fruit类还是其子类，因此取出的元素即为Fruit类。相当于此时List的get()方法变为了： #####

//	类型擦除前
    	? extends Fruit get();

#####   而当类型擦除后，实际上get()方法就变为了: #####

// 类型擦除后(若指定了上限，则类型参数被替换为相应的类型上限)
    	Fruit get();

#####   此时只要使用Fruit类的引用来接收get()的返回值即可。需要注意只能使用该类接收而不能使用子类接收(不满足向上转型) #####

#####   同样的创建一个addMethod2()函数测试泛型下限 #####

public static void addMethod2(List<? super Fruit> list){
    	        list.add(new Apple());
    			//	list.add(new Eat());
    	        Object object = list.get(0);
    	    }

#####   与泛型上限不同的是，此时可以给list中添加元素，但有一个要求，此时添加的对象必须是Fruit类及其子类的对象。同样的看一下此时List的add()方法： #####

void add(? super Fruit value)

#####   在类型擦除后，实际上add()方法就变为了: #####

void add(Object value)

#####   类型擦除完后，add()的形参变为了Object类型，但此时只能插入Fruit及其子类，虽然知道Fruit是基类，但并不知道是往上数多少级的基类。简单的讲，无论传入的这个类是Fruit类或其父类，若是Fruit类，Fruit类的集合中包含Fruit及其子类对象没有问题，若是Fruit类的父类，既然Fruit都是该类的子类，则Fruit的所有子类也是该类的子类，因此包含Fruit及其子类也没有问题。 #####

#####   但若不是Fruit及其子类则有明显的问题，根本不知道这个类与传入的类是什么关系，可能会导致类型错误。 #####

#####   说的还是不够清楚，举个栗子：如果现在这个集合最终的类为Eat类(Fruit类的父类)，则此时传入10个Fruit对象，10个Apple对象，10个Banana对象都是没有问题的。因为这些都是Eat类的子类(父类集合中可以存放子类对象—多态)。而若此时传入一个非Fruit及其子类(即Fruit的一个父类，假设存在为Water)，此时，Eat类和Water类之间的关系并不能确定，因此，不能直接将Water类的对象放在Eat类集合中，以免出现错误。 #####

#####   而从list中取得元素时取出来的对象类型只能是Object，由于编译器并不知道当前类到底是Fruit类还是其父类，因此不能直接赋值给Fruit类。相当于此时List的get()方法变为了： #####

//	类型擦除前
    	? super Fruit get();

#####   而当类型擦除后，实际上get()方法就变为了: #####

// 类型擦除后(若泛型类的类型参数若没有指定上限，会被擦除为Object类型)
    	Object get();

#####   由此也就不难理解为何返回的类型是Object了。 #####

####   现在再看上面的问题就很容易理解了。只需要注意类型擦除前后的结果即可（依旧用上面Fruit的例子）。 ####

#####   泛型上限时，实际上setXX()与getXX()变为了： #####

//	类型擦除前
    	void setXX(? extends Fruit fruit);
    	? extends Fruit getXX();

#####   而当类型擦除后，实际上get()方法就变为了: #####

//	类型擦除后
    	void setXX(Fruit fruit);
    	Fruit getXX();

#####   对于setXX(Fruit fruit)来说，形参为Fruit类，也就是说只要传入的对象是Fruit类及其子类都可以，而并不知道Fruit类及其子类与当前类的到底有没有关系，因此会产生类型错误。 #####

#####   举个栗子： #####

class Person<T>{
    	    private T first;
    	
    	    public T getFirst() {
    	        return first;
    	    }
    	
    	    public void setFirst(T first) {
    	        this.first = first;
    	    }
    	}
    	
    	public static void main(String[] args) {
    	        Person<? extends Fruit> person = new Person<>();
    	        //	不能设置值
    	        //	person.setFirst(new Fruit());
    	        person.getFirst();
    	 }

#####   此时在Person内部解析的setFirst()只知道当前的类型是Fruit类型或其子类，但到底是哪个子类也不得而知，因此，若Person内部是Apple(Fruit的一个子类)，而此时外部传了一个Fruit对象，此时就导致了严重的对象类型错误。(不符合多态) #####

#####   此时对于getFirst()来说，无论Person内部是Fruit的哪一个子类，但都会是Fruit的子类，因此外部使用Fruit引用接收Fruit或其子类对象是没有问题的。 #####

#####   同样的，对于泛型下限来说，实际的setXX与getXX变为了： #####

//	类型擦除前
    	void set(? super Fruit fruit)
    	? super Fruit get();

#####   而当类型擦除后，实际上get()方法就变为了: #####

// 类型擦除后(若泛型类的类型参数若没有指定上限，会被擦除为Object类型)
    	void set(Object fruit)
    	Object get();

#####   对于setXX(Fruit fruit)来说，形参为Object类，也就是Fruit的父类，而此时传入的对象只能是Fruit及其子类，Fruit的父类一定是Fruit及其子类的父类，但不能传入Fruit的父类，因为并不知道当前的形参类型(Fruit的父类)与实参类型(Fruit的父类)到底是什么关系。(一个类的两个父类之间关系无法确定) #####

public static void main(String[] args) {
            Person<? super Fruit> person = new Person<>();
            person.setFirst(new Fruit());
            person.getFirst();
        }

#####   而在getXX()上，很明显经过类型擦除后返回的值只能用Object类型来接收，因为根本不知道返回的是Fruit的哪个父类，所以没有一个确定的值，用Object统一接收即可。 #####

####   本文参考：[泛型上下界通配符][Link 1] ####

[Link 1]: https://my.oschina.net/u/2278977/blog/820771