Java中的泛型类

发布于:2024-07-11 ⋅ 阅读:(31) ⋅ 点赞:(0)

Java中的泛类


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

泛型类

定义泛型类时,可以使用类型参数。例如:

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

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

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

泛型方法

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

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

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

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

泛型接口

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

public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}

然后实现这个接口:

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

使用泛型接口时,指定类型参数:

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

通配符

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

无界通配符

表示可以是任何类型:

public void printList(List<?> list) {
    for (Object elem : list) {
        System.out.println(elem);
    }
}
有界通配符

表示类型的上下限:

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

// 下界通配符:表示类型必须是 Integer 或其超类
public void addIntegers(List<? super Integer> list) {
    // ... code ...
}

泛型的优点

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

类型擦除

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

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

编译后:

public class Box {
    private Object content;

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

    public Object getContent() {
        return content;
    }
}

示例

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

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

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