我对Java泛型如何处理继承/多态性有点困惑。
假设以下层次结构-
动物（父母）
狗-猫（儿童）
所以假设我有一个doSomething方法（列出＜Animal＞动物）。根据继承和多态性的所有规则，我会假设List<Dog>是List<Animal>，List<Cat>是List<Animal>-因此任何一个都可以传递给这个方法。不是这样。如果我想实现这种行为，我必须通过说doSomething（list<？extendsAnimal>动物）来明确告诉方法接受Animal的任何子类的列表。
我知道这是Java的行为。我的问题是为什么？为什么多态性通常是隐式的，但当涉及泛型时，必须指定它？
当前回答
这种行为的基本逻辑是泛型遵循类型擦除机制。因此，在运行时，您无法识别集合的类型，而不像阵列中没有这样的擦除过程。回到你的问题。。。
因此，假设有如下方法：
add(List<Animal>){
//You can add List<Dog or List<Cat> and this will compile as per rules of polymorphism
}
现在，若java允许调用者将List of type Animal添加到此方法中，那个么您可能会将错误的内容添加到集合中，并且在运行时它也会由于类型擦除而运行。而在数组的情况下，您将获得此类场景的运行时异常。。。
因此，本质上，这种行为的实现是为了避免将错误的东西添加到集合中。现在我相信类型删除的存在是为了与没有泛型的遗留java兼容。。。。
其他回答
这种行为的基本逻辑是泛型遵循类型擦除机制。因此，在运行时，您无法识别集合的类型，而不像阵列中没有这样的擦除过程。回到你的问题。。。
因此，假设有如下方法：
add(List<Animal>){
//You can add List<Dog or List<Cat> and this will compile as per rules of polymorphism
}
现在，若java允许调用者将List of type 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在编译时处理这个问题。
其他人已经很好地解释了为什么不能将后代列表转换为超类列表。
然而，许多人访问这个问题以寻求解决方案。
因此，自Java版本10以来，该问题的解决方案如下：
（注：S=超类）
List<S> supers = List.copyOf( descendants );
如果完全安全，则此函数将执行强制转换，如果强制转换不安全，则该函数将执行复制。
有关深入解释（考虑到此处其他答案提到的潜在陷阱），请参阅相关问题和我2022年的答案：https://stackoverflow.com/a/72195980/773113
答案和其他答案都是正确的。我将用我认为会有帮助的解决方案来补充这些答案。我认为这在编程中经常出现。需要注意的一点是，对于集合（列表、集合等），主要问题是添加到集合。这就是问题所在。即使移除也可以。
在大多数情况下，我们可以使用集合<？扩展T>而不是集合<T>，这应该是首选。然而，我发现这样做并不容易。关于这是否始终是最好的做法，这是一个值得争论的问题。我在这里介绍一个类DownCastCollection，它可以转换集合<？将T>扩展到集合<T>（我们可以为List、Set、NavigableSet等定义类似的类），以便在使用标准方法时使用。下面是一个如何使用它的示例（在这种情况下，我们也可以使用Collection<？extendsObject>，但我保持简单，以说明使用DownCastCollection。
/**Could use Collection<? extends Object> and that is the better choice.
* But I am doing this to illustrate how to use DownCastCollection. **/
public static void print(Collection<Object> col){
for(Object obj : col){
System.out.println(obj);
}
}
public static void main(String[] args){
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList("a","b","c"));
print(new DownCastCollection<Object>(list));
}
现在开始上课：
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class DownCastCollection<E> extends AbstractCollection<E> implements Collection<E> {
private Collection<? extends E> delegate;
public DownCastCollection(Collection<? extends E> delegate) {
super();
this.delegate = delegate;
}
@Override
public int size() {
return delegate ==null ? 0 : delegate.size();
}
@Override
public boolean isEmpty() {
return delegate==null || delegate.isEmpty();
}
@Override
public boolean contains(Object o) {
if(isEmpty()) return false;
return delegate.contains(o);
}
private class MyIterator implements Iterator<E>{
Iterator<? extends E> delegateIterator;
protected MyIterator() {
super();
this.delegateIterator = delegate == null ? null :delegate.iterator();
}
@Override
public boolean hasNext() {
return delegateIterator != null && delegateIterator.hasNext();
}
@Override
public E next() {
if(!hasNext()) throw new NoSuchElementException("The iterator is empty");
return delegateIterator.next();
}
@Override
public void remove() {
delegateIterator.remove();
}
}
@Override
public Iterator<E> iterator() {
return new MyIterator();
}
@Override
public boolean add(E e) {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
if(delegate == null) return false;
return delegate.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
if(delegate==null) return false;
return delegate.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> c) {
if(delegate == null) return false;
return delegate.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
if(delegate == null) return false;
return delegate.retainAll(c);
}
@Override
public void clear() {
if(delegate == null) return;
delegate.clear();
}
}
让我们以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方法中，如果要传递圆的列表（形状的子类型），编译器应该检测到这一点，并用编译错误限制您这样做）。
出于明显的原因，他们选择了第一条路。
