泛型是Java中的一种强类型机制，它允许在定义类、接口和方法时，使用类型参数即占位符来指定操作的对象类型。开发者可以通过泛型，编写更通用、可重用的代码，同时提高类型安全性。下面我们就来详细的介绍一下泛型的使用。

泛型类

泛型类是在类声明时使用类型参数，使得该类可以操作多种类型，而不需要具体化这些类型。如下所示。

public class Box<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

在这个类中通过参数T来定义其类型参数，我们可以将这个类实例化成任何类型，例如Box 或 Box。如下所示。

Box<Integer> integerBox = new Box<>();
integerBox.set(10);
Integer value = integerBox.get();

Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String str = stringBox.get();

泛型方法

泛型方法是在方法定义时使用类型参数，使得该方法可以应用于多种类型，而不需要具体化这些类型。如下所示。

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

在这个例子中，printArray 是一个泛型方法，其中 声明了一个类型参数 T。

Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"one", "two", "three"};

Util.printArray(intArray);
Util.printArray(strArray);

泛型接口

泛型接口和泛型类类似，只不过它用于接口的定义。

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

在这个例子中，Pair 是一个泛型接口，K 和 V 是类型参数。

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

可以通过如下的方式来使用泛型接口

Pair<String, Integer> pair = new OrderedPair<>("One", 1);
String key = pair.getKey();
Integer value = pair.getValue();

泛型的类型限制（上限和下限）

泛型可以指定类型参数的上限（即类型必须是某个类的子类）或下限（即类型必须是某个类的父类），如下所示。

类型上限

public <T extends Number> void printNumber(T number) {
    System.out.println(number);
}

在这个例子中，T 必须是 Number 的子类。

类型下限

public static void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

在这个例子中，? super Integer 表示可以是 Integer 或者其父类。

通配符（Wildcard）

在泛型中，通配符 ? 表示一个未知的类型。通配符主要有三种形式，如下所示。

• <?>：表示一个未知的类型。
• <? extends T>：表示类型为 T 或 T 的子类。
• <? super T>：表示类型为 T 或 T 的父类。

普通通配符

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

上限通配符

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

下限通配符

public void addInteger(List<? super Integer> list) {
    list.add(10);
}

泛型擦除

Java 中泛型是通过类型擦除（Type Erasure）来实现的。类型擦除意味着在编译时，所有的泛型信息都会被移除，替换为它们的上限（如果没有指定，则为 Object）。这意味着在运行时，泛型类型信息不可用。如下所示。

public class Box<T> {
    private T t;
}

编译后，Box 会被擦除为 Box，而 T 被替换为 Object。

泛型和继承

泛型类型与继承的关系较为复杂。例如，List<String> 并不是 List<Object> 的子类型。如下所示。

List<Object> objects = new ArrayList<>();
List<String> strings = new ArrayList<>();
// objects = strings; // 编译错误，类型不匹配

但是，我们可以使用通配符来实现类似的效果，如下所示。

List<? extends Object> objects = new ArrayList<>();
List<String> strings = new ArrayList<>();
objects = strings; // 正常

总结

Java 泛型是一种强大的特性，允许编写更加灵活和类型安全的代码。通过泛型，开发者可以创建能够处理多种数据类型的通用类、接口和方法，同时保持代码的可读性和安全性。在使用泛型时，要特别注意泛型的类型擦除和继承关系，以及何时使用通配符以保持代码的灵活性。