- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

🔥 深入浅出 Java 泛型：让你的代码更灵活、安全又高效！💻

bug菌发表于 2024/11/29 09:44:57 2024/11/29

【摘要】 @TOC 前言 🌟你是否曾经在开发中为处理不同类型的集合而烦恼，尤其是频繁的类型转换让你忍不住头痛？或是你在看一些看似简单的代码时，总是能感受到代码的复杂和不安全？没错，这就是泛型的魔力——它帮助我们在保留灵活性的同时，确保类型安全，减少错误。那么，今天就跟我一起深入探讨一下 Java 泛型，它是如何让你的代码变得既简洁又安全的，告别类型转换的烦恼！🧙‍♂️ 什么是泛型？🧐泛型简单来说...

@TOC

前言 🌟

你是否曾经在开发中为处理不同类型的集合而烦恼，尤其是频繁的类型转换让你忍不住头痛？或是你在看一些看似简单的代码时，总是能感受到代码的复杂和不安全？没错，这就是泛型的魔力——它帮助我们在保留灵活性的同时，确保类型安全，减少错误。那么，今天就跟我一起深入探讨一下 Java 泛型，它是如何让你的代码变得既简洁又安全的，告别类型转换的烦恼！🧙‍♂️

什么是泛型？🧐

泛型简单来说，就是在定义类、接口或者方法时，不指定具体的数据类型，而是使用一个占位符，待实际使用时再指定类型。通过泛型，Java 实现了对不同类型的通用处理，不仅增加了代码的复用性，还提升了类型安全性。我们不再需要在运行时进行类型转换，从而避免了潜在的错误。

举个简单的例子，假设我们有一个 Box 类，它原本只能存储特定类型的对象，但通过泛型，我们就可以让 Box 能够存储任意类型的对象：

public class Box<T> {
    private T value;

    public T getValue() {
        return value;
    }

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

在这个类中，T 就是泛型类型的占位符。你可以根据实际需求将 T 替换为任何类型，像是 String、Integer，甚至是自定义的类型，极大提高了代码的灵活性和复用性。

代码解析：

在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段代码展示了如何使用泛型在 Java 中创建一个简单的容器类 Box，其中 T 是泛型类型，可以在运行时动态指定。

public class Box<T> {
    private T value;  // 声明一个类型为 T 的字段

    // 获取值的方法
    public T getValue() {
        return value;
    }

    // 设置值的方法
    public void setValue(T value) {
        this.value = value;
    }
}

泛型类型 T：

Box<T> 是一个 泛型类，T 是一个占位符，表示任意类型。在实例化 Box 类时，可以指定 T 的具体类型，比如 Box<Integer> 或 Box<String>。
泛型的主要作用是让类、接口和方法能够操作任意类型的数据，同时保证类型安全。

成员变量 value：

private T value;：声明了一个类型为 T 的字段，这意味着 Box 类将持有一个任意类型的对象。
因为 T 是一个类型参数，所以它可以是任何类型（如 Integer、String 等）。

方法 getValue 和 setValue：

public T getValue()：返回 Box 中存储的值，类型是 T，即泛型类型。
public void setValue(T value)：接受一个类型为 T 的参数，将其设置为 Box 中的值。
通过这两个方法，你可以安全地操作 Box 中存储的值，而不需要关心它的具体类型。

使用示例

以下是如何使用 Box 类的示例：

使用 Box 存储 Integer 类型：

public class Main {
    public static void main(String[] args) {
        // 创建一个存储 Integer 类型的 Box
        Box<Integer> intBox = new Box<>();
        intBox.setValue(10);  // 设置值为 10
        System.out.println("Integer value: " + intBox.getValue());  // 输出: Integer value: 10
    }
}

使用 Box 存储 String 类型：

public class Main {
    public static void main(String[] args) {
        // 创建一个存储 String 类型的 Box
        Box<String> stringBox = new Box<>();
        stringBox.setValue("Hello, Generics!");  // 设置值为字符串
        System.out.println("String value: " + stringBox.getValue());  // 输出: String value: Hello, Generics!
    }
}

泛型的优势

类型安全：泛型提供了类型检查，避免了类型转换时的 ClassCastException。例如，Box<Integer> 只能存储 Integer 类型的对象，而不能存储其他类型（如 String）。
代码复用：泛型使得类和方法可以在不重复编写代码的情况下处理不同类型的数据。
灵活性：通过泛型，可以在实例化时指定具体的类型，使得类更加灵活和可扩展。

总结

这段代码展示了如何使用 Java 泛型来创建一个类型安全且灵活的容器类。通过泛型，Box 类可以存储任何类型的数据，同时避免了类型转换的问题，提供了更强的类型安全性。

泛型的基本用法 📦

1. 泛型类

泛型类允许我们创建一个可以处理任意类型的类。你不需要为每个不同的类型编写不同的类，泛型让你的代码变得更加通用。

示例：一个可以存储任何类型的容器 `Box<T>`

public class Box<T> {
    private T value;

