java基础学习——java泛型

泛型概述

什么是泛型

泛型（Generics） 是 Java 语言中的一项特性，旨在提高代码的重用性、可读性和类型安全性。通过泛型，你可以编写能够处理多种数据类型的类、接口和方法，而无需为每种数据类型都单独编写代码。泛型的主要目的是让代码更加通用和灵活，同时保持编译时的类型检查。

泛型的优缺点

使用泛型的好处：

类型安全 ：编译器可以在编译期间检查类型正确性，避免运行时出现 ClassCastException。
消除强制转换：由于编译器已经知道容器中存储的是什么类型的对象，因此不再需要显式的类型转换。
代码重用：泛型提供了一种机制来编写适用于多种类型的代码，减少了重复代码的数量。
更好的 API 设计：通过泛型，API 可以更清晰地表达意图，并且更容易被其他开发者理解。

尽管泛型提供了很多便利，但也有一些限制：

不能实例化类型参数 ：例如，你不能写 new T() 或 new T[10]。这是因为泛型信息在运行时被擦除（Type Erasure），所以 JVM 不知道 T 实际是什么类型。
原始类型不支持泛型 ：即不能直接将基本数据类型（如 int, double）作为类型参数传递给泛型类或方法；必须使用相应的包装类（如 Integer, Double）。
类型参数的继承关系 ：尽管可以用 extends 关键字来限定类型参数的上界，但是无法使用 implements 来指定接口。

总结

Java 泛型是一项强大的功能，它增强了代码的安全性和灵活性。理解如何正确地使用泛型及其相关概念（如类型参数、通配符等），可以帮助你在编程中写出更加优雅、高效的代码。随着经验的积累，你会发现自己越来越依赖泛型来简化复杂的数据结构和算法实现。通过泛型，你可以编写出既通用又类型安全的代码，从而提升开发效率和软件质量。

泛型的基本使用

首先介绍一下泛型的类型参数。

类型参数

类型参数是指在定义泛型类或方法时使用的占位符，它们通常以大写字母表示（如 T、E、K、V 等）。这些符号代表了将来会被具体类型的值所替换的位置。

T (Type)：通常用于表示任意类型。
E (Element)：通常用于集合中的元素类型。
K (Key) 和 V (Value)：分别用于键值对中的键和值类型。

泛型类

泛型类是在类声明中包含一个或多个类型参数的类。这使得同一个类可以在不同类型的对象上工作，而不需要创建多个版本的类。

java 复制代码

public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

在这个例子中，Box 类可以用来封装任何类型的对象。使用时，可以通过指定具体的类型参数来实例化：

java 复制代码

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

泛型方法

泛型方法是在方法签名中包含类型参数的方法。即使类本身不是泛型类，也可以定义泛型方法。

java 复制代码

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

这里，printArray 方法可以接受任何类型的数组并打印其内容。调用时，类型参数可以由编译器推断：

java 复制代码

Utility.printArray(new Integer[]{1, 2, 3});
Utility.printArray(new String[]{"apple", "banana", "orange"});

泛型接口

泛型接口类似于泛型类，但用于定义可以由多个不同类型的对象实现的行为。

java 复制代码

public interface Container<T> {
    void add(T item);
    T get(int index);
}

泛型的作用

泛型的作用主要体现在以下几个方面，它们共同提高了代码的灵活性、安全性、可读性和可维护性：

提高类型安全性

泛型允许编译器在编译期间执行更严格的类型检查。这有助于避免运行时出现的 ClassCastException 错误，因为编译器会确保你只能向容器中添加正确类型的对象。

示例：

java 复制代码

// 使用泛型前
List rawList = new ArrayList();
rawList.add("String");
rawList.add(42); // 编译时不报错，但可能导致运行时错误

// 使用泛型后
List<String> stringList = new ArrayList<>();
stringList.add("String"); // 正确
// stringList.add(42); // 编译错误，不能添加 Integer 类型的对象

消除强制类型转换

使用泛型可以减少显式的类型转换，因为编译器已经知道容器中存储的是什么类型的对象。这不仅减少了代码中的冗余，还降低了出错的可能性。

示例：

java 复制代码

// 不使用泛型
List rawList = new ArrayList();
rawList.add("Hello");
String str = (String) rawList.get(0); // 需要显式类型转换

// 使用泛型
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
String str = stringList.get(0); // 不需要显式类型转换

增加代码的重用性

通过泛型，你可以编写能够处理多种数据类型的类、接口和方法，而无需为每种类型都单独实现一遍。这使得代码更加通用和灵活，减少了重复代码的数量。

示例：

java 复制代码

// 泛型类
public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

// 使用时可以通过指定具体的类型参数来实例化
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");

Box<Integer> integerBox = new Box<>();
integerBox.setContent(42);

增强 API 的表达能力

泛型可以使 API 更加清晰地表达其意图，让其他开发者更容易理解如何使用这些 API。通过类型参数，API 可以明确指出它接受或返回的数据类型。

示例：

java 复制代码

// 泛型方法
public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

// 调用时编译器可以推断类型参数
printArray(new Integer[]{1, 2, 3});
printArray(new String[]{"apple", "banana", "orange"});

支持复杂的数据结构和算法

