Java中的C# IEnumerable相当于什么?协变能力的，而不是可迭代的

这种协方差在 C# 中是可能的：

IEnumerable<A> a = new List<A>();
IEnumerable<B> b = new List<B>();
a = b;
...
class A {
}
class B : A {
}

这在Java中是不可能的：(可迭代：在这个问题中看到Java Arrays & Generics：Java等同于C# IEnumerable(。

Iterable<A> a = new ArrayList<A>();
Iterable<B> b = new ArrayList<B>();
a = b;
...
class A {
}
class B extends A {
}

使用可迭代，Java看不到这两个集合是协方差的。

Java 中哪个可迭代/可枚举接口可以促进协方差？

---

协方差的另一个很好的例子，给定上面的 A 类和 B 类，这在 Java 和 C# 上都是允许的：

   A[] x;
   B[] y = new B[10];
   x = y;

该功能在版本 1 的两种语言上都有。很高兴他们正在取得进展，使这在泛型上成为现实。C# 在语法方面的摩擦较小。

协方差是所有 OOP 语言的必备条件，否则 OOP 继承将是一个无用的练习，例如

 A x;
 B y = new B();
 x = y;

这种力量也应该扩展到泛型。

---

---

感谢大家的回答和见解。现在有一个可重用的方法，现在有一个支持协变的 Java 泛型。这不是我们中的一些人想要的语法，但它(<? extends classHere>(肯定符合要求：

import java.util.*;    
public class Covariance2 {  
  
        public static void testList(Iterable<? extends A> men) {                 
                for(A good : men) {
                        System.out.println("Good : " + good.name);
                }
        }    
        public static void main(String[] args) {    
                System.out.println("The A"); 
                {
                        List<A> team = new ArrayList<A>();
                        { A player = new A(); player.name = "John"; team.add(player); }
                        { A player = new A(); player.name = "Paul"; team.add(player); }
                        testList(team);
                }
                System.out.println("The B");
                {
                        List<B> bee = new ArrayList<B>();
                        { B good = new B(); good.name = "George"; bee.add(good); }
                        { B good = new B(); good.name = "Ringo"; bee.add(good); }
                        testList(bee);
                }    
        }
}
class A { String name; }    
class B extends A {}

输出：

The A
Good : John
Good : Paul
The B
Good : George
Good : Ringo

---

如果有人对它在 C# 中的外观感兴趣

using System.Collections.Generic;
using System.Linq;
public class Covariance2 {  
        internal static void TestList(IEnumerable<A> men) {                 
                foreach(A good in men) {
                        System.Console.WriteLine("Good : " + good.name);
                }
        }    
        public static void Main(string[] args) {    
                System.Console.WriteLine("The A"); 
                {
                        IList<A> team = new List<A>();
                        { A player = new A(); player.name = "John"; team.Add(player); }
                        { A player = new A(); player.name = "Paul"; team.Add(player); }
                        TestList(team);
                }
                System.Console.WriteLine("The A"); 
                {
                        IList<B> bee = new List<B>();
                        { B good = new B(); good.name = "George"; bee.Add(good); }
                        { B good = new B(); good.name = "Ringo"; bee.Add(good); }
                        TestList(bee);
                }    
        }
}
class A { internal string name; }    
class B : A {}

    Iterable<? extends A> a = new ArrayList<A>();
    Iterable<B> b = new ArrayList<B>();
    a = b;

Iterable<A> a = new ArrayList<A>();
Iterable<?> b = a;

ArrayList<A> a = new ArrayList<A>();
ArrayList<B> b = new ArrayList<B>();
a.add(new A()); 
b = a;
B item=b.get(0);