我们有一下几个类，一个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
网友评论