泛型的使用详解

在 Java 中，泛型（Generics）允许你在定义类、接口和方法时使用类型参数，从而提高代码的类型安全性和可重用性。以下是对 Java 泛型的详细解释和复杂一些的例子。

一、泛型的基本概念

类型参数

泛型中的类型参数是一种占位符，代表在使用泛型类型时实际传入的具体类型。例如，在List<T>中，T就是类型参数。

可以使用多个类型参数，如Map<K, V>中的K和V。
类型安全

泛型确保在编译时进行类型检查，避免了类型转换错误。例如，使用List<Integer>时，只能向列表中添加整数类型的元素，而不能添加其他类型的元素。
可重用性

泛型类型可以在不同的类型上重复使用，提高了代码的可重用性。例如，List<Integer>和List<String>都是使用相同的List泛型类型，但存储不同类型的元素。

二、泛型的使用场景

集合类

Java 集合框架广泛使用泛型来提供类型安全的集合操作。例如，ArrayList<Integer>表示存储整数的列表，HashMap<String, Integer>表示键为字符串、值为整数的映射。
自定义类和接口

可以定义自己的泛型类和接口，以实现更灵活的数据结构和算法。例如：

java 复制代码

class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }
}

在上面的例子中，Box类是一个泛型类，可以存储任何类型的对象。

方法泛型

可以在方法中使用泛型，以实现更通用的方法。例如：

java 复制代码

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

在上面的例子中，printArray方法是一个泛型方法，可以打印任何类型的数组。

三、复杂一些的泛型例子

泛型边界

可以使用泛型边界来限制类型参数的类型范围。例如：

java 复制代码

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

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

    public double getDoubleValue() {
        return number.doubleValue();
    }
}

在上面的例子中，NumberBox类的类型参数T被限制为Number及其子类，确保只能存储数字类型的对象。

泛型通配符
泛型通配符可以用于表示未知类型或多种类型。例如：

java 复制代码

class WildcardExample {
    public static void printList(List<?> list) {
        for (Object element : list) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

在上面的例子中，printList方法使用了通配符?，表示可以接受任何类型的列表。

泛型方法的多态性

泛型方法可以在不同的类型上表现出多态性。例如：

java 复制代码

class PolymorphicGenericMethod {
    public static <T> T getMiddleElement(T[] array) {
        int middleIndex = array.length / 2;
        return array[middleIndex];
    }
}

在上面的例子中，getMiddleElement方法可以根据传入的数组类型返回不同类型的中间元素。

泛型接口的实现

可以实现泛型接口，并根据具体需求指定类型参数。例如：

java 复制代码

interface Comparable<T> {
    int compareTo(T o);
}

class IntegerComparator implements Comparable<Integer> {
    @Override
    public int compareTo(Integer o) {
        return 0;
    }
}

在上面的例子中，IntegerComparator类实现了Comparable<Integer>接口，用于比较整数类型的对象。

四、总结

Java 泛型提供了一种强大的机制，可以提高代码的类型安全性、可重用性和灵活性。通过使用类型参数、泛型边界、通配符和泛型方法，可以实现复杂的数据结构和算法，并在不同的类型上进行通用的操作。在使用泛型时，需要注意类型擦除和泛型的限制，以确保代码的正确性和性能。

在 Java 泛型中，extends和super主要用于限定通配符的类型范围，它们有各自特定的使用场景。

一、extends的使用场景

用于读取泛型类型的值

当使用? extends T通配符时，表示可以接受类型为T或T的子类型的泛型对象。这种情况下，只能从该泛型对象中读取数据，不能向其中写入数据。

例如，假设有以下方法：

java 复制代码

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

这个方法可以接受存储了Number或其任何子类型（如Integer、Double等）的列表，并遍历打印其中的元素。但不能向这个列表中添加任何元素，因为编译器无法确定具体的子类型，添加元素可能会导致类型不匹配的错误。

在泛型方法中返回特定类型或其子类型的值

当一个泛型方法需要返回一个类型为T或T的子类型的对象时，可以使用? extends T来表示返回值的类型范围。

例如：

java 复制代码

public static <T extends Number> T getMaxNumber(List<? extends T> list) {
    T max = null;
    for (T number : list) {
        if (max == null || number.doubleValue() > max.doubleValue()) {
            max = number;
        }
    }
    return max;
}

这个方法可以接受存储了特定类型数字（如Integer、Double等）或其子类型的列表，并返回其中的最大值。

二、super的使用场景

用于写入泛型类型的值

当使用? super T通配符时，表示可以接受类型为T或T的父类型的泛型对象。这种情况下，可以向该泛型对象中写入类型为T或T的子类型的元素，但只能读取类型为Object的元素。

例如，假设有以下方法：

java 复制代码

public static void addNumber(List<? super Integer> list, Integer number) {
    list.add(number);
}

这个方法可以接受存储了Integer或其任何父类型（如Number、Object等）的列表，并向其中添加一个整数元素。但在读取列表中的元素时，只能将其视为Object类型，因为编译器无法确定具体的父类型。

在泛型方法中接受特定类型或其父类型的值作为参数

当一个泛型方法需要接受一个类型为T或T的父类型的对象作为参数时，可以使用? super T来表示参数的类型范围。

例如：

java 复制代码

public static <T> void processNumbers(List<? super T> list, T number) {
    list.add(number);
    // 不能直接从 list 中读取 T 类型的元素，只能读取 Object 类型的元素
}

这个方法可以接受存储了特定类型或其父类型的列表，并向其中添加一个该类型的元素。

总之，extends主要用于读取泛型类型的值或在泛型方法中返回特定类型或其子类型的值，而super主要用于写入泛型类型的值或在泛型方法中接受特定类型或其父类型的值作为参数。正确使用这两个关键字可以提高泛型代码的灵活性和安全性。