Java泛型操持详解

弁言

在一样平常Java开辟中，泛型是一个非常紧张的特性。它提供了编译时的范例安全查抄，加强了代码的可读性和可维护性。然而，对于初学者乃至一些有履历的开辟者来说，泛型的使用和明白仍旧是一个挑衅。本文旨在深入探究Java泛型的诞生配景、特性以及著名的PECS原则，资助读者更好地把握这一强大的工具。
泛型的诞生配景

为什么须要泛型

在没有泛型之前，Java中的聚集类（如ArrayList、HashMap等）只能存储Object范例的对象。这意味着在添加和获取元素时，须要举行显式的范例转换。这种做法不光繁琐，而且轻易导致ClassCastException。比方：

2. ArrayList list = new ArrayList();
3. list.add(11);
4. list.add("ssss");
5. for (int i = 0; i < list.size(); i++) {
6.     System.out.println((String) list.get(i));
7. }

复制代码

上述代码在运行时会抛出ClassCastException，由于列表中的元素既有Integer范例，又有String范例。在实行将Integer范例转换为String范例时，会抛出非常。
为了办理这一标题，Java 5引入了泛型。泛型允许在编译时指定聚会合元素的范例，从而在编译阶段就能查抄范例错误，克制运行时非常。比方：

2. List<String> list = new ArrayList<>();
3. list.add("hahah");
4. list.add("ssss");
5. for (int i = 0; i < list.size(); i++) {
6.     System.out.println(list.get(i));
7. }

复制代码

在上面的代码中，我们只能向列表中添加String范例的元素，否则编译器会报错。如许，在调用get()方法时，无需举行显式的范例转换，由于编译器已经确保了元素的范例。
泛型的头脑泉源

泛型的头脑并不是Java独有的，它在其他编程语言中早已存在。比方，C++中的模板（Templates）就是一种参数化范例的机制。模板允许开辟者编写与范例无关的代码，在编译时根据现实的范例参数天生具体的代码。Java的泛型在很大水平上鉴戒了C++模板的头脑。
泛型的特性

范例安全

泛型最明显的特性之一是范例安全。通过泛型，可以在编译时捕获范例错误，而不是在运行时。这大大进步了步调的稳固性和可靠性。比方：

2. List<Integer> intList = new ArrayList<>();
3. intList.add(1);
4. intList.add(2);
5. int firstInt = intList.get(0); // 正确，无需类型转换
6. // intList.add("three"); // 编译错误，无法添加String类型元素

复制代码

在上面的代码中，实行向intList中添加String范例的元素会导致编译错误。这是由于编译器在编译时已经查抄了元素的范例，并确保了范例的划一性。
代码复用

泛型允许编写实用于多种数据范例的代码，从而克制了代码重复。比方，可以编写一个通用的排序方法，该方法可以对任何实现了Comparable接口的对象举行排序：

2. java复制代码
3. public static <T extends Comparable<T>> void sort(List<T> list) {
4. // 实现排序算法
5. }

复制代码

在这个方法中，T是一个范例参数，它表现列表中的元素范例。由于T继续自Comparable<T>，因此可以对列表中的元素举行比力和排序。如许，一个排序方法就可以实用于任何范例的列表，而无需为每种范例编写单独的排序方法。
机动性

泛型提供了在运行时动态指定范例的本领，从而增长了代码的机动性。比方，可以编写一个泛型类，该类可以在创建对象时指定范例参数：

2. public class Box<T> {
3. private T t;
4. public void set(T t) {
5. this.t = t;
6.     }
7. public T get() {
8. return t;
9.     }
10. }
11. // 使用Box类
12. Box<Integer> box1 = new Box<>();
13. box1.set(12);
14. Integer value1 = box1.get();
15. Box<String> box2 = new Box<>();
16. box2.set("abc");
17. String value2 = box2.get();

复制代码

在这个例子中，Box类是一个泛型类，它使用范例参数T来表现存储的元素范例。通过创建Box<Integer>和Box<String>对象，可以分别存储整数和字符串范例的元素。
PECS原则的由来

