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

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

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

我认为，其他答案中提到的一点是

List＜Dog＞不是Java中的List＜Animal＞

这也是事实

狗的列表是英文的动物列表（在合理的解释下）

OP的直觉运作方式——当然这是完全有效的——是后一句话。然而，如果我们运用这种直觉，我们得到的语言在其类型系统中不是Java风格的：假设我们的语言确实允许将猫添加到我们的狗列表中。这意味着什么？这意味着该列表不再是狗的列表，而仅仅是动物的列表。还有一张哺乳动物的列表和一张四足动物的列表。

换一种说法：Java中的List＜Dog＞在英语中并不意味着“一个狗的列表”，它的意思是“一个只有狗的列表。”。

更一般地说，OP的直觉倾向于一种语言，在这种语言中，对对象的操作可以改变其类型，或者更确切地说，对象的类型是其值的（动态）函数。

关于Jon Skeet的回答，他使用了以下示例代码：

// Illegal code - because otherwise life would be Bad
List<Dog> dogs = new ArrayList<Dog>(); // ArrayList implements List
List<Animal> animals = dogs; // Awooga awooga
animals.add(new Cat());
Dog dog = dogs.get(0); // This should be safe, right?

在最深层次上，这里的问题是狗和动物共享一个参考。这意味着一种方法是复制整个列表，这将打破引用相等：

// This code is fine
List<Dog> dogs = new ArrayList<Dog>();
dogs.add(new Dog());
List<Animal> animals = new ArrayList<>(dogs); // Copy list
animals.add(new Cat());
Dog dog = dogs.get(0);   // This is fine now, because it does not return the Cat

在调用List＜Animal＞animals＝new ArrayList＜＞（狗）；后；，您随后不能将动物直接分配给狗或猫：

// These are both illegal
dogs = animals;
cats = animals;

因此，您不能将错误的Animal子类型放入列表中，因为没有错误的子类型--任何子类型的对象？扩展动物可以添加到动物。

显然，这改变了语义，因为动物和狗的列表不再共享，所以添加到一个列表不会添加到另一个列表中（这正是您想要的，以避免将猫添加到只应包含狗对象的列表中的问题）。此外，复制整个列表可能效率低下。然而，通过打破引用相等性，这确实解决了类型等价问题。

另一个解决方案是建立一个新的列表

List<Dog> dogs = new ArrayList<Dog>(); 
List<Animal> animals = new ArrayList<Animal>(dogs);
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在编译时处理这个问题。

子类型对于参数化类型是不变的。即使严格来说，类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
}

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

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