泛型在历史版本变化

泛型（Generics）是编程语言中用于参数化类型的特性，允许代码在定义时使用“类型占位符”，在使用时再指定具体类型，从而提升代码的复用性、类型安全性和可读性。不同编程语言对泛型的支持差异较大，且同一语言的泛型特性也随版本迭代不断演进。以下按语言梳理泛型的历史变化：

一、Java 泛型：从“擦除”到“增强”

Java 泛型是后天补丁型设计，因早期版本未考虑类型参数化，后期通过类型擦除（Type Erasure） 兼容旧代码，但也带来局限性。

1. Java 1.4 及之前：无泛型（“原始类型”时代）

集合框架（如 List、Map）使用原始类型，元素默认是 Object，需要手动强制转型，易引发 ClassCastException：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 需手动转型，风险高

2. Java 5（2004年）：泛型正式引入

核心特性：

• 参数化类型：定义类/接口/方法时声明类型参数（如 <T>），使用时指定具体类型（如 List<String>）。
• 类型擦除：编译时将泛型类型替换为上界类型（无上界则为 Object），运行时无泛型信息（避免修改 JVM 指令集）。
• 通配符：?（无界通配符）、? extends T（上界通配符，协变）、? super T（下界通配符，逆变），解决泛型不可变性问题。

示例：

List<String> list = new ArrayList<>(); // 菱形语法（Java 7 优化为<>自动推断）
list.add("hello");
String s = list.get(0); // 无需转型，编译期检查

局限性：

• 不能创建泛型数组（如 new T[] 非法）；
• 不能实例化泛型类型（如 new T() 非法）；
• 基本类型不能作为类型参数（需使用包装类，如 List<Integer> 而非 List<int>）。

3. Java 7（2011年）：菱形语法（<>）

简化泛型实例化时的类型重复书写：

// Java 5/6 需写两次类型：List<String> list = new ArrayList<String>();
List<String> list = new ArrayList<>(); // Java 7+ 菱形语法自动推断

4. Java 8（2014年）：泛型与 Lambda 结合

Lambda 表达式依赖泛型的函数式接口（如 Predicate<T>、Function<T,R>），泛型推断能力增强：

List<String> list = Arrays.asList("a", "b");
list.forEach(s -> System.out.println(s)); // 编译器推断 s 为 String

5. Java 9~17：小优化与密封类

• Java 9：匿名内部类的菱形语法支持（如 new Supplier<>() { ... } 可推断类型）；
• Java 10：局部变量类型推断（var），结合泛型更简洁：var list = new ArrayList<String>();；
• Java 17：密封类（sealed）与泛型结合，限制类型参数的子类范围。

二、C# 泛型：原生支持，无擦除

C# 泛型是原生设计（.NET 2.0 引入），CLR 直接支持泛型类型，运行时保留类型信息，性能优于 Java 擦除式泛型。

1. .NET 1.0/1.1（2002年）：无泛型

类似早期 Java，集合用 ArrayList（元素为 object），存在装箱/拆箱性能问题：

ArrayList list = new ArrayList();
list.Add(1); // 值类型1装箱为object
int i = (int)list[0]; // 拆箱，性能损耗

2. .NET 2.0（2005年）：泛型正式引入

核心特性：

• 运行时保留泛型信息：List<int> 和 List<string> 是不同的运行时类型；
• 避免装箱/拆箱：值类型（如 int）作为类型参数时，直接生成专用类型，无性能损耗；
• 约束（Constraints）：通过 where 子句限制类型参数（如 where T : class 表示 T 必须是引用类型，where T : new() 表示 T 必须有无参构造函数）。

示例：

List<int> list = new List<int>();
list.Add(1); // 无需装箱
int i = list[0]; // 无需拆箱

3. .NET 3.0+：泛型与 LINQ 结合

LINQ（语言集成查询）大量使用泛型，如 IEnumerable<T>、IQueryable<T>，支持强类型查询：

