我对Java泛型如何处理继承/多态性有点困惑。

假设以下层次结构-

动物(父母)

狗-猫(儿童)

所以假设我有一个doSomething方法(列出<Animal>动物)。根据继承和多态性的所有规则,我会假设List<Dog>是List<Animal>,List<Cat>是List<Animal>-因此任何一个都可以传递给这个方法。不是这样。如果我想实现这种行为,我必须通过说doSomething(list<?extendsAnimal>动物)来明确告诉方法接受Animal的任何子类的列表。

我知道这是Java的行为。我的问题是为什么?为什么多态性通常是隐式的,但当涉及泛型时,必须指定它?


当前回答

我看到这个问题已经被回答了很多次,只想在同一个问题上输入我的意见。

让我们继续创建一个简化的Animal类层次结构。

abstract class Animal {
    void eat() {
        System.out.println("animal eating");
    }
}

class Dog extends Animal {
    void bark() { }
}

class Cat extends Animal {
    void meow() { }
}

现在让我们看看我们的老朋友Arrays,我们知道它隐式支持多态性-

class TestAnimals {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat(), new Dog()};
        Dog[] dogs = {new Dog(), new Dog(), new Dog()};
        takeAnimals(animals);
        takeAnimals(dogs);
    }

    public void takeAnimals(Animal[] animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

该类编译良好,当我们运行上面的类时,我们得到输出

animal eating
animal eating
animal eating
animal eating
animal eating
animal eating

这里需要注意的是,takeAnimals()方法被定义为接受Animal类型的任何东西,它可以接受Animal类型的数组,也可以接受Dog类型的数组。这就是多态性的作用。

现在让我们对泛型使用相同的方法,

现在假设我们稍微调整一下代码,使用ArrayList而不是Arrays-

class TestAnimals {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<Animal>();
        animals.add(new Dog());
        animals.add(new Cat());
        animals.add(new Dog());
        takeAnimals(animals);
    }

    public void takeAnimals(ArrayList<Animal> animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

上面的类将编译并生成输出-

animal eating
animal eating
animal eating
animal eating
animal eating
animal eating

所以我们知道这是可行的,现在让我们稍微调整一下这个类,使其以多态的方式使用Animal类型-

class TestAnimals {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<Animal>();
        animals.add(new Dog());
        animals.add(new Cat());
        animals.add(new Dog());

        ArrayList<Dog> dogs = new ArrayList<Dog>();
        takeAnimals(animals);
        takeAnimals(dogs);
    }

    public void takeAnimals(ArrayList<Animal> animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

看起来编译上面的类应该没有问题,因为takeAnimals()方法被设计为接受Animal和Dog-is-Animal类型的任何ArrayList,因此它不应该成为交易破坏者。

但是,不幸的是,编译器抛出了一个错误,不允许我们将Dog ArrayList传递给期望Animal ArrayList的变量。

你问为什么?

因为想象一下,如果JAVA允许将Dog ArrayList-dogs-放入Animal ArrayList中-animals-然后在takeAnimals()方法中,有人会这样做-

animals.add(new Cat());

认为这应该是可行的,因为理想情况下它是一个Animal ArrayList,您应该能够将任何猫添加到其中,作为cat-is-also-Animal,但实际上您将一个Dog类型的ArrayList传递给了它。

所以,现在您必须想到,数组也应该发生同样的情况。你这样想是对的。

如果有人试图用Arrays做同样的事情,那么Arrays也会抛出一个错误,但Arrays在运行时处理这个错误,而ArrayList在编译时处理这个问题。

其他回答

问题已正确识别为与差异有关,但详细信息不正确。纯函数列表是协变数据函子,这意味着如果Sub类型是Super的子类型,那么Sub列表绝对是Super列表的子类型。

然而,列表的可变性并不是这里的基本问题。问题是总体上的可变性。这个问题是众所周知的,被称为协方差问题,我认为它是卡斯塔尼亚首先发现的,它完全彻底地破坏了作为一个通用范式的对象定向。这是基于Cardelli和Reynolds之前建立的方差规则。

有点过于简单化,让我们将T型对象B分配给T型对象A作为突变。这不失一般性:a的突变可以写成a=f(a),其中f:T->T。当然,问题是,虽然函数在其共域中是协变的,但它们在其域中是逆变的,但通过赋值,域和共域是相同的,因此赋值是不变的!

因此,概括而言,亚型不能突变。但是对象定向突变是根本的,因此对象定向本质上是有缺陷的。

这里有一个简单的例子:在纯函数设置中,对称矩阵显然是一个矩阵,它是一个子类型,没有问题。现在,让我们在矩阵中添加一项功能,即在坐标(x,y)处设置一个元素,规则是其他元素不变。现在对称矩阵不再是一个子类型,如果你改变了(x,y),你也改变了(y,x)。函数运算是delta:Sym->Mat,如果你改变对称矩阵的一个元素,你会得到一个一般的非对称矩阵。因此,如果在Mat中包含“更改一个元素”方法,Sym不是子类型。事实上几乎肯定没有合适的亚型。

简单地说,如果你有一个通用的数据类型,其中包含大量的变异器,这些变异器利用了它的通用性,你可以确定任何适当的子类型都不可能支持所有这些变异:如果可以,它将与超类型一样通用,与“适当”子类型的规范相反。

事实上,Java阻止了可变列表的子类型化,这并不能解决真正的问题:几十年前,当Java受到质疑时,为什么要使用面向对象的垃圾呢??

无论如何,这里有一个合理的讨论:

https://en.wikipedia.org/wiki/Covariance_and_contravariance_(计算机科学)

List<Dog>不是List<Animal>的原因是,例如,您可以将猫插入List<Animate>,但不能插入List<Dog>。。。在可能的情况下,可以使用通配符使泛型更具可扩展性;例如,从List<Dog>中读取与从List<Animal>中读取类似,但不是写入。

《Java语言中的泛型》和《Java教程》中的“泛型”一节对为什么某些事物是多态的或不多态的或允许使用泛型进行了非常好、深入的解释。

如果您确定列表项是给定超类型的子类,则可以使用以下方法强制转换列表:

(List<Animal>) (List<?>) dogs

当您想要在构造函数内部传递列表或对其进行迭代时,这是非常有用的。

为了理解这个问题,比较数组是很有用的。

List<Dog>不是List<Animal>的子类。但狗[]是动物[]的子类。

数组是可具体化和协变的。可重用意味着它们的类型信息在运行时完全可用。因此,数组提供运行时类型安全性,但不提供编译时类型安全。

    // All compiles but throws ArrayStoreException at runtime at last line
    Dog[] dogs = new Dog[10];
    Animal[] animals = dogs; // compiles
    animals[0] = new Cat(); // throws ArrayStoreException at runtime

对于泛型,情况也是如此:泛型被删除且不变。因此,泛型不能提供运行时类型安全,但它们提供编译时类型安全。在下面的代码中,如果泛型是协变的,则可能在第3行造成堆污染。

    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = dogs; // compile-time error, otherwise heap pollution
    animals.add(new Cat());

我看到这个问题已经被回答了很多次,只想在同一个问题上输入我的意见。

让我们继续创建一个简化的Animal类层次结构。

abstract class Animal {
    void eat() {
        System.out.println("animal eating");
    }
}

class Dog extends Animal {
    void bark() { }
}

class Cat extends Animal {
    void meow() { }
}

现在让我们看看我们的老朋友Arrays,我们知道它隐式支持多态性-

class TestAnimals {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat(), new Dog()};
        Dog[] dogs = {new Dog(), new Dog(), new Dog()};
        takeAnimals(animals);
        takeAnimals(dogs);
    }

    public void takeAnimals(Animal[] animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

该类编译良好,当我们运行上面的类时,我们得到输出

animal eating
animal eating
animal eating
animal eating
animal eating
animal eating

这里需要注意的是,takeAnimals()方法被定义为接受Animal类型的任何东西,它可以接受Animal类型的数组,也可以接受Dog类型的数组。这就是多态性的作用。

现在让我们对泛型使用相同的方法,

现在假设我们稍微调整一下代码,使用ArrayList而不是Arrays-

class TestAnimals {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<Animal>();
        animals.add(new Dog());
        animals.add(new Cat());
        animals.add(new Dog());
        takeAnimals(animals);
    }

    public void takeAnimals(ArrayList<Animal> animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

上面的类将编译并生成输出-

animal eating
animal eating
animal eating
animal eating
animal eating
animal eating

所以我们知道这是可行的,现在让我们稍微调整一下这个类,使其以多态的方式使用Animal类型-

class TestAnimals {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<Animal>();
        animals.add(new Dog());
        animals.add(new Cat());
        animals.add(new Dog());

        ArrayList<Dog> dogs = new ArrayList<Dog>();
        takeAnimals(animals);
        takeAnimals(dogs);
    }

    public void takeAnimals(ArrayList<Animal> animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

看起来编译上面的类应该没有问题,因为takeAnimals()方法被设计为接受Animal和Dog-is-Animal类型的任何ArrayList,因此它不应该成为交易破坏者。

但是,不幸的是,编译器抛出了一个错误,不允许我们将Dog ArrayList传递给期望Animal ArrayList的变量。

你问为什么?

因为想象一下,如果JAVA允许将Dog ArrayList-dogs-放入Animal ArrayList中-animals-然后在takeAnimals()方法中,有人会这样做-

animals.add(new Cat());

认为这应该是可行的,因为理想情况下它是一个Animal ArrayList,您应该能够将任何猫添加到其中,作为cat-is-also-Animal,但实际上您将一个Dog类型的ArrayList传递给了它。

所以,现在您必须想到,数组也应该发生同样的情况。你这样想是对的。

如果有人试图用Arrays做同样的事情,那么Arrays也会抛出一个错误,但Arrays在运行时处理这个错误,而ArrayList在编译时处理这个问题。