泛型入门

什么是泛型？

泛型（Generic）是Java 5引入的一个重要特性，它的本质是参数化类型。简单来说，泛型就是给类型写参数，就像方法接收参数一样。泛型让你编写更通用、更安全的代码。

没有泛型的问题

在Java 5之前，集合（如ArrayList）只能存储Object类型。这意味着你可以把任何对象放进去，但取出来时需要强制类型转换，这会带来两个严重问题：

// 没有泛型的时代
List list = new ArrayList();
list.add("Hello");
list.add(123);  // 编译器不会报错

// 取出来时问题来了
String s = (String) list.get(1);  // 运行时ClassCastException!
System.out.println(s.length());   // 这行根本不会执行到

使用泛型的优势

泛型基本语法

1. 泛型类

// 定义泛型类 - T是类型参数
class Box {
    private T value;

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

    public T get() {
        return value;
    }
}

// 使用时指定具体类型
Box stringBox = new Box<>();
stringBox.set("Hello");
String s = stringBox.get();  // 不需要强制转换!

Box intBox = new Box<>();
intBox.set(123);
Integer num = intBox.get();  // 类型安全!

2. 泛型接口

// 定义泛型接口
interface Container {
    void add(E element);
    E get(int index);
    int size();
}

// 实现泛型接口
class StringContainer implements Container {
    private String[] array = new String[10];
    private int size = 0;

    @Override
    public void add(String element) {
        array[size++] = element;
    }

    @Override
    public String get(int index) {
        return array[index];
    }

    @Override
    public int size() {
        return size;
    }
}

3. 泛型方法

// 泛型方法 - 类型参数在返回值前面
public static  T getFirst(T[] array) {
    if (array == null || array.length == 0) {
        return null;
    }
    return array[0];
}

// 使用
String[] names = {"Alice", "Bob"};
Integer[] nums = {1, 2, 3};

String first = getFirst(names);   // 返回 String
Integer firstNum = getFirst(nums); // 返回 Integer

类型参数的命名约定

Java泛型有几种常见的类型参数命名，虽然你可以用任何标识符，但遵循约定让你的代码更易读：

多类型参数

泛型可以定义多个类型参数，就像Map有K（键）和V（值）：

class Pair {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}

// 使用
Pair entry = new Pair<>("年龄", 25);
System.out.println(entry.getKey() + ": " + entry.getValue());

泛型在哪里使用？

Java标准库中有大量使用泛型的例子，你每天都在使用：

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
Set<Integer> set = new HashSet<>();

List<String> names = people.stream()
    .map(Person::getName)
    .collect(Collectors.toList());

Optional<String> optional = Optional.of("value");
String value = optional.orElse("default");

泛型的局限

// 这个操作在编译时会报错
List stringList = new ArrayList<>();
List intList = new ArrayList<>();

// 虽然stringList和intList内容不同，但它们运行时类型都是ArrayList
System.out.println(stringList.getClass() == intList.getClass());  // true!

小结