Question

请帮助我理解为什么add1()和add4()报告错误以及为什么add2()和add3()没有错误。具体而言，如果编译器允许其中的每一个都进行编译，请显示不良后果的示例。

class InnerTypeConfusion {
   interface Animal {}
   class Dog implements Animal {}
   class Room<T> {
      void add(T t) {}
   }

   void add1(Room<? extends Animal> room) {
      // Error: The method add(capture#1-of ? extends Animal) in the type 
      // Room<capture#1-of ? extends Animal> is not applicable for the 
      // arguments (Dog)
      room.add(new Dog());
   }

   void add2(Room<Animal> room) {
      room.add(new Dog());
   }

   class Cage<T> {}

   void add3(Room<Cage<? extends Animal>> room) {
      room.add(new Cage<Dog>());
   }

   void add4(Room<Cage<Animal>> room) {
      // The method add(Cage<Animal>) in the type Room<Cage<Animal>> is not 
      // applicable for the arguments (Cage<Dog>)
      room.add(new Cage<Dog>());
   }
}

Answer 1

在方法void add1(Room<? extends Animal> room)中，您定义该方法接受包含Room的{{1}}。例如，它可以是Animal，或Room<Cat> - 甚至Room<Dog>来保存所有类型的动物。但是，请记住，房间是在此方法调用之外创建的，除了它拥有特定的动物之外，您不能对房间类型做任何假设。

Room<Animal>

但是一旦你进入这个方法，就无法具体知道哪种类型的房间已经通过了。

将方法称为只有鸟类add1(new Room<Dog>()); // give the method a room for dogs add1(new Room<Cat>()); // give the method a room for cats add1(new Room<Animal>()); // give the method a room for any animal的空间是有效的，因为add1(new Room<Bird>())确实扩展了Bird。但是在方法正文中，您要在其中添加Animal。这就是为什么它无效，我们无法将Dog个对象放入Dog。它是某种种动物的Room<Bird>，而不是任何种动物Room。

如果您想编写一种方法，将狗添加到适合添加狗的房间（但不仅限于仅限狗的房间），您可以使用签名Room按this answer编写它}。此方法可以接受addDogToRoom(Room<? super Dog> room)以及Room<Animal>，并且仍然在方法中添加新狗到房间。

关于Room<Dog>，它是相同的，但恰恰相反。使用add4，您指定该方法需要特定的房间类型 - 一个房间只允许包含任何种Room<Cage<Animal>>的网箱。但是后来你试图在其中添加一个Animal，一个只允许狗的笼子。因此，它再次无效。

关于评论的补充：

假设有设计用于容纳猫Cage<Dog>的笼子和用于容纳狗Cage<Cat>的笼子。还有通用笼子，可以包含任何种类的动物Cage<Dog>。这是三种不同的笼子，它们不能互相替代，因为它们具有完全不同的架构和设计。

Cage<Animal>表示该方法需要一个狗笼。
void method(Cage<Dog>)表示该方法需要一个通用笼。
void method(Cage<Animal>)意味着该方法需要任何种类的动物笼。无论是狗笼，猫笼还是笼子。

客房是另一层抽象 - 将其视为带有笼子的房间。可以有一个存放猫笼void method(Cage<? extends Animal>)的房间，一个用于存放狗笼Room<Cage<Cat>>的房间，一个用于存放通用笼Room<Cage<Dog>>的房间和一个用于存放多种<的房间/ strong>动物笼Room<Cage<Animal>>。因此，适用相同的规则：

Room<Cage<? extends Animal>> - 狗笼的房间

void method(Room<Cage<Dog>>) - 猫笼的房间

void method(Room<Cage<Cat>>) - 动物笼的房间

void method(Room<Cage<Animal>>) - 可以包含多种动物笼子的房间。例如，房间可以同时包含void method(Room<Cage<? extends Animal>>)和Cage<Dog>。

现在，在Cage<Animal>，你要求最后一种房间，一个可以包含“各种动物笼子”的房间。因此传递给该方法的房间可以包含或添加新的狗笼add3(Room<Cage<? extends Animal>> room)或任何其他类型的笼子。

但是，要调用该方法，您需要先创建一个新的“通用”房间（支持所有网箱）：

room.add(new Cage<Dog>())

给它一个狗笼子的房间是行不通的：

Room<Cage<? extends Animal>> room = new Room<Cage<? extends Animal>>(); add3(room);

如果你想写一个更灵活的方法来接受最不容纳狗笼的房间，它可能看起来像这样：

// Here we create a room that can contain only dog cages Room<Cage<Dog>> room = new Room<Cage<Dog>>(); // But the method needs a "any kind of animal cage" room // Therefore we get error during compilation add3(room);

Answer 2

add1：

// We don't want to add a Dog to a room of cats...
Room<Cat> cats = new Room<Cat>();
add1(cats);
Cat cat = cats.get(0);

对于add4，我们不希望Cage<Dog>添加Room Cage<Animal> ... Cage<Dog> isn' t Cage<Animal>，但是Cage<? extends Animal>。它类似于第一次演员阵容，只有一个级别的嵌套......

Answer 3

当您使用标有?的未知类型列表时，该列表几乎是只读的。您只能在其中插入null。您无法使用列表中的项目。在这里，您处理Animal

的未知子类

void add1(List<? extends Animal> list) {
   list.add(new Dog());
}

即使Dog是Animal的子类，List的{{1}}也不是Dog List的子类。 Java不会自动知道这一点，因此您必须手动指定它，就像在Animal

中一样

add3(..)

混淆了嵌套泛型的集合

3 个答案: