Java 泛型的学习笔记

什么是泛型？

泛型是在JDK5引入的新特性，使用"<数据类型>"符号表示泛型。使用泛型的接口、类、方法，会在编译阶段，要求编译器检查数据类型是否匹配，从而达到限制数据类型的目的。比如：

public class Demo0 {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>(); // 使用泛型<String>，集合在编译阶段就被限定为只能存放String类型的元素。编译器会检查所有相关操作，确保类型匹配。
        list.add("hello"); // 添加的元素符合泛型限制的数据类型String, 所以可以添加  
        // list.add(new Dog("小黄", 1)); // 添加的Dog元素不符合泛型限制的数据类型，编译器会直接报错，代码无法通过编译。
    }  
}

上方代码中，泛型的数据类型指定为String类型，则在List对象中添加的元素，只能是String类型，而添加其他类型（比如Dog类型）的元素，会在编译阶段报错。

为什么要引入泛型？

在引入泛型之前，有一些有关数据类型的难题。

如果我要定义一个列表，假如说希望这个列表可以存放所有数据类型的元素，我只能将存储元素的数据结构体定义为Object。但是，现在产生了一个问题，由于存放的元素都是Object类型，对元素的操作就只能使用Object的方法，而不能用元素特定的方法。如果要使用特定数据类型的方法，则需要强制类型转换，这会抛出ClassCastException异常。

// 如果没有泛型，那么只能用Object类型存储集合中的元素  
public class MyList1{ // 自定义一个指定容量的List类  
    private Object[] array;  
    private int size;  
  
    public MyList1(int capacity) {  
        array = new Object[capacity];  
    }  
  
    public void add(Object o) {  
        array[size] = o;  
        size++;  
    }  
  
    public Object get(int index) {  
        return array[index];  
    }  
  
    public int size() {  
        return size;  
    }  
}

public class Demo2 {  
    public static void main(String[] args) {  
        // 创建自定义List对象  
        MyList1 list = new MyList1(10);  
        list.add("hello"); // 添加Stirng类型元素  
        list.add(100); // 添加int类型元素（自动装箱为Integer类型）  
        list.add(new Dog("小黄")); // 添加Dog类型元素  
  
        for(int i = 0; i < list.size(); i++) {  
            Object o = list.get(i);  
            System.out.println(o.toString()); // 只能使用Object类型的实例方法  
        }  
  
        // 强制类型转换，则会抛出ClassCastException异常  
        // for(int i = 0; i < list.size(); i++) {  
        //     Dog s = (Dog) list.get(i);        //     s.eat();        // }    }  
}

当然，这种情况下，如果列表都存储数据类型的元素，也可以强制做数据类型转换，之后即可调用该元素的数据类型的方法。比如：

public class Demo3 {  
    public static void main(String[] args) {  
        MyList1 list = new MyList1(10); // 存放相同数据类型的元素  
        list.add("hello");  
        list.add("world");  
        list.add("java");  
  
        for(int i = 0; i < list.size(); i++) {  
            String s = (String) list.get(i); // 强制类型转换  
            System.out.println(s.length());   
        }  
    }  
}

也就是说，在没有泛型时，我们只能依赖代码编写时，程序员注意保持相同的数据类型，并且要手动做强制类型转换。这种很容易出错。

引入泛型，用"< T>"，相当于引入了一个数据类型变量"T"，让"T"作为存储元素的数据结构类型。

public class MyList2<T> { // 自定义一个指定容量的List类  
    private T[] array;  
    private int size;  
  
    public MyList2(int capacity) {  
        array = (T[]) new Object[capacity];  
    }  
  
    public void add(T o) {  
        array[size] = o;  
        size++;  
    }  
  
    public T get(int index) {  
        return array[index];  
    }  
  
    public int size() {  
        return size;  
    }  
}

在编译阶段，编译器会根据<String>对类型T进行严格的检查和推断，所有使用T的地方都被视为String。

在运行时（JVM层面），这个"替换"并没有发生。Java的泛型是通过 "类型擦除" 实现的。也就是说，在编译后的字节码中，T被替换成了它的上界（在你这里是 Object），MyList2<String> 和 MyList2<Integer> 在运行时其实是同一个类。

public class Demo4 {  
    public static void main(String[] args) {  
        MyList2<String> list = new MyList2<>(10); // 使用泛型类存放字符串元素  
        list.add("hello");  
        list.add("world");  
        // list.add(new Dog("小黄")); // 添加Dog类型元素，编译器会报错  
    }  
}

如上代码，在添加Dog类型元素时，编译器会报类型错误。因为编译器会认为你在调用add方法时，需要使用String类型，而不应该用Dog类型。

public void add(String o) {  // T 已被替换成String
        array[size] = o;  
        size++;  
    }  

综上所述，引入泛型后，可以让编译器检查数据类型约束，减少错误。

初次之外，泛型还提供两个价值：

1. 代码复用，使用泛型，就不需要为每个数据类型单独写一个接口、类或方法。比如，写了一个Collection< T >，就可以创建Collection< String >、Collection < Integer >等。
2. 代码可读性。List<String> 一眼就能看出这个列表里放的是什么，比 List然后靠注释说明清晰得多。