image

泛型上下边界

作用

先从通配符'?'说起，已知通配符可以是任意类类型，在实际业务或功中在使用通配符时会遇到很多安全问题如：传入的泛型类没有特定的方法或属性，类型转换错误等等。所以为了防止这些问题的发生，就有了上下边界，用于指定通配符的范围。

上边界

关键字 ==extends== : 通配符('?')类型必须继承指定的某个类(class)，或实现某个接口(interface)。

// 上边界指定格式
? extends 指定类型(可以是类也可以是接口)

// 要求
class ? extends 指定类
// 或
class ? implements 指定接口

// 要求继承指定类且必须实现指定接口
? extends 指定类&指定接口
// 如下
? extends A&B

==范围== : 指定类型或指定类型的子类

示例

一图胜千言：

Image text

示例类：

// 食物
class Food { }

// 肉
class Meat extends Food { }
// 猪肉
class Pork extends Meat { }
// 牛肉
class Beef extends Meat { }

// 水果
class Fruit extends Food { }
// 苹果
class Apple extends Fruit { }
// 香蕉
class Banana extends Fruit { }
// 青苹果
class GreenApple extends Apple { }
// 红苹果
class RedApple extends Apple { }

// 容器类（装食物用）
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 static void eatFruit(Container<? extends Fruit> container) {
    // 取出水果
    Fruit obj = container.getObj();
    // 打印
    System.out.println("我正在吃" + obj.getName());
}

// 吃肉
public static void eatMeat(Container<? extends Meat> container) {
    // 取出肉
    Meat obj = container.getObj();
    // 打印
    System.out.println("我正在吃" + obj.getName());
}

// 主函数
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("土猪肉");

    // 把洗好的水果装盘
    fruits.setObj(fruit);
    fruits.setObj(apple);
    bananas.setObj(banana);
    
    // 把炒好的土猪肉装盘
    porks.setObj(pork);
    
    // 调用一下吃水果的方法进行吃水果
    eatFruit(fruits);
    // 调用一下吃水果的方法进行吃香蕉
    eatFruit(bananas);
    
    // 调用一下吃水果的方法进行吃猪肉，这个时候编译器就会提示异常
    // 因为吃水果的方法进行了上限的设置
//    eatFruit(porks);
    // 所以吃肉的就得使用吃肉的方法
    eatMeat(porks);
}

==注== : 当设定上限后只能读取内容(即：get)，不能往里添加内容(即：set)

例：在上述吃水果的方法中不能往里添加新的水果，否则编译器将会提示异常

---

下边界

关键字 ==super== : 指定的类型不能小于操作的类，即指定类及其父类

? super 指定类型

==范围== : 指定类型或指定类型的父类...父类的父类最终至Object，且不能为任意父类的其他子类

示例

一图胜千言：

Image text

示例类：

// 上限中的示例类

代码逻辑：

// 加菜
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);
}

==注== : 当设定下限后只能添加内容(即：set)，而取的话只能为Object类型，不能为具体类型

例：在上述装菜的方法中不能从盘子里取出具体菜(即：只能是Object类型的菜)，否则编译器将会提示异常

---

总结

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

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

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

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

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

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