Java中的泛型类

Java中的泛类

---

Java 的泛型（Generics）是一种语言特性，允许你定义类、接口和方法时使用类型参数。这使得代码更具可读性和安全性，因为编译器能够在编译时检查类型，而不是在运行时。

泛型类

定义泛型类时，可以使用类型参数。例如：

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}
1
2
3
4
5
6
7
8
9
10
11

在这里，T 是一个类型参数，可以在类的任何地方使用。当你创建 Box 的实例时，可以指定实际的类型参数：

Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
String content = stringBox.getContent();
1
2
3

泛型方法

你还可以在方法中使用泛型。例如：

public class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}
1
2
3
4
5
6
7

调用泛型方法时，可以显式或隐式地指定类型参数：

String[] stringArray = {"A", "B", "C"};
Util.printArray(stringArray);
1
2

泛型接口

接口也可以是泛型的。例如：

public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}
1
2
3
4

然后实现这个接口：

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;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}
1
2
3
4
5
6
7
8
9
10
11
12

使用泛型接口时，指定类型参数：

Pair<String, Integer> pair = new OrderedPair<>("key", 123);
1

通配符

Java 泛型提供了通配符，用于处理泛型类型的未知类型。

无界通配符

表示可以是任何类型：

public void printList(List<?> list) {
    for (Object elem : list) {
        System.out.println(elem);
    }
}
1
2
3
4
5

有界通配符

表示类型的上下限：

// 上界通配符：表示类型必须是 Number 或其子类
public void processList(List<? extends Number> list) {
    // ... code ...
}

// 下界通配符：表示类型必须是 Integer 或其超类
public void addIntegers(List<? super Integer> list) {
    // ... code ...
}
1
2
3
4
5
6
7
8
9

泛型的优点

1. 类型安全：在编译时进行类型检查，减少了类型转换错误。
2. 重用代码：通过泛型，代码可以适用于多种数据类型。
3. 提高可读性：泛型代码更具可读性，因为它明确了使用的类型。

类型擦除

在运行时，所有的泛型类型信息都会被移除，这个过程称为类型擦除。编译器在编译时会进行类型检查和转换，但在运行时，所有的泛型类型都被转换为 Object 或其边界类型。例如：

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}
1
2
3
4
5
6
7
8
9
10
11

编译后：

public class Box {
    private Object content;

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

    public Object getContent() {
        return content;
    }
}
1
2
3
4
5
6
7
8
9
10
11

示例

这里是一个完整的例子，展示了泛型类、泛型方法和通配符：

import java.util.ArrayList;
import java.util.List;

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

        // 泛型方法
        List<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        Util.printList(intList);

        // 通配符
        List<Number> numberList = new ArrayList<>();
        numberList.add(1);
        numberList.add(1.5);
        processList(numberList);
    }

    public static void processList(List<? extends Number> list) {
        for (Number num : list) {
            System.out.println(num);
        }
    }
}

class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

class Util {
    public static <T> void printList(List<T> list) {
        for (T element : list) {
            System.out.println(element);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

这个示例展示了如何使用泛型类、方法和通配符来创建类型安全和可重用的代码。