资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划,从策略到执行的一站式服务

怎么理解Java中的逆变与协变-创新互联

这篇文章主要介绍“怎么理解Java中的逆变与协变”,在日常操作中,相信很多人在怎么理解Java中的逆变与协变问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”怎么理解Java中的逆变与协变”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

创新互联公司自2013年创立以来,是专业互联网技术服务公司,拥有项目网站建设、成都网站设计网站策划,项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命,1280元思茅做网站,已为上家服务,为思茅各地企业和个人服务,联系电话:13518219792

1. 逆变与协变

在介绍逆变与协变之前,先引入Liskov替换原则(Liskov Substitution Principle, LSP)。

Liskov替换原则

LSP由Barbara Liskov于1987年提出,其定义如下:

所有引用基类(父类)的地方必须能透明地使用其子类的对象。

LSP包含以下四层含义:

  • 子类完全拥有父类的方法,且具体子类必须实现父类的抽象方法。

  • 子类中可以增加自己的方法。

  • 当子类覆盖或实现父类的方法时,方法的形参要比父类方法的更为宽松。

  • 当子类覆盖或实现父类的方法时,方法的返回值要比父类更严格。

  • 前面的两层含义比较好理解,后面的两层含义会在下文中详细解释。根据LSP,我们在实例化对象的时候,可以用其子类进行实例化,比如:

    Number num = new Integer(1);

    定义

    逆变与协变用来描述类型转换(type transformation)后的继承关系,其定义:如果A、B表示类型,f(⋅)表示类型转换,≤表示继承关系(比如,A≤B表示A是由B派生出来的子类);

  • f(⋅)是逆变(contravariant)的,当A≤B时有f(B)≤f(A)成立;

  • f(⋅)是协变(covariant)的,当A≤B时有f(A)≤f(B)成立;

  • f(⋅)是不变(invariant)的,当A≤B时上述两个式子均不成立,即f(A)与f(B)相互之间没有继承关系。

  • 类型转换

    接下来,我们看看Java中的常见类型转换的协变性、逆变性或不变性。

    泛型:

    令f(A)=ArrayList,那么f(⋅)时逆变、协变还是不变的呢?如果是逆变,则ArrayList是ArrayList的父类型;如果是协变,则ArrayList是ArrayList的子类型;如果是不变,二者没有相互继承关系。开篇代码中用ArrayList实例化list的对象错误,则说明泛型是不变的。

    数组:

    令f(A)=[]A,容易证明数组是协变的:

    Number[] numbers = new Integer[3];

    调用方法result = method(n);根据Liskov替换原则,传入形参n的类型应为method形参的子类型,即typeof(n)≤typeof(method's parameter);result应为method返回值的基类型,即typeof(methods's return)≤typeof(result):

    static Number method(Number num) {
        return 1;
    }
    Object result = method(new Integer(2)); //correct
    Number result = method(new Object()); //error
    Integer result = method(new Integer(2)); //error

    在Java 1.4中,子类覆盖(override)父类方法时,形参与返回值的类型必须与父类保持一致:

    class Super {
        Number method(Number n) { ... }
    }
    class Sub extends Super {
        @Override 
        Number method(Number n) { ... }
    }

    从Java 1.5开始,子类覆盖父类方法时允许协变返回更为具体的类型:

    class Super {
        Number method(Number n) { ... }
    }
    class Sub extends Super {
        @Override 
        Integer method(Number n) { ... }
    }

    2. 泛型中的通配符

    实现泛型的协变与逆变

    Java中泛型是不变的,可有时需要实现逆变与协变,怎么办呢?这时,通配符?派上了用场:

    实现了泛型的协变,比如:

    List list = new ArrayList();

    实现了泛型的逆变,比如:

    List list = new ArrayList();

    extends与super

    为什么(开篇代码中)List list在add Integer和Float会发生编译错误?首先,我们看看add的实现:

    public interface Listextends Collection{
        boolean add(E e);
    }

    在调用add方法时,泛型E自动变成了,其表示list所持有的类型为在Number与Number派生子类中的某一类型,其中包含Integer类型却又不特指为Integer类型(Integer像个备胎一样!!!),故add Integer时发生编译错误。为了能调用add方法,可以用super关键字实现:

    List list = new ArrayList();
    list.add(new Integer(1));
    list.add(new Float(1.2f));

    表示list所持有的类型为在Number与Number的基类中的某一类型,其中Integer与Float必定为这某一类型的子类;所以add方法能被正确调用。从上面的例子可以看出,extends确定了泛型的上界,而super确定了泛型的下界。

    PECS

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

    PECS: producer-extends, consumer-super.
    比如,一个简单的Stack API:

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

    要实现pushAll(Iterable src)方法,将src的元素逐一入栈:

    public void pushAll(Iterablesrc){
        for(E e : src)
            push(e)
    }

    假设有一个实例化Stack的对象stack,src有Iterable与 Iterable;在调用pushAll方法时会发生type mismatch错误,因为Java中泛型是不可变的,Iterable与 Iterable都不是Iterable的子类型。因此,应改为

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

    要实现popAll(Collection dst)方法,将Stack中的元素依次取出add到dst中,如果不用通配符实现:

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

    同样地,假设有一个实例化Stack的对象stack,dst为Collection;调用popAll方法是会发生type mismatch错误,因为Collection不是Collection的子类型。因而,应改为:

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

    在上述例子中,在调用pushAll方法时生产了E 实例(produces E instances),在调用popAll方法时dst消费了E 实例(consumes E instances)。Naftalin与Wadler将PECS称为Get and Put Principle。

    java.util.Collections的copy方法(JDK1.7)完美地诠释了PECS:
    public staticvoid copy(List dest, List 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<1srcsize; i++)="" dest.set(i,="" src.get(i));="" }="" else="" {="" listiteratordi=dest.listIterator();
            ListIterator si=src.listIterator();
            for (int i=0; i<1srcsize; i++)="" {="" di.next();="" di.set(si.next());="" }=""

    PECS总结:

  • 要从泛型类取数据时,用extends;

  • 要往泛型类写数据时,用super;

  • 既要取又要写,就不用通配符(即extends与super都不用)。

到此,关于“怎么理解Java中的逆变与协变”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注创新互联-成都网站建设公司网站,小编会继续努力为大家带来更多实用的文章!


网页题目:怎么理解Java中的逆变与协变-创新互联
URL链接:http://cdkjz.cn/article/hccpc.html
多年建站经验

多一份参考,总有益处

联系快上网,免费获得专属《策划方案》及报价

咨询相关问题或预约面谈,可以通过以下方式与我们联系

大客户专线   成都:13518219792   座机:028-86922220