当前位置： 首页 > news >正文

Java 泛型使用教程

news 来源：原创 2025/4/22 6:13:00

简介

Java 泛型是 JDK 5 引入的一项特性，它提供了编译时类型安全检测机制，允许在编译时检测出非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型的好处：

  • 编译期检查类型安全

  • 避免强制类型转换（cast）

  • 代码更通用，更易重用

泛型的基本使用

泛型类
public class Box<T> {private T content;public void set(T content) {this.content = content;}public T get() {return content;}
}

使用：

Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String value = stringBox.get(); // 无需强转
泛型方法
public class Util {public static <T> void printArray(T[] array) {for (T element : array) {System.out.println(element);}}
}

使用：

String[] arr = {"A", "B", "C"};
Util.printArray(arr);
泛型接口
public interface Converter<F, T> {T convert(F from);
}public class StringToIntegerConverter implements Converter<String, Integer> {public Integer convert(String from) {return Integer.parseInt(from);}
}

泛型中的通配符：?

? 通配符

表示任意类型：

public void printList(List<?> list) {for (Object item : list) {System.out.println(item);}
}
? extends T（上界通配符）

表示 T 或 T 的子类（只读，不能写）：

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

不能添加元素：

list.add(10); // ❌ 报错
? super T（下界通配符）

表示 T 或 T 的父类（可以写入，但取出只能当作 Object）：

public void addNumbers(List<? super Integer> list) {list.add(10); // ✅ OK
}

类型擦除（Type Erasure）

泛型在编译后会被擦除，JVM 不知道泛型类型，全部变成 Object：

List<String> list = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list.getClass() == list2.getClass()); // true

正因如此：

  • 不能使用 new T()

  • 不能使用 T.class

  • 不能判断 instanceof T

常见的泛型类库例子

  • List<T>：存储 T 类型的集合

  • Map<K, V>：泛型键值对

  • Optional<T>：包装返回值

  • Comparable<T>：排序比较接口

  • Function<T, R>：函数式接口

  • Callable<T>：异步任务的返回类型

  • Future<T>：异步计算的结果

进阶技巧

泛型数组不允许：
List<String>[] lists = new List<String>[10]; // ❌ 编译错误
泛型静态方法必须声明 <T>：
public static <T> void print(T value) {System.out.println(value);
}

实际项目中 Java 泛型的用法大全

通用返回封装类（统一 API 响应格式）
public class Result<T> {private int code;private String message;private T data;public Result(int code, String message, T data) {this.code = code;this.message = message;this.data = data;}public static <T> Result<T> success(T data) {return new Result<>(200, "Success", data);}public static <T> Result<T> fail(String message) {return new Result<>(500, message, null);}// getter/setter omitted
}
通用分页结果类
public class PageResult<T> {private List<T> records;private long total;public PageResult(List<T> records, long total) {this.records = records;this.total = total;}
}

结合 Spring 使用泛型的示例

通用 Service 接口
public interface BaseService<T, ID> {T findById(ID id);List<T> findAll();T save(T entity);void deleteById(ID id);
}
抽象 Service 实现类
public abstract class AbstractBaseService<T, ID> implements BaseService<T, ID> {@Autowiredprotected JpaRepository<T, ID> repository;@Overridepublic T findById(ID id) {return repository.findById(id).orElse(null);}@Overridepublic List<T> findAll() {return repository.findAll();}@Overridepublic T save(T entity) {return repository.save(entity);}@Overridepublic void deleteById(ID id) {repository.deleteById(id);}
}
具体 Service
@Service
public class UserService extends AbstractBaseService<User, Long> {// 可以扩展额外业务逻辑
}

Java 泛型 与 C#.net 泛型比较

Java 泛型 与 C# (.NET) 泛型有很多相似之处，C# 泛型的设计部分参考了 Java。但它们在类型擦除、协变/逆变、约束、运行时行为等方面有显著的不同。

特性Java 泛型C# (.NET) 泛型
类型擦除是（编译期擦除）否（保留类型信息）
运行时可反射获取泛型类型否是
基本类型支持不直接支持（需使用包装类如 Integer）支持，例如 List<int>
泛型约束限制（只能 extends，不支持多个约束）强大（支持 where T : class, new(), 多个接口）
协变/逆变支持通过通配符 ? extends/super直接使用 out/in 关键字
泛型数组不支持（如 new T[] 编译错误）支持
泛型方法支持支持
类型擦除 vs 保留类型
  • Java
List<String> list = new ArrayList<>();
List<Integer> intList = new ArrayList<>();
System.out.println(list.getClass() == intList.getClass()); // true

Java 在编译时擦除了泛型信息，List<String> 和 List<Integer> 其实是同一个字节码类。

  • C#
List<string> list = new List<string>();
List<int> intList = new List<int>();
Console.WriteLine(list.GetType() == intList.GetType()); // false

C# 会为不同泛型参数生成不同的类实例，因此保留类型信息。

泛型约束
  • Java
public class Repository<T extends BaseEntity> {public void save(T entity) { }
}
  • C#
public class Repository<T> where T : BaseEntity, new() {public void Save(T entity) { }
}

C# 支持更丰富的泛型约束，例如要求是引用类型 class、值类型 struct、必须有无参构造函数 new() 等。

协变与逆变（Covariance & Contravariance）
  • Java 使用通配符
