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

假设以下层次结构-

动物(父母)

狗-猫(儿童)

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

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


当前回答

我想说,Generics的全部观点是它不允许这样做。考虑数组的情况,它确实允许这种类型的协方差:

  Object[] objects = new String[10];
  objects[0] = Boolean.FALSE;

该代码编译良好,但抛出运行时错误(第二行中的java.lang.ArrayStoreException:java.lang.Boolean)。它不是类型安全的。Generics的目的是增加编译时类型安全性,否则您可以只使用没有泛型的普通类。

现在有些时候你需要更加灵活,这就是为什么?超级班和?扩展类用于。前者是当您需要插入到类型Collection中时(例如),后者是当需要以类型安全的方式从中读取时。但同时做到这两个的唯一方法是拥有一种特定的类型。

其他回答

子类型对于参数化类型是不变的。即使严格来说,类Dog是Animal的子类型,但参数化类型List<Dog>不是List<Animal>的子类型。相反,协变子类型由数组使用,因此数组类型狗[]是动物[]的一个亚型。

不变的子类型确保不违反Java强制的类型约束。考虑@Jon Skeet给出的以下代码:

List<Dog> dogs = new ArrayList<Dog>(1);
List<Animal> animals = dogs;
animals.add(new Cat()); // compile-time error
Dog dog = dogs.get(0);

正如@Jon Skeet所说,这段代码是非法的,因为否则它会违反类型约束,在狗期望的时候返回一只猫。

将上述代码与数组的类似代码进行比较是有指导意义的。

Dog[] dogs = new Dog[1];
Object[] animals = dogs;
animals[0] = new Cat(); // run-time error
Dog dog = dogs[0];

该代码是合法的。但是,引发数组存储异常。数组在运行时携带其类型,JVM可以这样强制协变子类型的类型安全性。

为了进一步理解这一点,让我们看一下javap生成的字节码:

import java.util.ArrayList;
import java.util.List;

public class Demonstration {
    public void normal() {
        List normal = new ArrayList(1);
        normal.add("lorem ipsum");
    }

    public void parameterized() {
        List<String> parameterized = new ArrayList<>(1);
        parameterized.add("lorem ipsum");
    }
}

使用命令javap-c演示,这将显示以下Java字节码:

Compiled from "Demonstration.java"
public class Demonstration {
  public Demonstration();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void normal();
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: iconst_1
       5: invokespecial #3                  // Method java/util/ArrayList."<init>":(I)V
       8: astore_1
       9: aload_1
      10: ldc           #4                  // String lorem ipsum
      12: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      17: pop
      18: return

  public void parameterized();
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: iconst_1
       5: invokespecial #3                  // Method java/util/ArrayList."<init>":(I)V
       8: astore_1
       9: aload_1
      10: ldc           #4                  // String lorem ipsum
      12: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      17: pop
      18: return
}

观察方法体的翻译代码是否相同。编译器通过删除来替换每个参数化类型。此属性至关重要,这意味着它不会破坏向后兼容性。

总之,参数化类型的运行时安全性是不可能的,因为编译器通过删除来替换每个参数化类型。这使得参数化类型只不过是语法糖。

我们还应该考虑编译器如何威胁泛型类:每当我们填充泛型参数时,“实例化”一个不同的类型。

因此,我们有ListOfAnimal、ListOfDog、ListOfCat等,它们是不同的类,当我们指定泛型参数时,最终由编译器“创建”。这是一个扁平的层次结构(实际上关于List根本不是一个层次结构)。

在泛型类的情况下,协方差没有意义的另一个论点是,基本上所有类都是相同的-都是List实例。通过填充泛型参数来专门化List并不会扩展类,它只会使其适用于特定的泛型参数。

问题已正确识别为与差异有关,但详细信息不正确。纯函数列表是协变数据函子,这意味着如果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>的子类。但狗[]是动物[]的子类。

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

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

问题已经很好地确定了。但有一个解决方案;使doSomething通用:

<T extends Animal> void doSomething<List<T> animals) {
}

现在,您可以使用List<Dog>或List<Cat>或List<Animal>调用doSomething。