Java 泛型：从入门到精通的进阶之路

Java 泛型是 Java 语言中一个非常重要的特性，它在类型安全、代码复用和程序可维护性方面提供了极大的帮助。然而，泛型的概念并不简单，尤其是当涉及到通配符、类型擦除和泛型边界等进阶内容时，很多开发者会感到困惑。本文将带你从泛型的基础概念出发，逐步深入到泛型的进阶用法，通过详细的代码示例和深入的分析，帮助你全面掌握 Java 泛型。

一、泛型的基础概念

1.1 什么是泛型？

泛型（Generics）是 Java 5 引入的一种特性，它允许在定义类、接口和方法时使用类型参数。通过泛型，我们可以在编译时指定类型，从而避免在运行时进行类型转换，提高代码的安全性和可读性。

1.2 泛型的基本用法

示例 1：泛型类

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

// 使用泛型类
public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, Generics!");
        System.out.println(stringBox.getContent()); // 输出：Hello, Generics!

        Box<Integer> integerBox = new Box<>();
        integerBox.setContent(123);
        System.out.println(integerBox.getContent()); // 输出：123
    }
}

在这个例子中，Box<T> 是一个泛型类，T 是类型参数。通过指定 Box<String> 或 Box<Integer>，我们可以创建不同类型的具体实例。

示例 2：泛型方法

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

// 使用泛型方法
public class Main {
    public static void main(String[] args) {
        String[] strings = {"Apple", "Banana", "Cherry"};
        Utils.printArray(strings);

        Integer[] numbers = {1, 2, 3, 4, 5};
        Utils.printArray(numbers);
    }
}

泛型方法通过 <T> 定义类型参数，允许方法在不同类型的参数上工作。

二、泛型的限制与边界

2.1 泛型的类型限制

泛型类型不能是原始类型（如 int、double 等），只能是引用类型。例如：

Box<int> intBox = new Box<>(); // 错误：类型参数不能是原始类型

2.2 泛型的边界

泛型边界用于限制类型参数的范围，确保类型参数符合特定条件。

示例：上界通配符（extends）

public class Animal {}
public class Dog extends Animal {}
public class Cat extends Animal {}

public class Zoo {
    public static void feedAnimals(List<? extends Animal> animals) {
        for (Animal animal : animals) {
            System.out.println("Feeding animal: " + animal);
        }
    }
}

// 使用上界通配符
public class Main {
    public static void main(String[] args) {
        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        Zoo.feedAnimals(dogs);

        List<Cat> cats = new ArrayList<>();
        cats.add(new Cat());
        Zoo.feedAnimals(cats);
    }
}

上界通配符 <? extends Animal> 表示列表中的元素可以是 Animal 或其子类。

示例：下界通配符（super）

public class Zoo {
    public static void addAnimals(List<? super Dog> animals) {
        animals.add(new Dog());
    }
}

// 使用下界通配符
public class Main {
    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        Zoo.addAnimals(animals); // 可以添加 Dog 到 Animal 列表中
    }
}

下界通配符 <? super Dog> 表示列表中的元素可以是 Dog 或其父类。

三、泛型与继承

3.1 泛型类的继承

泛型类可以继承其他泛型类，也可以实现泛型接口。

public class Box<T> {}
public class FruitBox<T> extends Box<T> {} // 泛型类继承

public interface Comparable<T> {
    int compareTo(T o);
}

public class Person implements Comparable<Person> {
    @Override
    public int compareTo(Person o) {
        // 实现比较逻辑
        return 0;
    }
}

3.2 泛型方法的重载

泛型方法可以重载，但需要注意类型参数的差异。

public class Utils {
    public static <T> void print(T value) {
        System.out.println(value);
    }

    public static void print(int value) {
        System.out.println("Primitive int: " + value);
    }
}

// 使用重载的泛型方法
public class Main {
    public static void main(String[] args) {
        Utils.print("Hello"); // 调用泛型方法
        Utils.print(123);     // 调用重载的方法
    }
}

四、类型擦除与泛型的局限性

4.1 什么是类型擦除？

Java 泛型在编译时会进行类型擦除，即泛型类型信息会被擦除，替换为原始类型（通常是 Object）。例如：

Box<String> stringBox = new Box<>();
Box<Integer> integerBox = new Box<>();

// 编译后，两者都变为 Box 对象

4.2 类型擦除的影响

1. 无法创建泛型数组：

   Box<String>[] stringBoxes = new Box<String>[10]; // 错误：泛型数组创建
   

2. 运行时无法获取泛型类型信息：

   Box<String> stringBox = new Box<>();
   Box<Integer> integerBox = new Box<>();
   
   System.out.println(stringBox.getClass() == integerBox.getClass()); // 输出：true
   

4.3 如何解决类型擦除的问题？

可以通过反射获取泛型类型信息，但通常不推荐这样做。更好的方法是设计代码时避免依赖运行时类型信息。

五、泛型的高级用法

5.1 泛型与反射

反射可以用来获取泛型类型信息，但需要谨慎使用。

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

public class GenericTypeResolver {
    public static <T> Class<T> getGenericType(Class<?> clazz) {
        Type type = clazz.getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments.length > 0) {
                return (Class<T>) actualTypeArguments[0];
            }
        }
        return null;
    }
}

// 使用反射获取泛型类型
public class Main {
    public static void main(String[] args) {
        Class<?> type = GenericTypeResolver.getGenericType(FruitBox.class);
        System.out.println(type); // 输出：class java.lang.Object
    }
}

5.2 泛型注解

Java 8 引入了泛型注解（Type Annotations），允许在类型使用处添加注解。

public class SafeBox<T @NonNull()> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

// 使用泛型注解
public class Main {
    public static void main(String[] args) {
        SafeBox<@NonNull String> safeBox = new SafeBox<>();
        safeBox.setContent("Hello"); // 正常
        // safeBox.setContent(null); // 报错：@NonNull 约束
    }
}

六、总结

Java 泛型是一个强大但复杂的特性，它在类型安全和代码复用方面提供了巨大的帮助。通过本文的讲解，你已经掌握了泛型的基础用法、边界限制、类型擦除以及高级技巧。在实际开发中，合理使用泛型可以显著提升代码的质量和可维护性。

希望本文能帮助你在 Java 泛型的道路上更进一步！如果你有任何疑问或想法，欢迎在评论区留言交流。