为什么将 ArrayList 的泛型转换为超类不起作用？

发布于 2024-11-08 04:51:19 字数 970 浏览 0 评论 0原文

有人可以向我解释为什么下面的代码示例中标记为 //this line 给出编译错误（为什么？） 的行不起作用吗？

import java.util.ArrayList;

public class GenericCastCheck {

    class A{
    }

    class B extends A{
    }

    public static void main(String[] args) {

        A aObject = new A();
        B bObject = new B();

        //this line works fine
        aObject = bObject;
        //this line gives a compile (expected)
        bObject = aObject;

        ArrayList<A> aList = new ArrayList<A>();
        ArrayList<B> bList = new ArrayList<B>();

        //this line gives a compile error (why?)
        aList = bList;
        //this line gives a compile error (expected)
        bList = aList;
    }
}

具体来说，当我们说 bList 是 ArrayList 类型时，是不是意味着它的每个元素都是 B 的实例？如果是这样，那么如果我们可以将 B 的各个实例强制转换为 A，那么将其强制转换为 ArrayList 会出现什么问题？

谢谢。

原文

Can someone please explain to me why the line marked //this line gives a compile error (why?) in the following code sample does not work?

import java.util.ArrayList;

public class GenericCastCheck {

    class A{
    }

    class B extends A{
    }

    public static void main(String[] args) {

        A aObject = new A();
        B bObject = new B();

        //this line works fine
        aObject = bObject;
        //this line gives a compile (expected)
        bObject = aObject;

        ArrayList<A> aList = new ArrayList<A>();
        ArrayList<B> bList = new ArrayList<B>();

        //this line gives a compile error (why?)
        aList = bList;
        //this line gives a compile error (expected)
        bList = aList;
    }
}

Specifically, when we say that bList is of type ArrayList<B>, does it not mean that each element of it is an instance of B? If so, then what is the problem in casting it to ArrayList<A>, if we can cast individual instances of B to A?

Thanks.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

冬天旳寂寞 2024-11-15 04:51:19

问题是这样的：

ArrayList<A> aList = new ArrayList<A>();
ArrayList<B> bList = new ArrayList<B>();
aList = bList; // if this were valid...
aList.add(new A()); // ...what should happen here?
B b = bList.get(0); // ...and here?

如果您对数组执行相同的操作，则会在运行时在第 4 行中收到 ArrayStoreException。对于泛型集合，决定在编译时防止这种情况发生。

The problem is this:

ArrayList<A> aList = new ArrayList<A>();
ArrayList<B> bList = new ArrayList<B>();
aList = bList; // if this were valid...
aList.add(new A()); // ...what should happen here?
B b = bList.get(0); // ...and here?

If you do the same thing with arrays, you get an ArrayStoreException in line 4 at runtime. For generic collections, it was decided to prevent that kind of thing at compile time.

回复收藏 0 原文

赠意 2024-11-15 04:51:19

因为通用是严格的。它们不是协变的

ArrayList aList 只能引用 A 类型的 ArrayList

来自 wiki

与数组不同，泛型类是
既不是协变也不是逆变。
例如，List 和
List

Because generic are strict. they aren't covarient

ArrayList<A> aList can only refer to an ArrayList of type A

From wiki

Unlike arrays, generic classes are
neither covariant nor contravariant.
For example, neither List<String> nor
List<Object> is a subtype of the
other:
// a is a single-element List of String
List<String> a = new ArrayList<String>();
a.add("foo");

// b is a List of Object
List<Object> b = a; // This is a compile-time error
However, generic type parameters can
contain wildcards (a shortcut for an
extra type parameter that is only used
once). Example: Given a requirement
for a method which operates on Lists,
of any object, then the only
operations that can be performed on
the object are those for which the
type relationships can be guaranteed
to be safe.
// a is a single-element List of String
List<String> a = new ArrayList<String>();
a.add("foo");

// b is a List of anything
List<?> b = a;

// retrieve the first element
Object c = b.get(0);
// This is legal, because we can guarantee
// that the return type "?" is a subtype of Object

// Add an Integer to b.
b.add(new Integer (1)); 
// This is a compile-time error; 
// we cannot guarantee that Integer is
// a subtype of the parameter type "?"
Wildcards can also be bound, e.g. "? extends Foo" or "? super Foo" for
upper and lower bounds, respectively.
This allows to refine permitted
performance. Example: given a List<? extends Foo>, then an element can be
retrieved and safely assigned to a Foo
type (covariance). Given a List<? super Foo>, then a Foo object can be
safely added as an element
(contravariance).