寒假打卡07——1月20日

Java 泛型基础——泛型类、泛型方法、泛型接口

Java 泛型（Generics）是 Java 5 引入的一种重要特性，它允许我们在定义类、接口和方法时使用类型参数，从而使代码更加通用和类型安全。泛型可以帮助我们在编译时检查类型错误，减少类型转换的麻烦，并提高代码的可读性和可维护性。

泛型类

泛型类是指带有一个或多个类型参数的类。在定义泛型类时，我们可以在类名后面使用尖括号 <> 指定类型参数。

示例代码

下面是一个简单的泛型类示例，展示了如何定义和使用泛型类：

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }

    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setContent(123);
        System.out.println("Integer Box: " + intBox.getContent());

        Box<String> strBox = new Box<>();
        strBox.setContent("Hello, Generics!");
        System.out.println("String Box: " + strBox.getContent());
    }
}

在上述代码中，我们定义了一个泛型类 Box<T>，其中 T 是类型参数。我们可以在实例化泛型类时指定具体的类型，如 Integer 和 String。

泛型方法

泛型方法是指带有一个或多个类型参数的方法。在定义泛型方法时，我们可以在方法返回类型之前使用尖括号 <> 指定类型参数。

示例代码

下面是一个简单的泛型方法示例，展示了如何定义和使用泛型方法：

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

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"Hello", "World", "Generics"};

        printArray(intArray);
        printArray(strArray);
    }
}

在上述代码中，我们定义了一个泛型方法 printArray(T[] array)，其中 T 是类型参数。我们可以在调用泛型方法时传递不同类型的数组，如 Integer 数组和 String 数组。

泛型接口

泛型接口是指带有一个或多个类型参数的接口。在定义泛型接口时，我们可以在接口名后面使用尖括号 <> 指定类型参数。

示例代码

下面是一个简单的泛型接口示例，展示了如何定义和使用泛型接口：

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

class KeyValuePair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public KeyValuePair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    public static void main(String[] args) {
        Pair<Integer, String> pair = new KeyValuePair<>(1, "One");
        System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
    }
}

在上述代码中，我们定义了一个泛型接口 Pair<K, V>，其中 K 和 V 是类型参数。我们实现了这个接口的 KeyValuePair 类，并在实例化时指定具体的类型。

类型通配符

类型通配符（Wildcard）是泛型的一种特殊用法，它使用问号 ? 表示不确定的类型。类型通配符可以用于泛型类、泛型方法和泛型接口中，以表示可以接受任何类型的参数。

示例代码

下面是一个使用类型通配符的示例，展示了如何定义和使用类型通配符：

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

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

    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);

        List<String> strList = new ArrayList<>();
        strList.add("Hello");
        strList.add("World");

        printList(intList);
        printList(strList);
    }
}

在上述代码中，我们定义了一个泛型方法 printList(List<?> list)，其中 ? 是类型通配符，表示可以接受任何类型的 List。我们可以在调用泛型方法时传递不同类型的 List，如 Integer 列表和 String 列表。

类型边界

类型边界（Bounded Type Parameters）是泛型的一种高级用法，它允许我们对类型参数进行约束。我们可以使用 extends 关键字来指定类型参数的上边界，或者使用 super 关键字来指定类型参数的下边界。

示例代码

下面是一个使用类型边界的示例，展示了如何定义和使用类型边界：

public class BoundedTypeDemo {
    public static <T extends Number> void printNumber(T number) {
        System.out.println("Number: " + number);
    }

    public static void main(String[] args) {
        printNumber(123);
        printNumber(45.67);
        // printNumber("Hello"); // 编译错误，String 不是 Number 的子类
    }
}

在上述代码中，我们定义了一个泛型方法 printNumber(T number)，并使用 T extends Number 指定类型参数 T 的上边界为 Number 类。这样，我们只能传递 Number 类及其子类的实例，如 Integer 和 Double。

总结

Java 泛型是一个强大的特性，它允许我们在定义类、接口和方法时使用类型参数，从而使代码更加通用和类型安全。通过使用泛型类、泛型方法、泛型接口、类型通配符和类型边界，我们可以编写出更灵活和高效的代码。

希望通过本篇文章，大家对 Java 泛型基础有了更深入的了解。在接下来的文章中，我们将继续探讨更多关于 Java 泛型的知识点，敬请期待！