    public T getValue() {
        return value;
    }

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

创建一个 Box 类，你可以用它来存储任何类型的对象，比如 String、Integer 或者自定义类型。

Box<String> stringBox = new Box<>();
stringBox.setValue("Hello, Java Generics!");
System.out.println(stringBox.getValue());  // 输出：Hello, Java Generics!

Box<Integer> intBox = new Box<>();
intBox.setValue(123);
System.out.println(intBox.getValue());  // 输出：123

通过这种方式，我们避免了使用原始类型集合时的类型安全问题（比如 Object 类型），让类型更加明确和安全。

代码解析：

这段代码展示了一个简单的 泛型类 Box 的定义。在这个类中，T 是一个类型参数，表示任意类型。通过使用泛型，我们可以在类实例化时指定具体的数据类型，而不必为了每种类型单独编写类。下面是对这段代码的详细解析：

public class Box<T> {
    private T value;  // 这是一个泛型字段，类型为 T，表示 Box 存储的值可以是任何类型

    // 获取存储的值
    public T getValue() {
        return value;
    }

    // 设置存储的值
    public void setValue(T value) {
        this.value = value;
    }
}

泛型类型 T

Box<T>：T 是一个类型参数，它代表任意类型。在创建 Box 类的实例时，我们可以指定 T 的具体类型，比如 Box<Integer>、Box<String> 等。
泛型提供了一种机制，让我们能够编写一次代码，处理不同类型的对象。

成员变量 value

private T value;：这是一个泛型字段，表示 Box 类中存储的值的类型是 T。因为 T 是泛型参数，它可以是任何类型（如 Integer、String、Double 等）。

方法 getValue 和 setValue

public T getValue()：返回当前 Box 中存储的值，返回值类型为 T，即 Box 存储的对象的类型。
public void setValue(T value)：这个方法接受一个类型为 T 的参数，并将其设置为 Box 中的值。这样你可以设置 Box 存储的具体类型的数据。

使用示例

创建 Box 存储整数类型

public class Main {
    public static void main(String[] args) {
        // 创建一个 Box 对象，用于存储 Integer 类型的数据
        Box<Integer> intBox = new Box<>();
        intBox.setValue(10);  // 设置值为 10
        System.out.println("Integer value: " + intBox.getValue());  // 输出: Integer value: 10
    }
}

创建 Box 存储字符串类型

public class Main {
    public static void main(String[] args) {
        // 创建一个 Box 对象，用于存储 String 类型的数据
        Box<String> stringBox = new Box<>();
        stringBox.setValue("Hello, Generics!");  // 设置值为字符串
        System.out.println("String value: " + stringBox.getValue());  // 输出: String value: Hello, Generics!
    }
}

泛型的优势

类型安全：使用泛型后，编译器会检查类型的一致性，避免了类型转换错误。例如，Box<Integer> 只能存储 Integer 类型的数据，不能存储 String 类型。
代码复用：通过泛型，我们可以创建一个类 Box，它能够存储任意类型的对象。我们无需为每个类型创建单独的类，可以减少代码冗余。
避免类型转换：如果没有泛型，我们可能需要将 Object 转换为目标类型（如 String 或 Integer），而泛型使得类型在编译时就被确定，避免了运行时的类型转换，减少了错误的发生。

总结

这段代码定义了一个简单的泛型类 Box，它可以存储任意类型的对象。通过泛型，你可以在类的实例化时指定存储的数据类型，确保了类型的安全性和灵活性。泛型的使用使得代码更加简洁、通用，避免了类型转换错误，并增强了类型安全。

2. 泛型方法

泛型方法是指方法本身使用泛型，允许我们在方法调用时指定类型参数。通过泛型方法，能让我们在方法内部处理不同类型的数据，而不需要重复编写多种方法版本。

示例：一个打印数组的泛型方法

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

这个方法使用了泛型 <T>，接受一个任意类型的数组并打印出它的元素。你可以用它来打印 Integer 数组、String 数组，甚至是自定义对象数组。

Integer[] intArray = {1, 2, 3, 4};
String[] strArray = {"Java", "Generics", "Fun"};

printArray(intArray);  // 输出：1 2 3 4
printArray(strArray);  // 输出：Java Generics Fun

通过泛型方法，我们实现了一个可以处理任何类型的通用方法，避免了为每种类型编写不同的打印方法。

3. 泛型接口

接口也可以使用泛型，使得实现该接口的类可以定义具体的类型参数。这是接口设计中非常有用的功能。

示例：一个泛型接口 `Comparable<T>`

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

在这个接口中，T 是一个占位符，表示实现该接口的类需要定义如何与另一个相同类型的对象进行比较。例如，我们可以创建一个 Person 类，实现 Comparable<Person> 接口。

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}

这种方式使得我们能够使用 compareTo 方法比较任意类型的对象，代码更加简洁高效。

代码解析：

在 Java 中，Comparable<T> 是一个泛型接口，用于定义对象的自然顺序。通过实现 compareTo(T o) 方法，类的实例可以与同类型的其他对象进行比较。这种接口通常用于排序和集合框架中，比如 Collections.sort() 和 TreeSet。

Comparable<T> 接口详解

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

在这个接口中，T 是一个占位符，表示实现该接口的类需要定义如何与另一个相同类型的对象进行比较。compareTo(T o) 方法返回一个整数，表示当前对象与另一个对象 o 的相对顺序：

如果返回负数，表示当前对象小于 o。
如果返回零，表示当前对象等于 o。
如果返回正数，表示当前对象大于 o。

示例：Person 类实现 Comparable<Person>

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 实现 compareTo 方法，按照年龄排序
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }

    // getter 和 setter 方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

