泛型——通配符

? 在泛型中使用，即为通配符

1. 通配符解决的问题

示例：

class Message<T> {
    private T message;

    public T getMessage() {
        return message;
    }

    public void setMessage(T message) {
        this.message =message;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Message<String> message = new Message<String>();
        message.setMessage("我是字符串");
        fun(message);
    }
    public static void fun(Message<String> temp) {
        System.out.println(temp.getMessage());
    }
}

上述程序中 fun() 方法若传入一个Integer类型，就会报错

为使 fun() 方法可以接收所有的泛型类型，就需要使用通配符 ? 来处理：

使用通配符有一个问题，就是此时通配符可以接收任意类型，由于不确定类型，所以无法进行修改：

在 ? 的基础上又产生了两个 子通配符：

? extends 类：设置通配符上界

? super 类：设置通配符下界

2. 通配符的上界

语法：

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

 

示例：

class Food {}
class Fruit extends Food {}
class Apple extends Fruit {}
class Banana extends Fruit {}

class Message<T> {
    private T message;

    public T getMessage() {
        return message;
    }

    public void setMessage(T message) {
        this.message =message;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Message<Apple> message1 = new Message<>();
        message1.setMessage(new Apple());
        fun(message1);

        Message<Banana> message2 = new Message<>();
        message2.setMessage(new Banana());
        fun(message2);
    }
    public static void fun(Message<? extends Fruit> temp) {
        //temp.setMessage(new Banana()); //无法修改！
        //temp.setMessage(new Apple()); //无法修改！
        System.out.println(temp.getMessage());
    }
}

此时无法在fun() 方法中对temp添加元素，因为temp接收的是Fruit和它的子类，此时存储的元素应该是哪个子类无法确定，所以添加会报错。但是获取元素没问题：

    public static void fun(Message<? extends Fruit> temp) {
        //temp.setMessage(new Banana()); //无法修改！
        //temp.setMessage(new Apple()); //无法修改！
        Fruit b = temp.getMessage();//可以获取元素
        System.out.println(b);
    }

通配符的上界，不能进行写入数据，只能进行读取数据

3. 通配符的下界

语法：

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

示例：

class Food {}
class Fruit extends Food {}
class Apple extends Fruit {}

class Plate<T> {
    private T plate ;
    public T getPlate() {
        return plate;
    }
    public void setPlate(T plate) {
        this.plate = plate;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Plate<Fruit> plate1 = new Plate<>();
        plate1.setPlate(new Fruit());
        fun(plate1);
        
        Plate<Food> plate2 = new Plate<>();
        plate2.setPlate(new Food());
        fun(plate2);
    }
    public static void fun(Plate<? super Fruit> temp){
        // 此时可以修改！！添加的是Fruit 或者Fruit的子类
        temp.setPlate(new Apple());//这个是Fruit的子类
        temp.setPlate(new Fruit());//这个是Fruit的本身
        //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate());//只能直接输出
    }
}

通配符的下界，不能进行读取数据，只能写入数据