你好！让我们继续研究泛型。您已经从之前的课程中获得了大量关于它们的知识（关于在处理泛型时使用可变参数和类型擦除），但是我们还没有考虑一个重要的主题——通配符。这是泛型非常重要的特性。如此之多，以至于我们专门为此开设了一堂课！也就是说，通配符并没有什么特别复杂的地方。你马上就会看到 :)![泛型中的通配符 - 1]()
让我们看一个例子：
![Java webinar]()
![Java university]()
这里原理类似。该
让我们看一个例子：
public class Main {
public static void main(String[] args) {
String str = new String("Test!");
// No problem
Object obj = str;
List<String> strings = new ArrayList<String>();
// Compilation error!
List<Object> objects = strings;
}
}
String对象转换为一个Object对象。这里没有问题——一切都按预期进行。但在第二种情况下，编译器会产生错误。但我们正在做同样的事情，不是吗？这次我们只是使用几个对象的集合。但是为什么会出现这个错误呢？有什么不同？我们是将一个String对象投射到一个Object还是 20 个对象？对象和对象集合之间有一个重要的区别。 如果B班级是班级的孩子A，则Collection<B>不是 的孩子Collection<A>。 这就是为什么我们无法将我们的投射List<String>到List<Object>. String是 的孩子Object，但List<String>不是 的孩子List<Object>。 这可能看起来不是很直观。为什么语言的创造者会这样做呢？让我们假设编译器没有给我们一个错误：
List<String> strings = new ArrayList<String>();
List<Object> objects = strings;
objects.add(new Object());
String s = strings.get(0);
List<Object>指向 的引用strings，所以我们可以将任何旧Object对象添加到strings集合中！因此，我们失去了我们的集合仅包含泛型类型调用中类型参数指定的对象的保证String。换句话说，我们失去了泛型的主要优势——类型安全。而且因为编译器没有阻止我们这样做，我们只会在运行时得到一个错误，这总是比编译错误糟糕得多。为了防止出现这种情况，编译器会报错：
// Compilation error
List<Object> objects = strings;
List<String>不是 . 的后代List<Object>。这是泛型的铁律，在使用泛型时必须牢记这一点。让我们继续。假设我们有一个小的类层次结构：
public class Animal {
public void feed() {
System.out.println("Animal.feed()");
}
}
public class Pet extends Animal {
public void call() {
System.out.println("Pet.call()");
}
}
public class Cat extends Pet {
public void meow() {
System.out.println("Cat.meow()");
}
}
iterateAnimals()方法。该方法应该采用任何动物的集合 ( Animal, Pet, Cat, Dog)，迭代所有元素，并在每次迭代期间在控制台上显示一条消息。让我们尝试编写这样一个方法：
public static void iterateAnimals(Collection<Animal> animals) {
for(Animal animal: animals) {
System.out.println("Another iteration in the loop!");
}
}
List<Cat>,List<Dog>和List<Pet>不是List<Animal>! 这意味着当我们尝试使用iterateAnimals()猫列表调用该方法时，会出现编译错误：
import java.util.*;
public class Main3 {
public static void iterateAnimals(Collection<Animal> animals) {
for(Animal animal: animals) {
System.out.println("Another iteration in the loop!");
}
}
public static void main(String[] args) {
List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());
cats.add(new Cat());
cats.add(new Cat());
// Compilation error!
iterateAnimals(cats);
}
}
public static void iterateAnimals(Collection<? extends Animal> animals) {
for(Animal animal: animals) {
System.out.println("Another iteration in the loop!");
}
}
Animal派生的任何类的对象集合。Animal换句话说，该方法可以接受Animal、Pet、Dog或Cat对象的集合——这没有区别。让我们说服自己它有效：
public static void main(String[] args) {
List<Animal> animals = new ArrayList<>();
animals.add(new Animal());
animals.add(new Animal());
List<Pet> pets = new ArrayList<>();
pets.add(new Pet());
pets.add(new Pet());
List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());
List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());
iterateAnimals(animals);
iterateAnimals(pets);
iterateAnimals(cats);
iterateAnimals(dogs);
}
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Another iteration in the loop!
Animal，Pet下面是类，下一层是Cat和Dog类。现在您需要重写该iterateAnimals()方法，以便可以处理任何类型的动物，狗除外。也就是说，它应该接受Collection<Animal>，Collection<Pet>或Collection<Car>，但它不应该与 一起使用Collection<Dog>。我们怎样才能做到这一点？似乎我们再次面临为每种类型编写单独方法的前景：/否则我们如何向编译器解释我们想要发生的事情？其实很简单！在这里，通配符再次为我们提供帮助。但这次我们将使用另一种类型的通配符——下界通配符，它使用super表示。
public static void iterateAnimals(Collection<? super Cat> animals) {
for(int i = 0; i < animals.size(); i++) {
System.out.println("Another iteration in the loop!");
}
}
<? super Cat>构造告诉编译器该iterateAnimals()方法可以接受Cat对象集合或类的任何祖先Cat作为输入作为输入。在这种情况下，该类Cat、它的父级Pet及其父级的父级Animal都符合此描述。该类Dog不符合我们的限制，因此尝试使用带有List<Dog>参数的方法将导致编译错误：
public static void main(String[] args) {
List<Animal> animals = new ArrayList<>();
animals.add(new Animal());
animals.add(new Animal());
List<Pet> pets = new ArrayList<>();
pets.add(new Pet());
pets.add(new Pet());
List<Cat> cats = new ArrayList<>();
cats.add(new Cat());
cats.add(new Cat());
List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());
iterateAnimals(animals);
iterateAnimals(pets);
iterateAnimals(cats);
// Compilation error!
iterateAnimals(dogs);
}
GO TO FULL VERSION