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

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

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

这里给出的答案并不能完全说服我，所以我再举一个例子。

public void passOn(Consumer<Animal> consumer, Supplier<Animal> supplier) {
    consumer.accept(supplier.get());
}

听起来不错，不是吗？但你只能通过动物消费者和供应商。如果你有哺乳动物的消费者，但鸭子的供应商，尽管它们都是动物，但它们不应该适合。为了禁止这种行为，增加了额外的限制。

我们必须定义我们使用的类型之间的关系，而不是上述内容。

例如。，

public <A extends Animal> void passOn(Consumer<A> consumer, Supplier<? extends A> supplier) {
    consumer.accept(supplier.get());
}

确保我们只能使用为消费者提供正确类型对象的供应商。

OTOH，我们也可以

public <A extends Animal> void passOn(Consumer<? super A> consumer, Supplier<A> supplier) {
    consumer.accept(supplier.get());
}

我们的方向相反：我们定义供应商的类型，并限制其可以投放给消费者。

我们甚至可以做到

public <A extends Animal> void passOn(Consumer<? super A> consumer, Supplier<? extends A> supplier) {
    consumer.accept(supplier.get());
}

其中，有了“生活”->“动物”->“哺乳动物”->“狗”、“猫”等直观关系，我们甚至可以将“哺乳动物”放入“生活”消费者，但不能将“字符串”放入“生命”消费者。

让我们以JavaSE教程为例

public abstract class Shape {
    public abstract void draw(Canvas c);
}

public class Circle extends Shape {
    private int x, y, radius;
    public void draw(Canvas c) {
        ...
    }
}

public class Rectangle extends Shape {
    private int x, y, width, height;
    public void draw(Canvas c) {
        ...
    }
}

因此，为什么狗（圆圈）的列表不应被视为动物（形状）的列表，是因为这种情况：

// drawAll method call
drawAll(circleList);


public void drawAll(List<Shape> shapes) {
   shapes.add(new Rectangle());    
}

因此，Java“架构师”有两个选项可以解决这个问题：

不要认为子类型是隐式的，它是父类型，并给出编译错误，就像现在发生的那样将子类型视为它的父类型，并在编译“add”方法时进行限制（因此在drawAll方法中，如果要传递圆的列表（形状的子类型），编译器应该检测到这一点，并用编译错误限制您这样做）。

出于明显的原因，他们选择了第一条路。

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

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在编译时处理这个问题。

其他人已经很好地解释了为什么不能将后代列表转换为超类列表。

然而，许多人访问这个问题以寻求解决方案。

因此，自Java版本10以来，该问题的解决方案如下：

（注：S=超类）

List<S> supers = List.copyOf( descendants );

如果完全安全，则此函数将执行强制转换，如果强制转换不安全，则该函数将执行复制。

有关深入解释（考虑到此处其他答案提到的潜在陷阱），请参阅相关问题和我2022年的答案：https://stackoverflow.com/a/72195980/773113