在 Person 类中，我们实现了 Comparable<Person> 接口，并根据 Person 的年龄（age）来进行比较：

Integer.compare(this.age, other.age) 返回两个 int 值的比较结果，表示当前对象和另一个对象的年龄顺序。

使用 Comparable 进行排序

一旦 Person 类实现了 Comparable 接口，我们就可以使用 Java 的集合框架进行排序，例如使用 Collections.sort() 方法：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));

        // 按年龄排序
        Collections.sort(people);

        // 打印排序后的结果
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

输出：

Bob (25)
Alice (30)
Charlie (35)

Collections.sort(people) 会根据 Person 类中的 compareTo 方法对 List<Person> 中的元素按年龄进行排序。

总结

Comparable<T> 接口使得对象能够与其他同类型对象进行自然排序。
compareTo(T o) 方法应该定义类对象与另一个相同类型对象的比较规则。
Comparable 主要用于排序操作，例如在 Collections.sort()、TreeSet 或 PriorityQueue 中使用。

4. 通配符 `?`

在使用泛型时，通配符 ? 是一个非常有用的工具，它可以表示任意类型，使得我们在处理未知类型的集合时更加灵活。

示例1：`? extends T`

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

这里，? extends Number 表示 list 可以接受 Number 或其任何子类的类型，如 Integer、Double 等。这样，你就可以让这个方法处理多种不同类型的数字集合，而不需要关心具体的类型。

示例2：`? super T`

public static void addInteger(List<? super Integer> list) {
    list.add(100);  // 只允许添加 Integer 或它的父类类型的元素
}

? super Integer 允许 list 存储 Integer 类型或 Integer 的父类类型（如 Number）。这种方式让你能够安全地向集合中添加元素。

代码解析：

泛型通配符 ? extends T 和 ? super T 的使用

