java中的泛型、协变、逆变、不变

本是古典何须时尚 2023-01-10 05:25 191阅读 0赞

# java中的泛型 #

先看下面一段java代码：

package com.morris.kotlin.generics;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class JavaGeneric { 
    
        public static void main(String[] args) { 
    
    		Animal a = new Cat();
            List<Cat> cats = new ArrayList<>();
            List<Animal> list = cats; // type mismatch
    
            List<? extends Animal> list = cats;
            Animal animal = list.get(0);
            list.add(new Cat()); // error
        }
    
    }
    
    class Animal { 
    }
    
    class Cat extends Animal { 
    }
    
    class Dog extends Animal { 
    }

疑问：

*  `Animal a = new Cat();`可以编译通过，为什么`List<Animal> cats = new ArrayList<Cat>();`不能？
 *  `List<? extends Animal>`为什么不能添加元素？

## 里氏替换原则（LSP） ##

定义如下：所有引用基类（父类）的地方必须能透明地使用其子类的对象。

里氏替换原则包含以下四层含义：

1.  子类完全拥有父类的方法，且具体子类必须实现父类的抽象方法。
2.  子类中可以增加自己的方法。
3.  当子类覆盖或实现父类的方法时，方法的形参要比父类方法的更为宽松（协变）。
4.  当子类覆盖或实现父类的方法时，方法的返回值要比父类更严格（逆变）。

## 不变、协变、逆变 ##

在java中泛型是不变的，所以`List<Cat>`不是`List<Animal>`的子类，所以`List<Animal> cats = new ArrayList<Cat>();`不能编译通过。

可有时需要实现逆变与协变，怎么办呢？这时，通配符?派上了用场：

`<? extends>`实现了泛型的协变，比如：`List<? extends Animal> list = new ArrayList<Cat>();`

`<? super>`实现了泛型的逆变，比如：`List<? super Animal> list = new ArrayList<Object>();`

## extends与super ##

`List<? extends Animal>`为什么不能添加元素？首先，我们看看add的实现：

public interface List<E> extends Collection<E> { 
        boolean add(E e);
    }

在调用add方法时，泛型E自动变成了<? extends Animal>，其表示list所持有的类型为在Animal与Animal派生子类中的某一类型，其中包含Cat类型却又不特指为Cat类型，故add Cat时发生编译错误。为了能调用add方法，可以用super关键字实现：

List<? super Animal> list2 = new ArrayList<>();
    list2.add(new Cat());
    list2.add(new Dog());

`<? super Animal>`表示list所持有的类型为在Animal与Animal的基类中的某一类型，其中Cat与Dog必定为这某一类型的子类；所以add方法能被正确调用。

从上面的例子可以看出，`extends`确定了泛型的上界，而`super`确定了泛型的下界。

## PECS ##

现在问题来了：究竟什么时候用extends什么时候用super呢？《Effective Java》给出了答案：

PECS: producer-extends, consumer-super。

比如，一个简单的Stack API：

public class  Stack<E>{ 
        public Stack();
        public void push(E e):
        public E pop();
        public boolean isEmpty();
    }

要实现`pushAll(Iterable<E> src)`方法，将src的元素逐一入栈：

public void pushAll(Iterable<E> src){ 
        for(E e : src)
            push(e)
    }

假设有一个实例化`Stack<Animal>`的对象stack，src有`Iterable<Cat>`与`Iterable<Dog>`；在调用pushAll方法时会发生`type mismatch`错误，因为Java中泛型是不可变的，`Iterable<Integer>`与`Iterable<Float>`都不是`Iterable<Number>`的子类型。因此，应改为

// Wildcard type for parameter that serves as an E producer
    public void pushAll(Iterable<? extends E> src) { 
        for (E e : src)
            push(e);
    }

要实现`popAll(Collection<E> dst)`方法，将Stack中的元素依次取出add到dst中，如果不用通配符实现：

// popAll method without wildcard type - deficient!
    public void popAll(Collection<E> dst) { 
        while (!isEmpty())
            dst.add(pop());
    }

同样地，假设有一个实例化`Stack<Animal>`的对象stack，dst为`Collection<Object>`；调用popAll方法是会发生`type mismatch`错误，因为`Collection<Object>`不是`Collection<Animal>`的父类型。因而，应改为：

// Wildcard type for parameter that serves as an E consumer
    public void popAll(Collection<? super E> dst) { 
        while (!isEmpty())
            dst.add(pop());
    }

在上述例子中，在调用pushAll方法时生产了E实例（produces E instances），在调用popAll方法时dst消费了E实例（consumes E instances）。

java.util.Collections的copy方法(JDK1.7)完美地诠释了PECS：

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

PECS总结：

*  要从泛型类取数据时，用extends；
 *  要往泛型类写数据时，用super；
 *  既要取又要写，就不用通配符（即extends与super都不用）。