掌握 Java 泛型（Generics）：通过类型参数化实现代码的通用性与类型安全，减少强制类型转换和运行时错误。

好的，各位观众，各位听众，欢迎来到今天的“Java 泛型漫谈”节目！我是你们的老朋友，也是你们的编程向导，今天就让我们一起拨开Java泛型的神秘面纱，看看它如何让我们的代码更优雅、更安全、更通用。

开场白：代码界的“变形金刚”——泛型

各位有没有看过《变形金刚》？擎天柱一句“汽车人，变形！”就能变成一辆威风凛凛的卡车。我们的Java泛型，就像代码界的“变形金刚”，它能根据你传入的类型，摇身一变，变成你需要的样子。

想想看，如果没有泛型，我们操作List的时候，每次都要小心翼翼地进行类型转换，一不小心就会冒出个ClassCastException，简直像在雷区蹦迪，心惊胆战！有了泛型，我们就可以告诉编译器：“嘿，我这个List里放的都是String类型的，你给我好好检查，别让别的类型混进来！”

所以，今天，我们就来深入了解一下这个“变形金刚”，看看它到底有多厉害。

第一章：泛型的基本概念与语法

1.1 什么是泛型？

简单来说，泛型是一种参数化类型的机制。它允许我们在定义类、接口和方法的时候，使用类型参数，而不是具体的类型。这些类型参数在使用时才会被实际的类型替换。

你可以把类型参数想象成一个占位符，就像填字游戏里的空格，等你真正使用的时候，再把空格填上具体的字。

举个栗子🌰：

假设我们要创建一个通用的List，它可以存放任何类型的对象。在没有泛型之前，我们可能会这样写：

List list = new ArrayList(); // raw type，原始类型
list.add("Hello");
list.add(123); // Oh no! 编译器不会报错，但运行时可能会出问题
String str = (String) list.get(1); // ClassCastException!

看到了吗？因为我们没有指定List里存放的类型，所以它可以存放任何类型的对象。但是，当我们从List里取出对象时，就需要进行强制类型转换，而且稍有不慎就会抛出ClassCastException。

有了泛型，我们就可以这样写：

List<String> list = new ArrayList<>(); // 使用泛型指定类型为String
list.add("Hello");
// list.add(123); // 编译时报错！类型不匹配
String str = list.get(0); // 不需要强制类型转换，直接获取String类型

看到了吗？使用泛型后，编译器会帮我们检查类型，如果试图向List中添加不符合类型的对象，编译器会直接报错，避免了运行时错误的发生。

1.2 泛型的语法

泛型的语法主要包括：

类型参数的声明： 使用尖括号 <> 来声明类型参数，通常使用单个大写字母表示，例如 T (Type), E (Element), K (Key), V (Value) 等。
泛型类： 在类名后面使用 <> 声明类型参数。
泛型接口： 在接口名后面使用 <> 声明类型参数。
泛型方法： 在方法返回值之前使用 <> 声明类型参数。

表格总结：泛型语法一览

类型	语法	示例
泛型类	`class ClassName<T> { ... }`	`class Box<T> { private T t; public void set(T t) { this.t = t; } }`
泛型接口	`interface InterfaceName<T> { ... }`	`interface List<T> { boolean add(T e); T get(int index); }`
泛型方法	`public <T> ReturnType methodName(T arg) { ... }`	`public <T> T getElement(List<T> list, int index) { return list.get(index); }`

1.3 类型参数的命名规范

虽然你可以使用任何大写字母作为类型参数的名字，但是为了代码的可读性和一致性，建议遵循以下命名规范：

E – Element (集合中的元素)
K – Key (键)
N – Number (数字)
T – Type (类型)
V – Value (值)
S, U, V etc. – 第二个、第三个、第四个类型

第二章：泛型的应用场景

泛型就像一位多才多艺的演员，可以在各种场景中发挥它的作用。

2.1 泛型类

泛型类是最常见的泛型应用场景。它可以让我们创建可以处理不同类型的类。

例子：一个通用的盒子📦

class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.set(10);
        System.out.println(integerBox.get()); // Output: 10

        Box<String> stringBox = new Box<>();
        stringBox.set("Hello");
        System.out.println(stringBox.get()); // Output: Hello
    }
}

在这个例子中，Box 类可以存放任何类型的对象。我们可以创建 Box<Integer> 来存放整数，也可以创建 Box<String> 来存放字符串。

2.2 泛型接口

泛型接口可以让我们定义通用的接口，这些接口可以被不同类型的类实现。

例子：一个通用的比较器Comparator

interface Comparator<T> {
    int compare(T o1, T o2);
}

class StringComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
}

在这个例子中，Comparator 接口定义了一个通用的比较方法，我们可以创建 StringComparator 来比较字符串。

2.3 泛型方法

泛型方法可以让我们编写可以处理不同类型的方法。

例子：一个通用的打印方法

public class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"Hello", "World"};

        printArray(intArray); // Output: 1 2 3 4 5
        printArray(stringArray); // Output: Hello World
    }
}

在这个例子中，printArray 方法可以打印任何类型的数组。

第三章：泛型的深入理解

3.1 类型擦除 (Type Erasure)

Java泛型的一个重要特性是类型擦除。这意味着在编译时，泛型类型信息会被擦除，替换为原始类型（raw type）。例如，List<String> 在编译后会变成 List。

为什么要有类型擦除？

类型擦除的主要目的是为了兼容旧版本的Java代码。在Java 5之前，是没有泛型的。如果Java虚拟机支持泛型，那么旧版本的代码就无法在新版本的虚拟机上运行。通过类型擦除，可以让旧版本的代码在新版本的虚拟机上继续运行。