什么是PECS原则

PECS原则是“Producer Extends, Consumer Super”的缩写，它是由Joshua Bloch在《Effective Java》一书中提出的。PECS原则旨在引导开辟者在使用Java泛型时的通配符选择，特别是在涉及到聚集类时。

• Producer Extends：当你须要从一个数据结构获取（生产）元素时，应该使用extends通配符。如许，你可以从该数据结构读取到的范例为该通配符或其任何子范例的对象。
  
• Consumer Super：当你须要向一个数据结构写入（斲丧）元素时，应该使用super通配符。这允许你写入指定的范例或其任何超范例（父范例）的对象到该数据结构中。
  

PECS原则的由来

PECS原则的提出是为了办理在使用泛型通配符时大概出现的范例安全标题。在没有PECS原则引导的情况下，开辟者大概会错误地选择通配符，从而导致范例不匹配或范例转换非常。
比方，思量以下两个方法：

2. public void printElements(List<? extends Number> list) {
3. for (Number number : list) {
4.         System.out.println(number);
5.     }
6. }
7. public void addElements(List<? super Integer> list) {
8.     list.add(1);
9.     list.add(2);
10. }

复制代码

在printElements方法中，我们使用了extends通配符。这是由于我们只须要从列表中读取元素，而不须要向列表中添加元素。使用extends通配符可以确保我们读取到的元素是Number范例或其子范例，从而克制了范例转换非常。
在addElements方法中，我们使用了super通配符。这是由于我们须要向列表中添加元素，而添加的元素范例是Integer。使用super通配符可以确保我们可以将Integer范例或其父范例的对象添加到列表中。
PECS原则的应用实例

使用extends举行读取使用

假设我们有一个Animal类和一个Bird类，此中Bird继续自Animal。现在，我们想要编写一个方法来打印动物列表中全部鸟的名字：

2. public class Animal {
3.     String name;
4. public Animal(String name) {
5. this.name = name;
6.     }
7. public String getName() {
8. return name;
9.     }
10. }
11. public class Bird extends Animal {
12. public Bird(String name) {
13. super(name);
14.     }
15. }
16. public void printBirdNames(List<? extends Bird> birdList) {
17. for (Bird bird : birdList) {
18.         System.out.println(bird.getName());
19.     }
20. }
21. // 使用方法
22. List<Bird> birdList = Arrays.asList(new Bird("Parrot"), new Bird("Sparrow"));
23. printBirdNames(birdList);

复制代码

在这个例子中，printBirdNames方法继承一个List<? extends Bird>范例的参数。这意味着我们可以通报一个包罗Bird范例或其子范例的列表给该方法。由于我们只从列表中读取元素，因此使用extends通配符是符合的。
使用super举行写入使用

现在，假设我们想要编写一个方法来向动物列表中添加一些默认的鸟：

2. public void addDefaultBirds(List<? super Bird> animalList) {
3.     animalList.add(new Bird("Default Parrot"));
4.     animalList.add(new Bird("Default Sparrow"));
5. }
6. // 使用方法
7. List<Animal> animalList = new ArrayList<>();
8. addDefaultBirds(animalList);

复制代码

在这个例子中，addDefaultBirds方法继承一个List<? super Bird>范例的参数。这意味着我们可以通报一个List<Animal>、List<Bird>或List<Object>范例的列表给该方法。由于我们须要向列表中添加元素，而且添加的元素范例是Bird，因此使用super通配符是符合的。
泛型的范例擦除

什么是范例擦除

Java的泛型是在编译时实现的，而不是在运行时。这意味着在编译后天生的字节码中，泛型信息会被擦除。这种机制被称为范例擦除（Type Erasure）。
范例擦除的目标

范例擦除的目标是为了保持与Java 5之前版本的兼容性。由于泛型是在Java 5中引入的，而在此之前已经存在大量的Java代码，因此为了兼容这些代码，Java操持者选择了范例擦除这种方案。
范例擦除的影响

