Java笔记6-泛型（待更）

笔记摘自 廖雪峰的官方网站-Java教程-泛型 。

泛型定义

泛型就是 编写模板代码 来适应任意类型；

泛型的来源（加深理解）：什么是泛型 。

ArrayList的优缺点

Java标准库提供了ArrayList，它可以看作“可变长度”的数组，因为用起来比数组更方便。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

public class ArrayList {
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    public void remove(int index) {...}
    public Object get(int index) {...}
}

如果用上述ArrayList存储String类型，会有这么几个缺点：

• 需要强制转型；
• 不方便，易出错。

ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);

ArrayList 的改进—— ArrayList

把ArrayList变成一种模板：ArrayList，代码如下：

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

ArrayList 自带 add(), remove(), get() 可供使用；
T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

因此，泛型就是定义一种模板，例如ArrayList，然后在代码中为用到的类创建对应的ArrayList<类型>：

ArrayList<String> strList = new ArrayList<String>();

strList.add("hello"); // OK
String s = strList.get(0); // OK
strList.add(new Integer(123)); // compile error!
Integer n = strList.get(0); // compile error!

这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。
泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；

向上转型

在Java标准库中的ArrayList实现了List接口，它可以向上转型为List：

public class ArrayList<T> implements List<T> {
    ...
}

List<String> list = new ArrayList<String>();

即类型ArrayList可以向上转型为List。

注意泛型的继承关系：可以把ArrayList向上转型为List（T不能变！），但不能把ArrayList向上转型为ArrayList（T不能变成父类）。**

使用泛型

简写

对于下面的代码：

List<Number> list = new ArrayList<Number>();

编译器看到泛型类型List可以自动推断出后面的ArrayList的泛型类型必须是ArrayList，因此，可以把代码简写为：

// 可以省略后面的Number，编译器可以自动推断泛型类型：
List<Number> list = new ArrayList<>();

泛型接口

除了ArrayList使用了泛型，还可以在接口中使用泛型。

例如，Arrays.sort(Object[])可以对任意数组进行排序，但 待排序的元素的类 必须实现 Comparable 这个泛型接口：

public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}

例如：

// sort
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Person[] ps = new Person[] {
            new Person("Bob", 61),
            new Person("Alice", 88),
            new Person("Lily", 75),
        };
        Arrays.sort(ps); // 想要对 ps 排序，那么 Person 类实现Comparable<Person> 这个泛型接口
        System.out.println(Arrays.toString(ps));
    }
}
class Person implements Comparable<Person> {// Person 类实现Comparable<Person> 这个泛型接口
    String name;
    int score;
    Person(String name, int score) {
        this.name = name;
        this.score = score;
    }
    public int compareTo(Person other) {
	    /**
	     * 返回负数: 当前实例比参数o小
	     * 返回0: 当前实例与参数o相等
	     * 返回正数: 当前实例比参数o大
	     */
        return this.score - other.score;
    }
    public String toString() {
        return this.name + "," + this.score;
    }
}
// 输出：[Bob,61, Lily,75, Alice,88]
// 按score从低到高排序

小结

使用泛型时，把泛型参数<T>替换为需要的class类型，例如：ArrayList<String>，ArrayList<Number>等；

可以省略编译器能自动推断出的类型，例如：List<String> list = new ArrayList<>();；

不指定泛型参数类型时，编译器会给出警告，且只能将<T>视为Object类型；

可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

编写泛型

编写泛型时，需要定义泛型类型；

模板：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

静态方法不能引用 泛型类型 ，必须定义其他类型（例如）来实现静态泛型方法；详情见 编写泛型-静态方法 。

泛型可以同时定义多种类型，例如Map<K, V>。例如，我们希望Pair不总是存储两个类型一样的对象，就可以使用类型<T, K>：

public class Pair<T, K> {
    private T first;
    private K last;
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

使用的时候，需要指出两种类型：

Pair<String, Integer> p = new Pair<>("test", 123);

Java标准库的Map<K, V>就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型。

擦拭法

原文写的比较详细，详情见 擦拭法 。

Java的泛型是采用擦拭法实现的；

擦拭法决定了泛型：

• 不能是基本类型，例如：int；
• 不能获取带泛型类型的Class，例如：Pair.class；
• 不能判断带泛型类型的类型，例如：x instanceof Pair；
• 不能实例化T类型，例如：new T()。

泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；因为方法 equals(Object obj) 已经存在。

子类可以获取父类的泛型类型。

extends通配符

super通配符

泛型和反射