28.Android架构-泛型通配符

我们有一下几个类，一个Fruit，一个Apple，Apple 继承 Fruit,是Fruit的子类。还有一个Plate（盘子）接口，用来装水果，ApplePlate类，专门装苹果


interface Plate<R>{
    void set(R r);
    R get();
}

class ApplePlate implements Plate<Apple> {
    @Override
    public void set(Apple apple) {

    }

    @Override
    public Apple get() {
        return null;
    }
}


class Fruit{

}

class Apple extends Fruit{
    @Override
    public String toString() {
        return super.toString();
    }
}

我通过泛型指定了这个盘子是用来装苹果的

    public static void main(String[] args) {
        Plate<Apple> applePlate = new ApplePlate<>();
    }

假如这个时候，我苹果吃完了，我就想用这个AppPlate去装其他水果，可不可以呢？因为所有的水果都继承自Fruit,所以我要把这个苹果AppPlate强转成装水果的Plate,但是直接在编译期就报错了，无法进行强转这是为什么呢？我们知道可以强转的两个类应该符合A is a B的关系，A才能强转成B,那么Apple继承自Fruit,Apple is a Fruit是符合的，但是Plate<Apple>满足is a Plate<Fruit> 的关系吗，答案是否定的。给定两种具体的类型A和B(例如Fruit和Apple), 无论A和B是否相关， MyClass<A>与MyClass<B>都没半毛钱关系，它们的公共父对象是Object

public static Plate<Fruit> getFruitPlate(Plate<Apple> plate){
        Plate<Fruit> fruitPlate = plate;  //错误
        return fruitPlate;
    }

只有满足下边这种关系，才能说他们有is a 的关系

图片.png

上界通配符<? extends R>：能取不能存

那么如何让水果盘子和苹果盘子直接发生关系呢，答案就是通配符<?>

我们把getFruitPlate方法改造一下

public static Plate<? extends Fruit> getFruitPlate(Plate<Apple> plate){
        Plate<? extends Fruit> fruitPlate = plate;
        return fruitPlate;
    }

Plate<? extends Fruit>叫上限通配符，他是Plate<Fruit> 和Plate<Apple>的基类，所以用子类给基类赋值是行得通的。他限定的是上边界Fruit,只有Fruit及其子类可以作为<? extends Fruit>的子类，从而实现赋值

图片.png

那么转成Plate<? extends Fruit>之后，我是不是可以往他里边放水果了，比如apple或者其他fruit类型，然后并非这样。如何解释呢，其实可以这样理解，既然Plate<? extends Fruit>是Plate<Fruit> 和Plate<Apple>的基类，那么其实他的真正类型只有在运行时才能确定，那么所以他的类型可能是Apple也可能是Orange等等Fruit的其他子类，所以这个情况下，他的真正类型是不确定的，所以无法往里边set,但是有一点，无论他的真正类型是什么，他都是一种Fruit,所以通过get方法取是可以的

public static Plate<? extends Fruit> getFruitPlate(Plate<Apple> plate){
        Plate<? extends Fruit> fruitPlate = plate;
        fruitPlate.set(new Apple());  //报错
        Fruit fruit = fruitPlate.get();  //正确
        return fruitPlate;
    }

那么有没有办法破解这个问题呢，有的，反射。但是比较危险，见下图

图片.png

下界通配符<? super R>：能存不能取

下界通配符限定的是下边界，如下图，Plate<? super Fruit>是Plate<Fruit>的基类

图片.png

我们再增加一个类型Food,水果Fruit也属于Food的一种，所以Fruit继承自Food

class Food{
    
}

class Fruit extends Food{

}

class Apple extends Fruit{
    @Override
    public String toString() {
        return super.toString();
    }
}

增加一个放Food的盘子FoodPlate

class FoodPlate implements Plate<Food> {

    @Override
    public void set(Food food) {
        
    }

    @Override
    public Food get() {
        return null;
    }

}

图片.png

可以看到，可以往里边放Apple Banana等水果，因为无论是哪种水果，都是属于Fruit类型，但是往外取的时候，泛型信息丢失了，只能通过Object接收了

<?> ：不能存也不能取

Plate<?>其实就是Plate<? extends Object>

总结：Java泛型PECS原则

如果你只需要从集合中获得类型T , 使用<? extends T>通配符
如果你只需要将类型T放到集合中, 使用<? super T>通配符
如果你既要获取又要放置元素，则不使用任何通配符。例如List<Apple>
PECS即 Producer extends Consumer super，为了便于记忆。

为何要PECS原则？提升了API的灵活性

应用java.util.Collections类中的copy方法

为什么dest要使用<? super T> 而src要使用<? extends T>？就是因为要从src里取出，存在dest里

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

通过一个例子来加深对上界和下届范型通配符的理解

仍然通过上边提到的那几个类来说明,我们写下这样几行代码

        //? extends Employee 表示只要是 Employee 的子类，都可以在初始化的时
        //候设置进来，并设置一个标识 CAP#1,而不是具体的子类类型，就像。  ArrayList和
        //LinkedArrayList可以赋值给List
        Plate<? extends Fruit> plate = new ApplePlate();
        //在获取的时候，我虽然不知道它具体是什么类型，但他一定是Fruit或其子
        //类，所以一定可以把他赋值给他的父类Fruit，父类引用指向子类对象
        Fruit fruit = plate.get();
        //给这个对象添加具体类型的子类时，因为子类型与标识 CAP#1 没法匹配，所以就不允许添加
        plate.set(new Apple());//编译出错

        //大家会产生一个问题，我们明明放的就是 Apple 类型,为什么获取出来
        //的数据还得需要我们强转
        // 因为 super 指的是父类，只要是Manager 的父类都可以，所以在设置参
        //数的情况下，不报错，因为 Employee 是Manager 的父类
        // 但是 我们在获取的情况就不一样的，获取出来时，编译器不知到是哪个父
        //类，所以就统一采取了 Object 超类作为返回值，而在set 时，编译器可以
        //半确定，肯定就是 Manager 本身或其父类并且父类顶端就是 Object， 所
        //以用 set 的时, 只能够将数据保存到 Object 对象上。
        Plate<? super Fruit> plate1 = new FoodPlate();
        plate1.set(new Apple());
        Object object = plate1.get();//设置的Apple，获取到了Object