编辑“︁泛型机制”︁

= 泛型机制 =

'''泛型'''（Generics）是Java编程语言中一项强大的特性，它允许开发者在编译时检测类型错误，提高代码的安全性和可重用性。泛型通过参数化类型（type parameters）来实现，使得类、接口和方法可以操作多种数据类型而不必牺牲类型安全性。

== 介绍 ==

泛型的主要目的是在编译时提供更强的类型检查，并消除类型转换的需要。在Java 5之前，集合类（如ArrayList）只能存储Object类型，这意味着每次从集合中取出元素时都需要进行强制类型转换，容易引发运行时错误。泛型的引入解决了这一问题。

泛型的核心概念包括：
* '''类型参数'''：在类、接口或方法声明中使用的占位符，例如`<T>`。
* '''类型擦除'''：Java泛型在运行时会被擦除，转换为原始类型（raw types）。
* '''通配符'''：`?`用于表示未知类型，通常与`extends`和`super`结合使用。

== 基本语法 ==

=== 泛型类 ===
泛型类在类名后使用尖括号声明类型参数。例如：

<syntaxhighlight lang="java">
public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}
</syntaxhighlight>

使用示例：
<syntaxhighlight lang="java">
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello, Generics!");
String value = stringBox.getContent(); // 无需强制类型转换
System.out.println(value); // 输出: Hello, Generics!
</syntaxhighlight>

=== 泛型方法 ===
泛型方法在返回类型前声明类型参数：
<syntaxhighlight lang="java">
public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}
</syntaxhighlight>

使用示例：
<syntaxhighlight lang="java">
Integer[] intArray = {1, 2, 3};
printArray(intArray); // 输出: 1 2 3
</syntaxhighlight>

== 类型擦除 ==

Java的泛型是通过类型擦除实现的，这意味着泛型类型信息在运行时不可用。例如，`Box<String>`和`Box<Integer>`在运行时都会被擦除为`Box`。

=== 擦除后的代码示例 ===
编译前：
<syntaxhighlight lang="java">
Box<String> box = new Box<>();
box.setContent("Test");
String content = box.getContent();
</syntaxhighlight>

编译后（等效代码）：
<syntaxhighlight lang="java">
Box box = new Box();
box.setContent("Test");
String content = (String) box.getContent();
</syntaxhighlight>

== 通配符 ==

通配符`?`用于表示未知类型，通常用于方法参数或变量声明。

=== 上限通配符（extends） ===
限制类型为某个类的子类：
<syntaxhighlight lang="java">
public void process(List<? extends Number> numbers) {
    for (Number num : numbers) {
        System.out.println(num);
    }
}
</syntaxhighlight>

=== 下限通配符（super） ===
限制类型为某个类的父类：
<syntaxhighlight lang="java">
public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}
</syntaxhighlight>

== 实际应用案例 ==

=== 集合框架中的泛型 ===
Java集合框架广泛使用泛型来保证类型安全：
<syntaxhighlight lang="java">
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
// names.add(123); // 编译错误，类型不匹配
</syntaxhighlight>

=== 自定义比较器 ===
泛型可用于创建可重用的比较逻辑：
<syntaxhighlight lang="java">
public class Comparator<T extends Comparable<T>> {
    public T max(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }
}
</syntaxhighlight>

== 高级主题 ==

=== 类型边界 ===
可以使用`extends`限制类型参数的范围：
<syntaxhighlight lang="java">
public class Calculator<T extends Number> {
    public double add(T a, T b) {
        return a.doubleValue() + b.doubleValue();
    }
}
</syntaxhighlight>

=== 泛型与继承 ===
泛型类可以继承或实现其他泛型类/接口：
<syntaxhighlight lang="java">
public interface Repository<T> {
    void save(T entity);
}

public class UserRepository implements Repository<User> {
    @Override
    public void save(User user) {
        // 实现保存逻辑
    }
}
</syntaxhighlight>

== 常见问题 ==

=== 为什么不能创建泛型数组？ ===
由于类型擦除，Java不允许创建泛型数组。例如：
<syntaxhighlight lang="java">
// 以下代码会导致编译错误
List<String>[] arrayOfLists = new List<String>[10];
</syntaxhighlight>

=== 泛型与原始类型的区别 ===
原始类型（raw types）是不带类型参数的泛型类，为了向后兼容而保留，但不推荐使用：
<syntaxhighlight lang="java">
List rawList = new ArrayList(); // 原始类型
rawList.add("String");
rawList.add(1); // 编译通过，但可能引发运行时错误
</syntaxhighlight>

== 总结 ==

泛型是Java中提高代码安全性和可重用性的重要特性。通过类型参数化，开发者可以：
* 在编译时捕获类型错误
* 消除强制类型转换
* 编写更通用的代码

虽然类型擦除带来了一些限制，但合理使用泛型能显著提高代码质量。对于初学者，建议从简单的泛型类和泛型方法开始练习，逐步掌握更高级的用法如通配符和类型边界。

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:Java基础]]