Java 泛型允许我们通过通配符 (?) 来表示类型的不确定性。? extends T 和 ? super T 是两种常见的通配符使用方式，分别用来定义上下限边界，控制类型的可接受范围。

? extends T：上限通配符

? extends T 表示接受 T 或 T 的子类型。这个通配符允许你传递 T 类型的任意子类（包括 T 本身）。它通常用于 读取数据 的场景，因为你无法向这样的集合中添加任何其他类型的元素，除了 null。

示例 1：? extends T

public static void printNumbers(List<? extends Number> list) {
    for (Number number : list) {
        System.out.println(number);  // 可以读取数据，Number 或其子类
    }
}

List<? extends Number> 表示可以接受任何 Number 的子类集合（如 Integer、Double、Float 等）。
该方法打印集合中的所有元素，由于 ? extends Number，编译器确保集合中的元素是 Number 或其子类，允许安全地访问每个元素。
限制：由于 ? extends T 只允许读取数据，你不能向 List<? extends Number> 中添加任何元素（除了 null）。这是因为编译器不能保证你想要添加的元素是列表类型的子类型。

? super T：下限通配符

? super T 表示接受 T 或 T 的父类。它允许你传入 T 或 T 的任何父类类型。这个通配符通常用于 写入数据 的场景，因为它确保可以向集合中添加 T 类型的元素，但它不允许读取具体的类型。

示例 2：? super T

public static void addInteger(List<? super Integer> list) {
    list.add(100);  // 只允许添加 Integer 或它的父类类型的元素
}

List<? super Integer> 表示接受 Integer 类型或 Integer 的父类类型（如 Number、Object）。
该方法向列表中添加 Integer 类型的元素，因为 Integer 是 Number 的子类，? super Integer 确保可以向该列表添加 Integer 或其子类的元素。
限制：你可以向 List<? super Integer> 添加 Integer 或其子类的元素，但是无法确定该列表中元素的确切类型。因此，在读取数据时，你只能以 Object 类型读取元素，因为编译器无法确定具体的类型。

总结

? extends T（上限通配符）：适用于只想读取 T 或其子类类型的数据，不能往集合中添加数据（除了 null）。适用于获取数据时需要确保类型的安全性。
? super T（下限通配符）：适用于只关心向集合中添加数据，而不关心集合中具体是什么类型的情况。你可以安全地添加 T 类型或其子类的元素，但读取时只能以 Object 类型访问数据。

使用场景

? extends T 适用于 读取数据，例如获取集合中的元素而不关心具体类型的情况。
? super T 适用于 写入数据，例如向集合中添加元素时，允许 T 或其父类类型的元素。

通过合理使用这两种通配符，你可以在保持类型安全的同时，灵活地处理不同类型的集合。

高级特性 🔧

1. 泛型的类型限制（Bounded Type Parameters）

通过限定泛型的类型，你可以更精确地控制它所能接受的类型范围。比如，我们可以限制泛型只能是 Number 类型或者它的子类。

public class Box<T extends Number> {
    private T value;

    public T getValue() {
        return value;
    }

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

在这个例子中，T 被限定为 Number 类型或它的子类（如 Integer、Double），使得 Box 类只能处理数值类型的数据。

代码解析：

在你提供的 Box 类示例中，泛型参数 T 被限制为 Number 或 Number 的子类。这是通过 T extends Number 来实现的，它表示 T 必须是 Number 类型或者是 Number 类型的某个子类型（例如 Integer、Double 等）。

解释：

public class Box<T extends Number> {
    private T value;

    public T getValue() {
        return value;
    }

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

T extends Number：这意味着 T 必须是 Number 类型或者是它的某个子类。这就确保了只有数字类型的对象才能被传递给 Box 类。
T value：定义了一个 value 字段，它的类型是 T，也就是一个数字类型（Integer、Double 等）。
getValue 和 setValue：这两个方法分别用于获取和设置 Box 中的值。因为 T 是泛型参数，所以这些方法可以处理任何符合 T extends Number 限制的类型。

使用示例：

你可以使用这个类来存储 Number 类型及其子类型的实例，例如 Integer、Double、Float 等。

public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();  // 使用 Integer 类型
        intBox.setValue(10);
        System.out.println("Value in intBox: " + intBox.getValue());

