多个嵌套通配符 - 参数不适用

发布于 2024-09-18 02:01:21 字数 549 浏览 6 评论 0 原文

我已经大大简化了我的问题。它是这样读的。

我试图找出为什么以下代码无法编译：

 List<AnonType<AnonType<?>>> l = new ArrayList<AnonType<AnonType<?>>>();
 l.add( new AnonType<AnonType<String>>() );

where

public class AnonType<T> {
  T a;

  List<T> b;
}

编译器错误表明 add 不适用于给定的参数。 OTOH，以下仅包含 1 层嵌套通配符的代码可以完美编译：

List<AnonType<?>> l = new ArrayList<AnonType<?>>();
l.add( new AnonType<String>() );

原文

I've heavily simplified my problem. Here's how it reads.

I'm trying to figure out why the following code does not compile:

 List<AnonType<AnonType<?>>> l = new ArrayList<AnonType<AnonType<?>>>();
 l.add( new AnonType<AnonType<String>>() );

where

public class AnonType<T> {
  T a;

  List<T> b;
}

The compiler error is saying that add is not applicable for the argument given. OTOH, the following code with only 1-level nested wildcard compiles perfectly:

List<AnonType<?>> l = new ArrayList<AnonType<?>>();
l.add( new AnonType<String>() );

分享到QQ

分享到微博

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

发布评论

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

音盲 2024-09-25 02:01:21

以下内容按预期编译：

    List<Set<? extends Set<?>>> list = new ArrayList<Set<? extends Set<?>>>();
    list.add(new HashSet<Set<String>>());
    list.add(new HashSet<Set<Integer>>());

问题是泛型是类型不变的。

考虑一个更简单的示例：

假设存在从 Animal 到 Dog 的强制转换（例如 Dog extends Animal）...
- List 不是 List
存在来自 List 的捕获转换？将 Animal> 扩展为 List

现在，此场景中会发生以下情况：

假设存在从 Set 到 Set 的捕获转换代码>设置<字符串>...
- Set> 不是 Set>
有一个捕获从 Set> 扩展为 Set>

因此，如果您想要一个 List，您可以在其中添加 < code>Set>、Set> 等，则 T 是 NOT Set>，而是 Set>。

另请参阅

The following compiles as expected:

    List<Set<? extends Set<?>>> list = new ArrayList<Set<? extends Set<?>>>();
    list.add(new HashSet<Set<String>>());
    list.add(new HashSet<Set<Integer>>());

The problem is that generics is type invariant.

Consider the simpler example:

Given that there is a casting conversion from Animal to Dog (e.g. Dog extends Animal)...
- A List<Animal> IS NOT a List<Dog>
There is a capture conversion from List<? extends Animal> to a List<Dog>

Now here's what happens in this scenario:

Given that there is a capture conversion from Set<?> to Set<String>...
- A Set<Set<?>> IS NOT a Set<Set<String>>
There is a capture conversion from Set<? extends Set<?>> to Set<Set<String>>

So if you want a List<T> where you can add a Set<Set<String>>, Set<Set<Integer>>, etc, then T is NOT Set<Set<?>>, but rather Set<? extends Set<?>>.