类型擦除的影响

类型擦除会带来一些限制：

无法在运行时获取泛型类型信息： 因为类型信息在编译时被擦除了，所以在运行时无法获取泛型类型信息。
无法使用泛型类型进行实例化： 例如，你不能创建一个 new T() 的实例，因为编译器不知道 T 的具体类型。
无法使用 instanceof 运算符判断泛型类型： 例如，你不能使用 obj instanceof List<String> 来判断 obj 是否是 List<String> 的实例。

3.2 泛型通配符 (Wildcards)

泛型通配符是一种特殊的类型参数，它可以表示未知类型。主要有两种通配符：

无界通配符 (?)： 表示未知类型，可以匹配任何类型。
上界通配符 (? extends Type)： 表示未知类型，但必须是 Type 或 Type 的子类。
下界通配符 (? super Type)： 表示未知类型，但必须是 Type 或 Type 的父类。

3.2.1 无界通配符 (?)

无界通配符主要用于以下两种情况：

当你只想使用泛型类或方法，而不需要知道具体的类型时。
当你编写的方法可以处理任何类型的泛型集合时。

例子：一个打印List的方法

public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

在这个例子中，printList 方法可以打印任何类型的List。

3.2.2 上界通配符 (? extends Type)

上界通配符可以限制类型参数必须是 Type 或 Type 的子类。

例子：一个计算List中数字之和的方法

public static double sumOfList(List<? extends Number> list) {
    double sum = 0.0;
    for (Number num : list) {
        sum += num.doubleValue();
    }
    return sum;
}

在这个例子中，sumOfList 方法只能计算 Number 或 Number 的子类（例如 Integer, Double）的List之和。

3.2.3 下界通配符 (? super Type)

下界通配符可以限制类型参数必须是 Type 或 Type 的父类。

例子：一个将Integer添加到List的方法

public static void addIntegerToList(List<? super Integer> list) {
    list.add(10);
}

在这个例子中，addIntegerToList 方法可以将 Integer 对象添加到 Integer 或 Integer 的父类（例如 Number, Object）的List中。

3.3 PECS原则 (Producer Extends, Consumer Super)

PECS原则是使用泛型通配符的最佳实践：

Producer Extends： 如果你需要从泛型类型中读取数据，使用 ? extends Type。
Consumer Super： 如果你需要向泛型类型中写入数据，使用 ? super Type。
如果既要读又要写，就不要使用通配符。

举个栗子🌰：

假设我们有一个 List<Apple>，我们需要将它复制到另一个 List 中。

如果我们需要从 List<Apple> 中读取数据，使用 ? extends Apple：

public static void copyApples(List<? extends Apple> source, List<Apple> destination) {
    for (Apple apple : source) {
        destination.add(apple);
    }
}

如果我们需要向 List<Apple> 中写入数据，使用 ? super Apple：

public static void addApples(List<? super Apple> list) {
    list.add(new Apple());
    list.add(new GoldenDelicious()); // GoldenDelicious is a subclass of Apple
}

第四章：泛型的高级应用

4.1 泛型与反射

虽然类型擦除使得在运行时获取泛型类型信息变得困难，但我们仍然可以通过反射来获取一些泛型信息。

例子：获取泛型类的类型参数

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

class GenericClass<T> {
    private T t;

    public T get() {
        return t;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        GenericClass<String> genericClass = new GenericClass<>();

        Type genericSuperclass = genericClass.getClass().getGenericSuperclass();
        if (genericSuperclass instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            Type[] typeArguments = parameterizedType.getActualTypeArguments();
            for (Type typeArgument : typeArguments) {
                System.out.println("Type Argument: " + typeArgument.getTypeName()); // Output: Type Argument: java.lang.String
            }
        }
    }
}

在这个例子中，我们使用反射获取了 GenericClass<String> 的类型参数 String。

4.2 泛型与数组

由于类型擦除的原因，创建泛型数组有一些限制。

不能创建泛型数组的实例： 例如， new T[] 是非法的。
可以使用通配符创建泛型数组： 例如， new List<?>[] 是合法的。

例子：创建一个泛型数组

public class Main {
    public static void main(String[] args) {
        List<?>[] listArray = new List<?>[10]; // 合法

        List<String>[] stringListArray = new List[10]; // Unchecked cast warning，类型不安全
    }
}

第五章：泛型的最佳实践

尽可能使用泛型： 泛型可以提高代码的类型安全性和可读性。
遵循类型参数的命名规范： 使用 E, K, N, T, V 等标准命名。
使用通配符来增加灵活性： 使用 ?, ? extends Type, ? super Type 来处理不同类型的泛型集合。
遵循PECS原则： 使用 Producer Extends, Consumer Super 来确保类型安全。
注意类型擦除的影响： 了解类型擦除的限制，避免出现意外的错误。

总结：泛型的魅力

今天我们一起探索了Java泛型的世界，从基本概念到高级应用，从语法规则到最佳实践。希望通过今天的学习，大家能够更好地理解和应用泛型，让我们的代码更加健壮、更加优雅、更加通用。

泛型就像一位魔法师，它能让我们的代码拥有更强的适应性和灵活性。掌握泛型，就是掌握了一种强大的编程技巧，让我们的代码在各种场景中都能游刃有余。

最后，希望大家在编程的道路上，不断学习，不断进步，创造出更加精彩的代码！谢谢大家！ 👏🎉

发表回复 取消回复

发表回复取消回复