Java泛型上下边界

蔚落 2024-04-01 12:13 94阅读 0赞

## 泛型上下边界 ##

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

## 泛型上限extends ##

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

? extends Fruit
    T extends List

![d00b9b59528310eae769916b6df55bf5.png][]

容器类：

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);
    }

## 泛型下限super ##

? super 指定类型

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

![e4ac065d9e4392a857634ee8d9bc333a.png][]

// 加菜
    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>。

[d00b9b59528310eae769916b6df55bf5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/381bfbc0925740aab297336fb32af1c5.png
[e4ac065d9e4392a857634ee8d9bc333a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/de7d456cbee34dd0ada214af62e73455.png