范例擦除对泛型的使用产生了一些限定和影响：

• 范例参数不支持根本范例：由于范例擦除会将泛型范例更换为它们的上界（通常是Object），而Object不能存储根本范例的值，因此泛型范例参数不支持根本范例。
  
• 不能实例化范例参数：由于范例擦除，无法在运行时创建泛型范例的实例。比方，无法创建T[]范例的数组。
  
• 不能创建泛型数组的实例：同样由于范例擦除，无法创建泛型数组的实例。比方，new T[10]黑白法的。
  
• 运行时范例查抄受限：由于泛型信息在运行时被擦除，因此无法使用instanceof关键字来查抄泛型范例的实例。比方，if (obj instanceof T)黑白法的。
  

范例擦除的实现原理

在编译时，Java编译器会对泛型代码举行范例擦除处置惩罚。具体来说，编译器会将泛型范例更换为它们的上界，并插入须要的范例转换代码以确保范例安全性。
比方，思量以下泛型方法：

2. public static <T> T getFirstElement(List<T> list) {
3. return list.get(0);
4. }

复制代码

在编译后，该方法会被转换为类似以下的代码：

2. public static Object getFirstElement(List list) {
3. return (T) list.get(0); // 插入类型转换
4. }

复制代码

留意，在转换后的代码中，泛型范例T被更换为了Object，而且在返回语句中插入了范例转换。这是为了确保范例安全性，由于编译器知道在调用getFirstElement方法时，传入的列表应该是特定范例的列表（比方List<String>），因此可以将返回的对象逼迫转换为该范例。
泛型的边界限定

什么是边界限定

边界限定（Bounded Types）允许对泛型范例参数施加束缚。通过边界限定，可以确保泛型范例参数是某个特定类或接口的子范例或实现范例。
边界限定的语法

边界限定的语法如下：

2. java复制代码
3. <T extends Bound>

复制代码

此中，T是泛型范例参数，Bound是对T的束缚。Bound可以是一个类或接口。
边界限定的应用实例

泛型类的边界限定

假设我们想要编写一个泛型类，该类只能处置惩罚数值范例的对象。我们可以使用边界限定来确保这一点：

2. public class NumericBox<T extends Number> {
3. private T value;
4. public void setValue(T value) {
5. this.value = value;
6.     }
7. public T getValue() {
8. return value;
9.     }
10. }
11. // 使用NumericBox类
12. NumericBox<Integer> intBox = new NumericBox<>();
13. intBox.setValue(123);
14. Integer intValue = intBox.getValue();
15. NumericBox<Double> doubleBox = new NumericBox<>();
16. doubleBox.setValue(123.45);
17. Double doubleValue = doubleBox.getValue();

复制代码

在这个例子中，NumericBox类是一个泛型类，它使用边界限定T extends Number来确保T只能是Number范例或其子范例（如Integer、Double等）。
泛型方法的边界限定

同样地，我们也可以对泛型方法举行边界限定。比方，我们可以编写一个泛型方法来盘算两个数值的和：

2. public static <T extends Number> double sum(T a, T b) {
3. return a.doubleValue() + b.doubleValue();
4. }
5. // 使用sum方法
6. double result1 = sum(123, 456);
7. double result2 = sum(123.45, 67.89);

复制代码

在这个例子中，sum方法是一个泛型方法，它使用边界限定T extends Number来确保a和b只能是Number范例或其子范例。然后，方法将a和b转换为double范例并盘算它们的和。
总结

Java泛型是一个强大的特性，它提供了编译时的范例安全查抄、代码复用和机动性。通过深入明白泛型的诞生配景、特性以及PECS原则，我们可以更好地使用泛型来编写高质量、可维护的Java代码。同时，我们也须要留意泛型的一些限定和影响，如范例擦除和边界限定等。在现实开辟中，公道使用泛型将大大进步代码的质量和服从。