        Box<Double> doubleBox = new Box<>();  // 使用 Double 类型
        doubleBox.setValue(3.14);
        System.out.println("Value in doubleBox: " + doubleBox.getValue());
    }
}

输出：

Value in intBox: 10
Value in doubleBox: 3.14

为什么使用 T extends Number？

通过 T extends Number 限制，你可以确保 Box 类只会接受数字类型（包括整数、浮点数等）。这在需要处理数学计算时非常有用，因为你可以直接对 T 类型的值进行数学运算（如加减乘除）而不需要额外的类型检查。

总结

T extends Number：表示泛型 T 必须是 Number 或 Number 的子类，限制了类型的范围，使得 Box 类只能存储数字类型的值。
这样设计使得 Box 类更加灵活且类型安全，能够处理不同类型的数字值。

2. 擦除机制（Type Erasure）

在 Java 中，泛型在编译后会被擦除为原始类型。也就是说，泛型类型信息不会在运行时存在。比如 List<String> 在编译后就变成了 List，类型信息被擦除。这是为了确保泛型不会对性能造成影响。

总结 🎯

通过今天的学习，你已经掌握了 Java 泛型的基础和一些高级特性。从简单的泛型类到通配符的应用，再到如何利用泛型提高代码的灵活性和类型安全，泛型在 Java 中扮演了至关重要的角色。它不仅能减少类型转换的麻烦，还能提高代码的可读性和可维护性，避免许多潜在的错误。只要你理解了泛型的精髓，它就能成为你编程时的一把利剑！⚔️

如果你对泛型有任何疑问，或者想讨论更多的使用场景，随时欢迎交流！

🧧福利赠与你🧧

无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学SpringBoot」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门SpringBoot，就像滚雪球一样，越滚越大，无边无际，指数级提升。

最后，如果这篇文章对你有所帮助，帮忙给作者来个一键三连，关注、点赞、收藏，您的支持就是我坚持写作最大的动力。

同时欢迎大家关注公众号:「猿圈奇妙屋」，以便学习更多同类型的技术文章，免费白嫖最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板、技术文章Markdown文档等海量资料。

✨️ Who am I?

我是bug菌，CSDN | 掘金 | InfoQ | 51CTO | 华为云 | 阿里云 | 腾讯云等社区博客专家，C站博客之星Top30，华为云2023年度十佳博主，掘金多年度人气作者Top40，掘金等各大社区平台签约作者，51CTO年度博主Top12，掘金/InfoQ/51CTO等社区优质创作者；全网粉丝合计 30w+；更多精彩福利点击这里；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试真题、4000G PDF电子书籍、简历模板等海量资料，你想要的我都有，关键是你不来拿。

-End-

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

🔥 深入浅出 Java 泛型：让你的代码更灵活、安全又高效！💻

前言 🌟

什么是泛型？🧐

泛型的基本用法 📦

1. 泛型类

示例：一个可以存储任何类型的容器 `Box<T>`

2. 泛型方法

示例：一个打印数组的泛型方法

3. 泛型接口

示例：一个泛型接口 `Comparable<T>`

4. 通配符 `?`

示例1：`? extends T`

示例2：`? super T`

高级特性 🔧

1. 泛型的类型限制（Bounded Type Parameters）

2. 擦除机制（Type Erasure）

总结 🎯

🧧福利赠与你🧧

✨️ Who am I?

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

🔥 深入浅出 Java 泛型：让你的代码更灵活、安全又高效！💻

前言 🌟

什么是泛型？🧐

泛型的基本用法 📦

1. 泛型类

示例：一个可以存储任何类型的容器 Box<T>

2. 泛型方法

示例：一个打印数组的泛型方法

3. 泛型接口

示例：一个泛型接口 Comparable<T>

4. 通配符 ?

示例1：? extends T

示例2：? super T

高级特性 🔧

1. 泛型的类型限制（Bounded Type Parameters）

2. 擦除机制（Type Erasure）

总结 🎯

🧧福利赠与你🧧

✨️ Who am I?

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品

示例：一个可以存储任何类型的容器 `Box<T>`

示例：一个泛型接口 `Comparable<T>`

4. 通配符 `?`

示例1：`? extends T`

示例2：`? super T`