List<? extends Number> numbers;  // 只能读取，不能添加
List<? super Integer> integers;  // 只能添加 Integer
  • C# 使用 in / out
interface ICovariant<out T> { }
interface IContravariant<in T> { }

C# 在接口中用 in/out 明确支持协变逆变，且更强大、更类型安全。

泛型数组
  • Java
T[] array = new T[10]; // 编译错误
  • C#
T[] array = new T[10]; // 合法
基本类型泛型
  • Java
List<int> list = new ArrayList<>(); // 编译错误
List<Integer> list = new ArrayList<>(); // 正确
  • C#
List<int> list = new List<int>(); // 正确，泛型支持值类型
总结
特性JavaC#
类型安全✔️✔️
灵活性❌（类型擦除限制）✔️（运行时保留泛型）
泛型数组❌✔️
基本类型支持❌（需包装）✔️
泛型约束一般强大
协变逆变复杂、通配符语法简洁、原生支持
性能需装箱无装箱（对值类型更快）

协变逆变详解

协变（Covariance）和逆变（Contravariance）是泛型类型系统中用于处理子类和父类之间的泛型关系的重要机制。

Java 的协变（Covariant）与逆变（Contravariant）

Java 使用 通配符（wildcards） 来支持：

协变（? extends T） — 只读

  • 意思是：某个未知类型是 T 的子类

  • 常用于“只能读”的场景

public void readAnimals(List<? extends Animal> animals) {for (Animal animal : animals) {System.out.println(animal);}
}

可以传入 List<Cat>、List<Dog> 或 List<Animal>，但不能添加新元素。

animals.add(new Cat()); // ❌ 编译错误

逆变（? super T） — 只写

  • 意思是：某个未知类型是 T 的父类

  • 常用于“只能写”的场景

public void addCats(List<? super Cat> cats) {cats.add(new Cat());     // ✅ 合法// cats.add(new Animal()); // ❌ 不安全
}

可以传入 List<Cat>、List<Animal>、List<Object>，但不能安全地读取具体类型：

Object obj = cats.get(0); // 只能作为 Object 使用
C# 中的协变与逆变
  • C# 协变（out）
interface IReadOnlyList<out T> {T Get(int index);
}IReadOnlyList<Animal> animals = new List<Cat>(); // ✅ 协变成功
  • C# 逆变（in）
interface IWriter<in T> {void Write(T value);
}IWriter<Cat> writer = new AnimalWriter(); // ✅ 逆变成功
完整示例：协变 & 逆变
import java.util.*;class Animal { }
class Cat extends Animal { }
class Dog extends Animal { }public class VarianceDemo {public static void main(String[] args) {List<Cat> cats = new ArrayList<>();cats.add(new Cat());readAnimals(cats); // ✅ 协变addCats(cats);     // ✅ 逆变}// 协变：读取public static void readAnimals(List<? extends Animal> animals) {for (Animal a : animals) {System.out.println("Animal: " + a);}// animals.add(new Dog()); // ❌ 编译错误}// 逆变：写入public static void addCats(List<? super Cat> animals) {animals.add(new Cat()); // ✅}
}
总结
特性协变逆变
Java 关键字? extends T? super T
C# 关键字out Tin T
适合场景读取数据写入数据
是否可写❌✅
是否可读✅❌（只能当 Object）

相关文章：

  • Netty前置基础知识之BIO、NIO以及AIO理论详细解析和实战案例
  • 使用PyTorch实现图像增广与模型训练实战
  • RESTful学习笔记（二）---简单网页前后端springboot项目搭建
  • uni-app 状态管理深度解析：Vuex 与全局方案实战指南
  • 【C++软件实战问题排查经验分享】UI界面卡顿 | CPU占用高 | GDI对象泄漏 | 线程堵塞 系列问题排查总结
  • 如何维护技术文档的持续更新？
  • 【Unity笔记】Unity音视频播放监听器封装笔记：VideoPlayer + AudioSource事件触发与编辑器扩展
  • 微软Entra新安全功能引发大规模账户锁定事件
  • GeoAI技术内涵与城市计算
  • 目标检测：视觉系统中的CNN-Transformer融合网络
  • 从代码学习深度学习 - 学习率调度器 PyTorch 版
  • Vue-组件的懒加载，按需加载
  • PyCharm 初级教程：从安装到第一个 Python 项目
  • git远程分支重命名（纯代码操作）
  • 大模型基础
  • 学习深度学习是否要先学习机器学习？工程师的路径选择策略
  • 重构・协同・共生：传统代理渠道数字化融合全链路解决方案
  • 基于Java的不固定长度字符集在指定宽度和自适应模型下图片绘制生成实战
  • 一段式端到端自动驾驶：VAD：Vectorized Scene Representation for Efficient Autonomous Driving
  • Spring Boot 核心模块全解析：12 个模块详解及作用说明
  • 高架上2名儿童从轿车天窗探出身来，驾驶员被记3分罚200元
  • “6+2”小复式追加票！松江购彩者擒大乐透1672万头奖
  • 上海群文创作大检阅，102个节目角逐群星奖
  • 杨国荣丨阐释学的内涵与意义——张江《阐释学五辨》序
  • “80后”辽宁石油化工大学副校长杨占旭已任阜新市领导
  • 谁在地铁里阅读？——对话上海地铁上的读书人