如何使用Java泛型实现类型安全

在Java中，泛型（Generics）是一种强大的工具，它允许你在编译时进行类型检查，从而确保类型安全。以下是如何使用Java泛型实现类型安全的详细步骤和示例：

1. 定义泛型类或方法

你可以定义一个泛型类或方法，使其能够处理多种数据类型，同时保持类型安全。

泛型类示例

public class Box<T> {
    private T content;

    public Box(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

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

在这个例子中，Box类有一个类型参数T，它可以是任何类型。当你创建一个Box对象时，你可以指定具体的类型。

Box<String> stringBox = new Box<>("Hello");
String content = stringBox.getContent(); // 类型安全，不需要类型转换

泛型方法示例

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

在这个例子中，printArray方法可以接受任何类型的数组，并且保持类型安全。

String[] stringArray = {"Hello", "World"};
GenericMethodExample.printArray(stringArray); // 类型安全

Integer[] intArray = {1, 2, 3};
GenericMethodExample.printArray(intArray); // 类型安全

2. 使用通配符

通配符（Wildcard）可以用来表示未知类型，这在某些情况下非常有用。

无界通配符

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

这个方法可以接受任何类型的List。

上界通配符

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

这个方法可以接受任何Number类型或其子类型的List。

下界通配符

public void addIntegers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

这个方法可以接受任何Integer类型或其父类型的List。

3. 泛型约束

你可以使用泛型约束（也称为类型边界）来限制泛型参数的类型。

单一约束

public class NumberBox<T extends Number> {
    private T number;

    public NumberBox(T number) {
        this.number = number;
    }

    public T getNumber() {
        return number;
    }

    public void setNumber(T number) {
        this.number = number;
    }
}

在这个例子中，NumberBox类只能接受Number类型或其子类型的参数。

NumberBox<Integer> integerBox = new NumberBox<>(123);
NumberBox<Double> doubleBox = new NumberBox<>(123.45);

多重约束

public class MultiConstraintBox<T extends Number & Comparable<T>> {
    private T value;

    public MultiConstraintBox(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

在这个例子中，MultiConstraintBox类只能接受既是Number又是Comparable的类型。

MultiConstraintBox<Integer> integerBox = new MultiConstraintBox<>(123);
MultiConstraintBox<Double> doubleBox = new MultiConstraintBox<>(123.45);

4. 避免原始类型

始终使用泛型类型而不是原始类型（raw type），以确保类型安全。

// 不推荐
List rawList = new ArrayList();
rawList.add("Hello");
String s = (String) rawList.get(0); // 需要类型转换，不安全

// 推荐
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
String s = stringList.get(0); // 不需要类型转换，类型安全

通过遵循这些步骤和示例，你可以有效地使用Java泛型来实现类型安全，从而提高代码的健壮性和可维护性。