var numbers = new List<int> { 1, 2, 3 };
var evens = numbers.Where(n => n % 2 == 0); // 推断 n 为 int

4. .NET 5+（2020年后）：泛型协变/逆变增强

• 接口/委托的泛型参数支持 out（协变，如 IEnumerable<out T>）和 in（逆变，如 IComparer<in T>）；
• 记录类型（record）支持泛型：record Pair<T1, T2>(T1 First, T2 Second);。

三、C++ 模板：从“宏替换”到“概念”

C++ 模板是编译期泛型，通过“代码生成”实现（类似宏展开但更严格），是最早的泛型机制之一。

1. C++98（1998年）：模板正式标准化

核心特性：

• 函数模板：template <typename T> T max(T a, T b) { return a > b ? a : b; }；
• 类模板：template <typename T> class Vector { ... };；
• 特化：针对特定类型定制模板实现（全特化/偏特化）。

局限性：

• 错误信息晦涩（“模板编译错误墙”）；
• 无类型约束，模板参数只要“语法匹配”即可（如传入不支持 > 的类型给 max 会编译报错，但提示不友好）。

2. C++11（2011年）：模板增强

• 可变参数模板：支持任意数量的类型参数（如 template <typename... Args> void func(Args... args)），用于实现 tuple、printf 等；
• 类型别名模板：template <typename T> using Vec = vector<T>;（替代 typedef 的局限性）；
• 右值引用与模板结合：实现完美转发（std::forward）。

3. C++17（2017年）：类模板参数推断（CTAD）

编译器可自动推断类模板的类型参数，无需显式指定：

vector v = {1, 2, 3}; // 推断 v 为 vector<int>（C++17 前需写 vector<int> v{...}）
pair p(1, "a"); // 推断 p 为 pair<int, const char*>

4. C++20（2020年）：概念（Concepts）

引入概念约束模板参数，解决模板参数无约束的问题，提升错误提示可读性：

#include <concepts>
// 约束 T 必须是“可比较大小”的类型（支持 > 运算符）
template <std::totally_ordered T>
T max(T a, T b) { return a > b ? a : b; }

若传入不支持 > 的类型（如自定义类未重载 >），编译器会直接提示“不满足 totally_ordered 概念”。

四、TypeScript 泛型：JS 的超集，编译期检查

TypeScript 是 JavaScript 的超集，泛型仅在编译期存在，运行时会被擦除（类似 Java），用于约束变量、函数、类的类型。

1. TypeScript 1.0（2012年）：泛型初步支持

支持函数、接口、类的泛型：

function identity<T>(arg: T): T { return arg; }
interface Pair<T, U> { first: T; second: U; }
class Stack<T> { private items: T[] = []; push(item: T) {} }

2. TypeScript 2.0+：泛型约束与条件类型

• 泛型约束：function log<T extends { name: string }>(obj: T) { console.log(obj.name); }（限制 T 必须有 name 属性）；
• 条件类型：type IsString<T> = T extends string ? true : false;（根据类型参数推导新类型）；
• 映射类型：type Readonly<T> = { readonly [P in keyof T]: T[P]; }（基于泛型修改类型结构）。

3. TypeScript 4.0+：泛型推断增强

• 可变元组类型：type Concat<T extends any[], U extends any[]> = [...T, ...U];（元组泛型拼接）；
• 泛型默认类型：interface Box<T = string> { value: T; }（未指定 T 时默认为 string）。

五、其他语言的泛型

• Go 1.18（2022年）：首次引入泛型（类型参数），支持函数/类型的类型参数，避免用 interface{} 做强制转型：

  func Max[T comparable](a, b T) T { if a > b { return a }; return b } // 约束 T 支持 > 运算符
  

• Rust：泛型是编译期单态化（类似 C++ 模板），通过 trait 约束类型参数（如 fn print<T: Display>(item: T) 要求 T 实现 Display trait），运行时无性能损耗。

总结：各语言泛型核心差异

泛型的演进核心方向是：更严格的类型约束、更简洁的语法、更友好的错误提示、更优的性能。