泛型特别适合用于实现复杂的集合类（如 ArrayList, HashMap）和其他数据结构。它还简化了编写通用算法的过程，使这些算法能够适用于各种不同类型的输入。

示例：

java 复制代码

// 泛型接口
public interface Container<T> {
    void add(T item);
    T get(int index);
}

// 实现类
public class MyContainer<T> implements Container<T> {
    private List<T> items = new ArrayList<>();

    @Override
    public void add(T item) {
        items.add(item);
    }

    @Override
    public T get(int index) {
        return items.get(index);
    }
}

类型通配符提供灵活性

类型通配符（wildcards）如 ?, <? extends UpperBound> 和 <? super LowerBound> 提供了额外的灵活性，允许你在不知道具体类型的情况下操作泛型类或方法。这对于创建更通用的工具函数非常有用。

示例：

java 复制代码

// 无界通配符
public void printList(List<?> list) {
    for (Object elem : list) {
        System.out.print(elem + " ");
    }
}

// 上限通配符
public double sumOfList(List<? extends Number> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

// 下限通配符
public void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

使用泛型的注意事项

使用 Java 泛型时，有一些重要的注意事项和最佳实践可以帮助你避免常见错误并充分利用泛型的优势。以下是几个关键点：

类型擦除（Type Erasure）

Java 的泛型是通过类型擦除实现的，这意味着在编译后的字节码中，泛型信息会被移除。所有的类型参数都会被替换为它们的上界（通常是 Object），并且任何类型检查都在编译时完成。因此，运行时无法获取泛型的实际类型信息。

不能实例化类型参数 ：例如，你不能写 new T() 或 new T[10]。

java 复制代码

public class Box<T> {
    // 错误：不能实例化类型参数
    // T[] array = new T[10];
    
    // 正确的做法是传递一个 Class 对象或使用 Object 数组
    T[] array = (T[]) new Object[10]; // 注意这可能会引发警告
}

类型安全警告 ：由于类型擦除，某些操作可能会导致未经检查的转换警告。尽量避免这些情况，并在必要时使用 @SuppressWarnings("unchecked") 注解来抑制警告，但要确保这样做不会引入类型不安全的操作。

原始类型与泛型类型的区别

原始类型 ：如果你使用了泛型类或接口的原始形式（即没有指定类型参数），那么泛型信息将被完全忽略，所有类型参数都被视为 Object。这会导致失去类型安全性和强制类型转换的需求。
java 复制代码
```
List rawList = new ArrayList(); // 原始类型
rawList.add("String");
rawList.add(42); // 编译时不报错，但可能导致运行时错误
```

泛型类型：总是尽可能地使用带有类型参数的泛型类型，以保持类型安全。

java 复制代码

List<String> stringList = new ArrayList<>();
stringList.add("Hello"); // 正确
// stringList.add(42); // 编译错误，不能添加 Integer 类型的对象

通配符（Wildcards）的正确使用

无界通配符 ：<?> 表示未知类型，通常用于只读场景，因为不能向这样的集合中添加元素（除了 null）。
java 复制代码
```
void printList(List<?> list) {
    for (Object elem : list) {
        System.out.print(elem + " ");
    }
}
```

上限通配符 ：<? extends UpperBound> 表示类型参数是某个特定类型的子类型，适用于读取操作。

java 复制代码

double sumOfList(List<? extends Number> list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

下限通配符 ：<? super LowerBound> 表示类型参数是某个特定类型的父类型，适用于写入操作。
java 复制代码
```
void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}
```

泛型方法的定义和调用

当你需要一个方法能够处理多种类型的数据时，可以定义泛型方法。注意泛型方法的类型参数应该出现在返回类型之前。

java 复制代码

public <T> void genericMethod(T t) {
    // 方法体
}

调用泛型方法时，类型参数可以由编译器自动推断，通常不需要显式指定。

java 复制代码

genericMethod("Hello"); // 编译器会推断 T 为 String

静态上下文中不能使用类型参数

类型参数只能用于非静态成员变量和方法。如果你想在静态上下文中使用泛型，必须将泛型参数作为方法参数或静态泛型方法的一部分。

java 复制代码

public class GenericClass<T> {
    private static T staticField; // 错误：不能在静态上下文中使用类型参数

    private T nonStaticField; // 正确

    public static <E> void staticGenericMethod(E e) { // 正确：静态泛型方法
        // 方法体
    }
}

避免使用原始类型

尽量避免使用泛型类或接口的原始形式，因为这会导致失去类型安全性和可能的强制类型转换需求。如果必须使用原始类型，应考虑重构代码以使用泛型版本。

理解泛型类的继承规则

如果 B 是 A 的子类，那么 ArrayList<B> 并不是 ArrayList<A> 的子类。换句话说，泛型类之间不存在协变关系。

java 复制代码

List<Animal> animals = new ArrayList<Animal>();
List<Dog> dogs = new ArrayList<Dog>();
// 下面这行代码会导致编译错误
// animals = dogs;

要解决上述问题，可以使用通配符：
java 复制代码
```
List<? extends Animal> animals = new ArrayList<Dog>();
```

泛型和序列化

当泛型类实现了 Serializable 接口时，需要注意类型参数的信息不会被序列化。如果你需要保存泛型类的状态，确保所有字段都是可序列化的，并且考虑到类型擦除的影响。