Java中的泛型

泛型（Generics）是Java中一个非常重要的特性，它从Java 5（JDK 1.5）开始引入。泛型的主要目的是增强代码的类型安全性，减少类型转换的错误，并提高代码的可重用性和可读性。以下是对Java中泛型的详细介绍：

1. 泛型的基本概念

泛型允许在定义类、接口或方法时使用类型参数（Type Parameters），这些类型参数可以在使用时指定具体的类型。通过泛型，可以编写更通用、类型安全的代码。

1.1 泛型的好处

• 类型安全：泛型在编译时检查类型，避免运行时的类型转换错误。
• 代码复用：可以编写通用的代码，适用于多种类型。
• 消除强制类型转换：减少代码中的显式类型转换。
• 更好的可读性：代码中明确指定了类型，更容易理解。

1.2 泛型的基本语法

• 使用尖括号<>定义类型参数。
• 类型参数通常用单个大写字母表示，例如：
  • T：表示类型（Type）
  • E：表示元素（Element）
  • K：表示键（Key）
  • V：表示值（Value）

2. 泛型类

泛型类是指具有一个或多个类型参数的类。类型参数在实例化时指定具体类型。

2.1 定义泛型类

▼
java
复制代码
// 定义一个泛型类
public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

2.2 使用泛型类

▼
java
复制代码
public class Main {
    public static void main(String[] args) {
        // 实例化一个Box，指定类型为String
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello");
        System.out.println(stringBox.getItem()); // 输出: Hello

        // 实例化一个Box，指定类型为Integer
        Box<Integer> integerBox = new Box<>();
        integerBox.setItem(123);
        System.out.println(integerBox.getItem()); // 输出: 123
    }
}

3. 泛型方法

泛型方法是指具有类型参数的方法。类型参数的作用范围仅限于该方法。

3.1 定义泛型方法

▼
java
复制代码
public class Util {
    // 定义一个泛型方法
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

3.2 使用泛型方法

▼
java
复制代码
public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"A", "B", "C"};

        // 调用泛型方法
        Util.printArray(intArray); // 输出: 1 2 3
        Util.printArray(strArray); // 输出: A B C
    }
}

4. 泛型接口

泛型接口是指具有类型参数的接口。

4.1 定义泛型接口

▼
java
复制代码
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

4.2 实现泛型接口

▼
java
复制代码
public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }
}

4.3 使用泛型接口

▼
java
复制代码
public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> pair = new OrderedPair<>("Age", 25);
        System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
        // 输出: Key: Age, Value: 25
    }
}

5. 泛型的类型通配符

类型通配符用于表示未知类型，通常用?表示。通配符可以用于方法参数、字段或局部变量。

5.1 上界通配符（<? extends T>）

表示类型必须是T或其子类。

▼
java
复制代码
public static void printList(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

5.2 下界通配符（<? super T>）

表示类型必须是T或其父类。

▼
java
复制代码
public static void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

5.3 无界通配符（<?>）

表示任意类型。

▼
java
复制代码
public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

6. 泛型的类型擦除

Java的泛型是通过类型擦除（Type Erasure）实现的。在编译时，泛型类型参数会被擦除，替换为它们的上界（通常是Object）。

6.1 类型擦除的示例

▼
java
复制代码
// 编译前
public class Box<T> {
    private T item;
    public void setItem(T item) { this.item = item; }
    public T getItem() { return item; }
}

// 编译后（类型擦除）
public class Box {
    private Object item;
    public void setItem(Object item) { this.item = item; }
    public Object getItem() { return item; }
}

6.2 类型擦除的影响

• 泛型类型不能是基本类型（如int、char），必须是引用类型。
• 无法在运行时获取泛型类型的具体信息（如T.class）。

7. 泛型的限制

• 不能实例化泛型类型：例如new T()是非法的。
• 不能创建泛型数组：例如new T[10]是非法的。
• 不能使用基本类型作为泛型参数：例如List<int>是非法的，必须使用List<Integer>。

8. 泛型的最佳实践

• 尽量使用泛型：提高代码的类型安全性和可读性。
• 避免使用原始类型：例如List应改为List<String>。
• 合理使用通配符：在需要灵活处理类型时使用通配符。
• 注意类型擦除的影响：在需要运行时类型信息时，避免依赖泛型。

通过泛型，Java开发者可以编写更通用、更安全的代码。希望以上内容能帮助你更好地理解和应用泛型！如果有进一步的问题，欢迎随时提问！