Java 中的泛型（Generics）零基础入门到精通，收藏这篇就够了

程序员_大白

墨衍会员 · AI 创作全网分发码龄5年

关注

原创最新推荐文章于 2026-08-04 09:53:56 发布 346 阅读 AI 写同款· GEO 优化 ›

Java语言的泛型（Generics）泛型类是一种带有类型参数的类，可以在实例化时指定具体的类型。以下是一个简单的泛型类的示例：```java。阅读详情

文章目录

- Java 中的泛型（Generics）
- - 1. 泛型的概念
- 2. 泛型的优势
- 3. Java 泛型的使用
- - (1) 泛型类
  - - 示例
  - (2) 泛型方法
  - - 示例
  - (3) 泛型接口
  - - 示例
  - (4) 泛型的通配符
  - - (a) `?`（无界通配符）
    - (b) `? extends T`（上界通配符）
    - © `? super T`（下界通配符）
  - (5) 泛型与类型擦除
  - - 示例
- 4. 泛型的限制
- 5. 总结

Java 中的泛型（Generics）

1. 泛型的概念

泛型（Generics）是 Java 5 引入的一种特性，允许编写类型安全、可复用的代码。泛型主要用于类、接口和方法，能够在编译时进行类型检查，而不需要在运行时进行强制类型转换。

2. 泛型的优势

类型安全（Type Safety）：避免 ClassCastException，在编译阶段进行类型检查。
代码复用（Code Reusability）：相同的代码可以适用于多种数据类型，减少代码冗余。
可读性和可维护性：减少了不必要的类型转换。

3. Java 泛型的使用

(1) 泛型类

泛型类是在类定义时指定一个或多个类型参数，以支持不同类型的数据。

示例

// 定义一个泛型类
class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }
}

// 使用泛型类
public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setValue(10);
        System.out.println(intBox.getValue());  // 输出：10

        Box<String> strBox = new Box<>();
        strBox.setValue("Hello");
        System.out.println(strBox.getValue());  // 输出：Hello
    }
}

解释：

T 是类型参数，实例化 Box<Integer> 时，T 变为 Integer，实例化 Box<String> 时，T 变为 String。
setValue(T value) 只能接收 T 类型的数据，确保了类型安全。

(2) 泛型方法

泛型方法可以在方法级别使用泛型，而不需要整个类都是泛型的。

示例

class Util {
    // 泛型方法，`<T>` 指定泛型类型
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"A", "B", "C"};

        Util.printArray(intArray);  // 输出：1 2 3 4 5
        Util.printArray(strArray);  // 输出：A B C
    }
}

解释：

public static <T> void printArray(T[] array)：<T> 说明该方法是泛型方法，可以接受不同类型的数组。

(3) 泛型接口

泛型接口允许接口的方法使用泛型，在实现时可以指定具体的类型。

示例

// 定义泛型接口
interface Generator<T> {
    T next();
}

// 实现泛型接口
class IntegerGenerator implements Generator<Integer> {
    private int value = 0;

    @Override
    public Integer next() {
        return value++;
    }
}

public class Main {
    public static void main(String[] args) {
        Generator<Integer> gen = new IntegerGenerator();
        System.out.println(gen.next());  // 输出：0
        System.out.println(gen.next());  // 输出：1
    }
}

解释：

Generator<T> 是一个泛型接口，IntegerGenerator 具体实现时指定 T 为 Integer。
next() 方法返回 Integer，符合泛型约束。

(4) 泛型的通配符

Java 提供 ? 作为泛型通配符，用于不确定具体类型的情况下，比如在方法参数中。

(a) `?`（无界通配符）

public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

List<?> 代表任意类型的 List，但是方法内部只能当作 Object 处理。

(b) `? extends T`（上界通配符）

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

List<? extends Number> 允许 List<Integer>、List<Double> 等作为参数，但不能添加新元素。

© `? super T`（下界通配符）

public static void addNumber(List<? super Integer> list) {
    list.add(10); // 允许添加 Integer 或其父类
}

List<? super Integer> 允许 List<Integer>、List<Number> 或 List<Object> 作为参数。

(5) 泛型与类型擦除

Java 泛型是编译时特性，JVM 并不存储具体的泛型类型，所有泛型类型信息在编译后都会被类型擦除（Type Erasure）。

示例

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

System.out.println(list1.getClass() == list2.getClass());  // 输出：true

解释：

在运行时，List<String> 和 List<Integer> 的类型信息都会被擦除，实际的 List<T> 变成 List<Object>，所以 list1 和 list2 具有相同的 Class。

4. 泛型的限制

Java 泛型有一些限制：

不能使用基本数据类型（必须使用包装类，如 List<int> 是非法的，应该用 List<Integer>）。
不能创建泛型数组（T[] array = new T[10] 会报错）。
不能在静态方法或静态变量中使用泛型类型参数（因为泛型类型参数是实例级的）。
不能直接实例化泛型类型（T obj = new T(); 是非法的，应该使用 Class<T> 来实例化）。

5. 总结

特性	说明
泛型类	`class Box<T> { T value; }`
泛型方法	`<T> void print(T item) {}`
泛型接口	`interface Generator<T> { T next(); }`
通配符	`?`（无界）、`? extends T`（上界）、`? super T`（下界）
类型擦除	编译后泛型信息会被擦除，变为 `Object`
限制	不能使用基本类型、不能创建泛型数组、不能实例化泛型

Java开发的就业市场正在经历结构性调整，竞争日益激烈

传统纯业务开发岗位（如仅完成增删改查业务的后端工程师）的需求，特别是入门级岗位，正显著萎缩。随着企业技术需求升级，市场对Java人才的要求已从通用技能转向了更深入的领域经验（如云原生、微服务）或前沿的AI集成能力。这也导致岗位竞争加剧，在一、二线城市，求职者不仅面临技术内卷，还需应对学历与项目经验的高门槛。

大模型为核心的AI领域正展现出前所未有的就业热度与人才红利

2025年，AI相关新发岗位数量同比激增543%，单月增幅最高超过11倍，大模型算法工程师位居热门岗位前列。行业顶尖人才的供需严重失衡，议价能力极强，跳槽薪资涨幅可达30%-50%。值得注意的是，市场并非单纯青睐算法研究员，而是急需能将大模型能力落地于复杂业务系统的工程人才。这使得具备企业级架构思维和复杂系统整合经验的Java工程师，在向“Java+大模型”复合人才转型时拥有独特优势，成为企业竞相争夺的对象，其薪资天花板也远高于传统Java岗位。

在这里插入图片描述