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>。
