【泛型】泛型上下边界

上一篇 【泛型】通配符与嵌套
通配符可以是任意类类型，在实际业务中使用通配符时，可能会遇到很多安全问题，如传入的泛型类没有特定的方法或属性，类型转换错误等。为了防止这些问题的发生，就有了上下边界，用于指定通配符的范围。

1 泛型上限extends

上限extends指定的类型必须是继承某个类，或者某个接口，即<=，如

? extends Fruit
T extends List

// 容器类（装食物用）
public class Container<T> {
    private T obj;

    public Container(){}

    public Container(T obj){
        this.obj = obj;
    }

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

示例类：

public class Food<T> {
    private T obj;
    public Food(T obj){
        this.obj = obj;
    }
    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}
public class Fruit<T> extends Food{
    public Fruit(T obj) {
        super(obj);
    }
}
public class Apple<T> extends Fruit{
    public Apple(T obj) {
        super(obj);
    }
}
public class Banana<T> extends Fruit{
    public Banana(T obj) {
        super(obj);
    }
}

public class Meat<T> extends Food{ 
    public Meat(T obj) {
        super(obj);
    }
}
public class Pork<T> extends Meat{
    public Pork(T obj) {
        super(obj);
    }
}

调用

// 主函数
public static void main(String[] strs) {
          // 水果盘
        Container<Fruit> fruits = new Container<Fruit>();
        // 香蕉篮
        Container<Banana> bananas = new Container<Banana>();
        // 菜盘
        Container<Pork> porks = new Container<Pork>();
        // 一个水果
        Fruit fruit = new Fruit("水果");
        // 一根香蕉
        Banana banana = new Banana("香蕉");
        // 一个苹果
        Apple apple = new Apple("苹果");
        // 一块猪肉
        Pork pork = new Pork("土猪肉");
        Meat meat = new Meat("肉");

        // 把洗好的水果装盘
        fruits.setObj(fruit);
        fruits.setObj(apple);
        bananas.setObj(banana);

        Container<? super Meat> container = new Container<>();
        container.setObj(pork);

        Container<? extends Meat> container1= new Container<>();
        //container1.setObj(meat);会报错

        // 把炒好的土猪肉装盘
        porks.setObj(pork);
}

2 泛型下限super

? super 指定类型

指定类型不能小于操作的类，即指定类型或指定类型的父类…父类的父类最终至Object，且不能为任意父类的其他子类。

// 加菜
public static void addDish(Container<? super Meat> container) {
    // 装土猪肉
    container.setObj(new Pork("土猪肉"));
    // 装牛肉
    container.setObj(new Pork("烤肥牛"));
}

// 主函数
public static void main(String[] strs) {
    // 菜盘 
    Container<Food> foods = new Container<Food>();
    // 专用装肉盘 
    Container<Meat> meats = new Container<Meat>();
    // 水果篮
    Container<Fruit> fruits = new Container<Fruit>();
        
    // 我们吃饭的时候菜吃完，所以我们加菜
    // 厨师准备用盘子装菜
        
    // 用菜盘装菜
    addDish(foods);
    // 用专用装肉盘装菜
    addDish(meats);
    // 但不能用水果篮装菜，一使用编译器就会提示我们异常
//    addDish(fruits);
}

总结

这两种方式基本上解决了之前所说的问题，但是同时，也有一定的限制。

1.上限<? extends T>不能往里存，只能往外取 (即：只能get)

因为编译器只知道容器里的是Fruit或者Fruit的子类，但不知道它具体是什么类型，所以存的时候，无法判断是否要存入的数据的类型与容器种的类型一致，所以会拒绝set操作。

2.下限<? super T>往外取只能赋值给Object变量，不影响往里存

因为编译器只知道它是Fruit或者它的父类，这样实际上是放松了类型限制，Fruit的父类一直到Object类型的对象都可以往里存，但是取的时候，就只能当成Object对象使用了。

所以如果需要经常往外读，则使用<? extends T>，如果需要经常往外取，则使用<? super T>。

参考：

1. https://www.jianshu.com/p/0c318bb54502
2. https://zhuanlan.zhihu.com/p/97517915