第02篇_进阶语法

第01章_泛型

第一节 泛型简介

1. 什么是泛型?

泛型是计算机编程中一种重要的思维方式，它将程序算法与数据类型相分离，使得同一套程序算法能够应用于各种数据类型，并且可以保证类型安全，提高可读性。

通俗来说，泛型就是类型参数化，即通过参数的形式传入类型，将代码与具体的数据类型解绑，同一套代码可用于多种数据类型。

​x
1
/* 泛型类 Pair，拥有两个泛型 U 和 V */
2
public class Pair<U, V> {
3
    U first;
4
    V second;
5

6
    public Pair(U first, V second) {
7
        this.first = first;
8
        this.second = second;
9
    }
10

11
    public U getFirst() {
12
        return first;
13
    }
14

15
    public V getSecond() {
16
        return second;
17
    }
18

19
    public static void main(String[] args) {
20
        // 泛型类实例化01  传入泛型参数 <String, String> => <U,T>
21
        Pair<String, String> pair01 = new Pair<String, String>("老马", "说编程");
22

23
        // 泛型类实例化02  传入泛型参数 <String, Integer> => <U,T>
24
        Pair<String, Integer> pair02 = new Pair<String, Integer>("老马", 100);
25

26
        // 使用泛型类对象, 无需强制类型转换
27
        String first = pair01.getFirst();
28
        String second = pair01.getSecond();
29

30
        // 提示：JDK7+版本，new后面的类型参数可以省略，会自动推断
31
        Pair<String, Integer> pair02_ = new Pair<>("老马", 100);
32
    }
33
}
34

2. 泛型的本质

泛型的本质是类型擦除(这对后面理解泛型非常重要)。在编译过程中，所有的泛型都将会被替换为Object类(或其上界类)，并在合适的位置插入必要的强制类型转换，虚拟机只能执行这种转换后的非泛型代码。

27
1
// 编译后：泛型被擦除，泛型类型被替换为Object(或其上界类)
2
public class ErasedPair {
3
    Object first;
4
    Object second;
5

6
    public ErasedPair(Object first, Object second) {
7
        this.first = first;
8
        this.second = second;
9
    }
10

11
    public Object getFirst() {
12
        return first;
13
    }
14

15
    public Object getSecond() {
16
        return second;
17
    }
18

19
    public static void main(String[] args) {
20
        ErasedPair pair01 = new ErasedPair("老马", 100);
21

22
        // 编译后：在使用处插入强制类型转换
23
        String first = (String) pair01.getFirst(); // "老马"
24
        Integer second = (Integer) pair01.getSecond();  // 100
25
    }
26
}
27

3. 泛型的好处

前面得知，泛型类最后依旧会被转换为非泛型类，那么我们使用泛型类有什么好处呢? 主要有两点：

1. 避免强制类型转换，做到在编译期进行类型安全检查，防止类型转换异常(ClassCastException)。

2. 精简代码，增强代码的健壮性和可维护性。

第二节 泛型的基本使用

泛型根据定义的位置不同，分为泛型类、泛型接口、泛型方法三类。

1. 泛型类

60
1
// 1. 泛型类：在类名后声明泛型，后面将在实例化泛型类时具体化泛型(E)
2
public class DynamicArray<E> {
3
    private static final int DEFAULT_CAPACITY = 10;
4
    private int size;
5
    private Object[] elementData;
6

7
    public DynamicArray() {
8
        this.elementData = new Object[DEFAULT_CAPACITY];
9
    }
10

11
    // 动态扩容
12
    private void ensureCapacity(int minCapacity) {
13
        int oldCapacity = elementData.length;
14
        if (oldCapacity >= minCapacity) {
15
            return;
16
        }
17
        int newCapacity = oldCapacity * 2;
18
        if (newCapacity < minCapacity) {
19
            newCapacity = minCapacity;
20
        }
21
        elementData = Arrays.copyOf(elementData, newCapacity); // 拷贝到newCapacity长度的新数组
22
    }
23

24
    public void add(E e) {
25
        ensureCapacity(size + 1);
26
        elementData[size++] = e;
27
    }
28

29
    public E get(int index) {
30
        return (E) elementData[index];
31
    }
32

33
    public int size() {
34
        return size;
35
    }
36

37
    public E set(int index, E element) {
38
        E oldValue = get(index);
39
        elementData[index] = element;
40
        return oldValue;
41
    }
42

43
    public static void main(String[] args) {
44
        // 2. 在实例化泛型类时具体化泛型(E)
45
        // 2.1 具体化为具体类型，此时具体化为Double类型
46
        DynamicArray<Double> doubleDynamicArray = new DynamicArray<>();
47
        doubleDynamicArray.add(1.23);
48

49
        // 2.2 具体化为具体类型中的Object类型(不推荐这样使用，因为后面使用时需要强制类型转换，违背了泛型的本意)
50
        DynamicArray<Object> objectDynamicArray = new DynamicArray<>();
51
        DynamicArray defaultDynamicArray = new DynamicArray(); // 具体化过程<xxx>可以省略，默认为<Object>
52
        defaultDynamicArray.add("老马");
53
        defaultDynamicArray.add(100);
54

55
        // 2.3 具体化为其它泛型类，此时具体化为Pair<String, Integer>类型(其中Pair的泛型U,V分别具体化为String, Integer类型)
56
        DynamicArray<Pair<String, Integer>> pairDynamicArray = new DynamicArray<>();
57
        pairDynamicArray.add(new Pair<>("老马", 100));
58
    }   
59
}
60

2. 泛型接口

49
1
// 1. 泛型接口：在接口名后声明泛型，后续将在实现接口时具体化泛型(T)
2
public interface Comparable<T> {
3
    int compareTo(T o);
4
}
5

6
// 2. 在实现接口时具体化泛型(T)
7
// 2.1 具体化为具体类型，此处为Integer
8
public class MyInteger implements Comparable<Integer> {
9
    private Integer num;
10

11
    @Override
12
    public int compareTo(Integer o) { // 可以与Integer类型的其它对象比较
13
        return this.num - o;
14
    }
15
}
16

17
// 2.2 具体化为具体类型，此处为Object
18
public class MyObject implements Comparable<Object> {
19
    private Object num;
20

21
    @Override
22
    public int compareTo(Object o) { // 可以与Object类型的其它对象比较
23
        return this.num.hashCode() - o.hashCode();
24
    }
25
}
26

27
// 2.3 具体化为新声明的泛型(泛型传递)，此时具体化为子类新声明的(TT) 
28
// 注意：这里为了区分Comparable的泛型名称T，取名为TT；实际上，新声明的泛型也可以叫T；
29
public class MyInfo<TT> implements Comparable<TT> {
30
    private TT info;
31

32
    public MyInfo(TT info) {
33
        this.info = info;
34
    }
35

36
    @Override
37
    public int compareTo(TT o) {
38
        return info.hashCode() - o.hashCode(); // 可以与TT类型的其它对象比较
39
    }
40

41
    public static void main(String[] args) {
42
        // 2.3 在实例化子类时，将具体化子类的泛型TT，此时TT具体化为String类型
43
        // 进而，将已知的TT类型(String)传递给Comparable接口的泛型T(泛型传递)
44
        MyInfo<String> stringMyInfo = new MyInfo<>("hyx");
45
        int compare = stringMyInfo.compareTo("hyx2");
46

47
    }
48
}
49

3. 泛型方法

25
1
// 1. 泛型方法：在返回值之前声明泛型
2
public static <T> int indexOf(T[] arr, T elm) {
3
    for (int i = 0; i < arr.length; i++) {
4
        if (arr[i].equals(elm)) {
5
            return i;
6
        }
7
    }
8
    return -1;
9
}
10

11
// 扩展：多个泛型参数的泛型方法
12
public static <U, V> Pair<U, V> makePair(U first, V second) {
13
    Pair<U, V> pair = new Pair<>(first, second);
14
    return pair;
15
}
16

17
public static void main(String[] args) {
18
    // 2. 在使用方法时具体化泛型(T)
19
    int indexOf01 = indexOf(new Integer[]{1, 3, 5}, 10); // 此时具体化为具体类型Integer
20
    int indexOf02 = indexOf(new String[]{"hello", "老马", "编程"}, "老马"); // 此时具体化为具体类型String
21

22
    // 注意：和泛型类/泛型接口不同，泛型方法在使用时一般并不需要特意指定泛型的具体类型，它会根据实参自动推断
23
    Pair<Integer, String> pair = makePair(1, "老马");
24
}
25
    

注意：

1. 如果方法为静态方法，那么将不能够使用类上声明的泛型(静态变量同理)，因为他们是类级别共享的。

2. 一个方法是不是泛型的，与它所在的类是不是泛型没有任何关系，可以使用类上的泛型，也可以新定义方法的泛型。

4. 泛型的类型信息

虽然泛型在编译时被擦除为Object或上界类，但是在运行时，泛型引用的对象是实际的不同具体类型，并且可以获取和使用该类型信息。

31
1
public class MyWrapper<T> {
2
    private T data;
3

4
    public MyWrapper(T data) {
5
        this.data = data;
6
    }
7

8
    public Class<?> getDataType() {
9
        // 具体化类型的Class信息
10
        return data.getClass();
11
    }
12

13
    public T create() throws IllegalAccessException, InstantiationException {
14
        return (T) getDataType().newInstance();
15
    }
16

17
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
18
        // 1. 使用不同的类型具体化泛型
19
        MyWrapper<String> strWrapper = new MyWrapper<>("abc");
20
        MyWrapper<Date> dateWrapper = new MyWrapper<>(new Date());
21

22
        // 2. 获取具体化类型的Class信息
23
        System.out.println(strWrapper.getDataType()); // class java.lang.String
24
        System.out.println(dateWrapper.getDataType()); // class java.lang.Integer
25

26
        // 3. 使用“具体化类型的Class信息”创建“具体化类型对象”
27
        Date date = dateWrapper.create();
28
        System.out.println(date); // Wed Feb 08 16:53:14 CST 2023
29
    }
30
}
31

第三节 限定泛型

1. 无限定泛型的使用限制

在上述案例中，声明泛型时未做任何额外的限制，因此在泛型具体化时，可以使用任意类型，这种未被限制的泛型称为无限定泛型。也正是因为在具体化时没有限制类型的取值范围，因此无限定泛型在使用时将会受到一些限制。

例如，在通过泛型引用E e操作指向的对象时，由于E可能是任意类型，因此只能调用任意类型的根类Object的属性或方法。

10
1
public void method01(E e) {
2
    // 1. 只能调用任意类型的根类Object的属性或方法
3
    e.hashCode(); // Object的方法，OK
4
    //e.childClassMethod(); // 非Object方法，ERR
5

6
    // 2. 只能赋值给Object或同类型引用E
7
    Object o = e;
8
    E ee = e;
9
    //Number n = e; // Error: 不兼容的类型: E无法转换为java.lang.Number
10
}

为了减弱上述限制，我们可以在声明泛型时进一步限定泛型可具体化的类型范围，要求其必须继承某类或实现某个接口，这样就可以在保证类型安全的前提下使用该类(接口)的一系列方法了，这种被限制可具体化类型范围的泛型称为限定泛型。

2. 限定为某类(接口)或其子类

上文提到的Pair<U,V>类，对其进行扩展，限定泛型可具体化的类型必须是Number或其子类，格式为：<泛型名 extends 上界类名>。

19
1
// 1. 泛型类NumberPair，声明了泛型U,V，并限定必须为Number或其子类
2
public class NumberPair<U extends Number, V extends Number> extends Pair<U, V> {
3
    public NumberPair(U first, V second) {
4
        super(first, second);
5
    }
6

7
    // 2. 泛型进行限定后，就可以使用上界类的一系列属性和方法了
8
    public double sum() {
9
        return getFirst().doubleValue() + getSecond().doubleValue(); // 使用Number的doubleValue()方法
10
    }
11

12
    public static void main(String[] args) {
13
        // 3. 在实例化时，泛型的具体化类型必须为Number或其子类
14
        // NumberPair<String, Long> pair = new NumberPair<String, Long>(1, 2L); // Type parameter 'java.lang.String' is not within its bound; should extend 'java.lang.Number'
15
        NumberPair<Integer, Long> pair = new NumberPair<>(1, 2L); // Integer, Long都是Number的子类
16
        double sum = pair.sum();
17
    }
18
}
19

注意：

1. 对于限定泛型，在进行类型擦除时，将转换为它的上界类。

2. 上界接口可以存在多个，如：T extends Base & Comparable & Serializable，其中Base为上界类，其它为上界接口。

2. 上界类为泛型类

上界类也可以是一个带泛型的泛型类，那么在声明限定泛型时，必须对上界类的泛型进行具体化：

66
1
import java.lang.Comparable;
2

3
public class MainTest {
4
    // 1. 上界类的泛型具体化为某个具体类型(由于该具体类型难以和原限定泛型T有交互，因此使用极少)
5
    // 调用要求：限定泛型T的具体化类型必须实现Comparable<String>接口
6
    public static <T extends Comparable<String>> T maxInString(T[] arr) {
7
        T max = arr[0];
8
        for (int i = 1; i < arr.length; i++) {
9
            if (arr[i].compareTo(max.toString()) > 0) { // compareTo的形参类型为String
10
                max = arr[i];
11
            }
12
        }
13
        return max;
14
    }
15

16
    // 2. 上界类的泛型具体化为原限定类型T(递归类型限制，常用)
17
    // 调用要求：限定泛型T的具体化类型必须实现Comparable<T>接口
18
    public static <T extends Comparable<T>> T maxInT(T[] arr) {
19
        T max = arr[0];
20
        for (int i = 1; i < arr.length; i++) {
21
            if (arr[i].compareTo(max) > 0) { // compareTo的形参类型为T
22
                max = arr[i];
23
            }
24
        }
25
        return max;
26
    }
27

28
    // 3.上界类的泛型具体化为Object(使用极少)
29
    // 调用要求：限定泛型T的具体化类型必须实现Comparable<Object>接口
30
    public static <T extends Comparable<Object>> T maxInObject(T[] arr) {
31
        T max = arr[0];
32
        for (int i = 1; i < arr.length; i++) {
33
            if (arr[i].compareTo(max) > 0) { // compareTo的形参类型为Object
34
                max = arr[i];
35
            }
36
        }
37
        return max;
38
    }
39

40
    // 4. 上界类的泛型具体化类型省略(这里不是默认为Object类型，而是为?类型，后文将会讲解)
41
    // 调用要求：限定泛型T的具体化类型必须实现Comparable<?>接口，?表示任意类型
42
    public static <T extends Comparable> T maxInAnyone(T[] arr) {
43
        T max = arr[0];
44
        for (int i = 1; i < arr.length; i++) {
45
            if (arr[i].compareTo(max) > 0) { // compareTo的形参类型为Object
46
                max = arr[i];
47
            }
48
        }
49
        return max;
50
    }
51

52
    public static void main(String[] args) {
53
        // 定义一个String类型的数组，String实现了java.lang.Comparable<String>接口
54
        String[] stringArr = {"a", "b", "c"};
55

56
        // 可以使用maxInString、maxInT、maxInAnyone方法
57
        maxInString(stringArr); 
58
        maxInT(stringArr); 
59
        maxInAnyone(stringArr);
60

61
        // 不允许使用maxInObject方法，因为String并未实现Comparable<Object>接口
62
        // maxInObject(stringArr);
63
    }
64
}
65

66

注意：

1. 在实例化泛型类时，如果泛型的具体类型省略，将默认为Object类型，但是在具体化上界类时，并非如此。

3. 上界类为其它泛型

上界类还可以是已声明的其它泛型，当该泛型被具体化时，才会确定上界类的具体类型。如上述的DynamicArray的addAll()方法：

13
1
// 1. 上界类的类型为类上声明的泛型E，即限定泛型T的上界为E
2
public <T extends E> void addAll(DynamicArray<T> c) {
3
    for (int i = 0; i < c.size; i++) {
4
        add(c.get(i)); // 解释：由于T是E或其子类，因此可以调用add(E e)方法
5
    }
6
}
7

8
public static void main(String[] args) {
9
    // 通过 T extends E 使DynamicArray<Number>容器允许添加DynamicArray<Integer>容器中的对象
10
    DynamicArray<Number> numberArr = new DynamicArray<>();
11
    numberArr.addAll(new DynamicArray<Integer>());
12
}
13

如果不使用T extends E将会怎样？即addAll()方法定义如下所示，可以看到，将会出现编译错误。

14
1
// 直接使用类上的泛型E
2
public void addAll2(DynamicArray<E> c) { // 只能接收DynamicArray<E>类型
3
    for (int i = 0; i < c.size; i++) {
4
        add(c.get(i)); 
5
    }
6
}
7

8
public static void main(String[] args) {
9
    DynamicArray<Number> numberArr = new DynamicArray<>();
10
    
11
    // err 提示需要一个DynamicArray <Number>类型，但是提供了一个DynamicArray <Integer>类型
12
    numberArr.addAll2(new DynamicArray<Integer>()); 
13
}
14

为什么会出现编译错误呢？我们分析下，如果DynamicArray<Integer>能给DynamicArray<Number>赋值将会怎么样?

7
1
// 如果上述DynamicArray<Integer>类型可以赋值给DynamicArray<Number>类型
2
DynamicArray<Integer> integerArray = new DynamicArray<>();
3
DynamicArray<Number> numberArray = integerArray; // 假设成立
4

5
// 由于numberArray的泛型的具体类型为Number，那么将可以通过add(E e)方法添加Double类型的数据到之前的integerArray之中！
6
numberArray.add(new Double(1.2)); // 如果上述假设成立那么将会出现该非法操作
7

注意：

1. 在add()方法中，形参为E，类型擦除后转换为Number，可以传入Number及Integer等子类；

2. 但是在addAll()方法中，形参为DynamicArray<E>，类型擦除后为DynamicArray<Number>，而DynamicArray<Integer>是不允许传给DynamicArray<Number>的，否则将会出现上述隐患；

第四节 泛型通配符

在泛型具体化时(而非声明时)，支持一些通配符的使用，它可以通配多种具体类型，但同时也带来了一些限制，下面将会详细介绍。

1. 通用泛型通配符

通用泛型通配符用于在具体化泛型时通配所有的具体类型，它简化了泛型的声明和使用，格式为：?。

10
1
// 在具体化类泛型E时，使用?通配所有的具体类型
2
public static int indexOf(DynamicArray<?> arr, Object elm) {
3
    for (int i = 0; i < arr.size(); i++) {
4
        if (arr.get(i).equals(elm)) { // 由于arr.get(i)的具体类型是?，因此只能调用Object对应的方法
5
            return i;
6
        }
7
    }
8
    return -1;
9
}
10
    

相应的，由于具体类型未知，因此在使用被通配的泛型对象时，也有一些限制。

8
1
// 1. 只能使用Object类型作为引用
2
Object o = arr.get(0);
3

4
// 2. 只能调用任意类型的根类Object的属性和方法
5
arr.get(0).hashCode();
6

7
// 3. 不能当作任何对象的引用，即不能被赋值
8
arr.get(0) = new Object() // err

为减弱上述限制，根据不同的使用场景，提供了两种特定通配范围的泛型通配符：子类型泛型通配符和超类型泛型通配符。

2. 子类型泛型通配符

子类型泛型通配符对通配的具体类型范围做出了一些限制，用于通配ParentClass其子类，格式为：? extends ParentClass。

17
1
// 在具体化类泛型E时，通配E及其子类
2
public void addAll(DynamicArray<? extends E> c) { 
3
    for (int i = 0; i < c.size; i++) {
4
        add(c.get(i));  
5
    }
6
}
7

8
public static void main(String[] args) {
9
    // Number容器添加Integer容器的所有数据
10
    DynamicArray<Number> numbers = new DynamicArray<>();
11
    DynamicArray<Integer> ints = new DynamicArray<>();
12
    ints.add(100);
13
    numbers.addAll(ints); // 这里类泛型E为Number，由于addAll方法在实例化E时通配了所有Number的子类，因此可以正确传参
14
}
15

16
// adAll方法的泛型具体化为什么不是<E>：虽然可以调用add(E e)，但是采用严格匹配，Number容器无法添加Integer容器数据
17
// adAll方法的泛型具体化为什么不是<?>：虽然可以传参进来，但是add(E e)无法调用，因为?不一定是E或其子类

在得知子类型泛型通配符只通配某个类及其子类后，那么就可以确定它的上界类了，上界类确定后就可以使用上界类的属性和方法，并且可以赋值给上界类。(注意：该例中上界类为E，同样是一个未知类型，因此没有其它额外的方法可以调用，同样也只能够赋值给E)

3. 超类型泛型通配符

超类型泛型通配符和子类型泛型通配符相反，它用于通配ChildClass及其父类，格式为：? super ChildClass。

19
1
// 在具体化类泛型E时，通配E及其父类
2
public void copyTo(DynamicArray<? super E> dest) {
3
    for (int i = 0; i < size; i++) {
4
        dest.add(get(i)); // get(i)的类型为E；dest容器的类型为E或其父类；
5
    }
6
}
7

8
public static void main(String[] args) {
9
    // Integer容器数据拷贝到另外的Number容器中
10
    DynamicArray<Integer> ints2 = new DynamicArray<Integer>();
11
    ints.add(100);
12
    ints.add(34);
13
    DynamicArray<Number> numbers2 = new DynamicArray<Number>();
14
    ints.copyTo(numbers);
15
}
16

17
// copyTo方法的泛型具体化为什么不是<E>：虽然可以调用add(E e)，但是采用严格匹配，Number容器数据无法添加到Integer容器
18
// copyTo方法的泛型具体化为什么不是<?>：虽然可以传参进来，但是add(E e)无法调用，因为?不一定是E或其父类
19
// copyTo方法的泛型具体化为什么不是<? extends E>：add(E e)无法调用，虽然?一定是E或其子类，但不一定是E或其父类

在得知超类型泛型通配符只通配某个类及其父类后，那么就可以确定它的下界类了，下界类确定后就可以使用下界类作为引用。

注意：关于限定泛型、子类型通配符、超类型通配符的赋值兼容

9
1
// 限定泛型<T extends Number>，表示限定具体化类型只能是Number或其子类
2

3
// 通配Number及其子类，由于Integer是Number的子类，所以可以赋值
4
DynamicArray<? extends Number> numberArray = new DynamicArray<Integer>();
5

6
// 通配Number及其父类，由于Integer不是Number的父类，所以不可以赋值
7
DynamicArray<? super Number> numberArray = new DynamicArray<Integer>(); // err
8
DynamicArray<? super Number> numberArray2 = new DynamicArray<Object>(); // OK，Object是Number的父类，可以通配
9

再来看另外一个关于超类型通配符的使用场景：

60
1
// 普通类Base继承了Comparable<Base>
2
class Base implements Comparable<Base> {
3
    private int sortOrder;
4

5
    public Base(int sortOrder) {
6
        this.sortOrder = sortOrder;
7
    }
8

9
    @Override
10
    public int compareTo(Base o) {
11
        if (sortOrder < o.sortOrder) {
12
            return -1;
13
        } else if (sortOrder > o.sortOrder) {
14
            return 1;
15
        } else {
16
            return 0;
17
        }
18
    }
19
}
20

21
// Child继承了Base，相当于间接继承了Comparable<Base>，因此继承了int compareTo(Base o)方法
22
class Child extends Base {
23
    public Child(int sortOrder) {
24
        super(sortOrder);
25
    }
26

27
    // max方法声明方式1
28
    public static <T extends Comparable<T>> T max(DynamicArray<T> arr) {
29
        if (arr == null || arr.size() == 0) {
30
            return null;
31
        }
32

33
        T max = arr.get(0);
34
        for (int i = 1; i < arr.size(); i++) {
35
            if (arr.get(i).compareTo(max) > 0) {
36
                max = arr.get(i);
37
            }
38
        }
39

40
        return max;
41
    }
42
    
43
    // max方法声明方式2：引入超类型通配符
44
    public static <T extends Comparable<? super T>> T max(DynamicArray<T> arr) {
45
        // ...
46
    }
47
    
48
    // 如下为测试代码
49
    public static void main(String[] args) {
50
        DynamicArray<Child> childs = new DynamicArray<Child>();
51
        childs.add(new Child(20));
52
        childs.add(new Child(80));
53
        
54
        // 调用max，其中T为Child
55
        // 方式1：要求T(Child)必须实现Comparable<Child>接口，但是Child实现的是Comparable<Base>接口，错误！
56
        // 方式2：要求T(Child)必须实现Comparable<? super Child>接口，其中Comparable的泛型可以通配Child及其父类，自然也可以是base，OK！
57
        Child maxChild = max(childs); 
58
    }
59
}
60

4. 限定泛型和泛型通配符对比

• 限定泛型在声明泛型时使用，泛型通配符在具体化泛型时使用，它们的使用时机不同。

• 泛型通配符形式和限定泛型往往配合使用，如下面的swap()方法。

  19
  1
  // 1. 通配所有类型，用户阅读和使用更加方便
  2
  // 注意：由于arr使用了通用泛型通配符，未知类型(arr.get(j))不能给set()方法的第二个形参(也是未知类型的引用)赋值
  3
  public static void swap(DynamicArray<?> arr, int i, int j) {
  4
      swapInternal(arr, i, j);  // 内部调用泛型方法
  5
  }
  6
  
  7
  // 2. 私有的泛型方法，内部能够使用set()方法
  8
  private static <T> void swapInternal(DynamicArray<T> arr, int i, int j) {
  9
      T tmp = arr.get(i);
  10
      arr.set(i, arr.get(j));
  11
      arr.set(j, tmp);
  12
  }
  13
  
  14
  // 3. 其它综合使用案例
  15
  public static <T extends Comparable<? super T>> void sort(List<T> list)
  16
  public static <T> void sort(List<T> list, Comparator<? super T> c)
  17
  public static <T> void copy(List<? super T> dest, List<? extends T> src)
  18
  public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)
  19
  
  

• 通常子类型泛型通配符可以使用限定泛型来实现，但是方法返回值依赖于泛型等特殊情况除外。

  34
  1
  // 拷贝容器数据，方式1：
  2
  public static <D, S extends D> void copy(DynamicArray<D> dest, DynamicArray<S> src) {
  3
      for (int i = 0; i < src.size(); i++) {
  4
          dest.add(src.get(i));
  5
      }
  6
  }
  7
  // 拷贝容器数据，方式2：
  8
  public static <D> void copy(DynamicArray<D> dest, DynamicArray<? extends D> src) {
  9
      for (int i = 0; i < src.size(); i++) {
  10
          dest.add(src.get(i));
  11
      }
  12
  }
  13
  
  14
  // 添加容器数据，方式1：
  15
  public <T extends E> void addAll(DynamicArray<T> c){}
  16
  // 添加容器数据，方式2：
  17
  public void addAll(DynamicArray<? extends E> c){}
  18
  
  19
  // indexOf，方式1：
  20
  public static <T> int indexOf(DynamicArray<T> arr, Object elm)
  21
  // indexOf，方式2：
  22
  public static int indexOf(DynamicArray<?> arr, Object elm)
  23
  
  24
  // 返回值依赖于泛型：返回类型无法用通配符替代
  25
  public static <T extends Comparable<T>> T max(DynamicArray<T> arr) {
  26
      T max = arr.get(0);
  27
      for (int i = 1; i < arr.size(); i++) {
  28
          if (arr.get(i).compareTo(max) > 0) {
  29
              max = arr.get(i);
  30
          }
  31
      }
  32
      return max;
  33
  }
  34
  
  

第五节 泛型的局限性

前面提到，Java中的泛型是通过类型擦除来实现的，所有的泛型在编译时都会被替换为Object或上界类，运行时Java虚拟机不知道泛型这回事，这带来了很多局限性，其中有的部分是比较容易理解的，有的则是非常违反直觉的 。

1. 泛型的具体化类型不能是基本类型

泛型的具体化类型不能是基本类型，应该使用它的包装类。

3
1
// 不能使用int去具体化泛型，因为int没有根类Object
2
Pair<int> intPair = new Pair<int>(1,100);
3

2. 不能通过泛型直接创建对象

不能通过泛型直接创建对象，需要传入泛型对应的类型信息，通过反射创建。

19
1
// 1. 由于类型擦除，使用new T()创建的对象也只能当Object使用，并且容易引起使用者误解，所以Java干脆禁止
2
T elm = new T(); // err
3

4
// 同样，泛型数组也是不允许创建的(容器的元素类型一般为Object而非泛型E与此相关)
5
T[] arr = new T[10]; // err 不能创建泛型数组
6

7

8
// 2. 如果希望创建具体化类型的对象，则可传入具体化类型的Class对象，根据反射创建
9
public static <T> T create(Class<T> type) {
10
    try {
11
        return type.newInstance(); // 反射
12
    } catch (Exception e) {
13
        return null;
14
    }
15
}
16

17
// 创建Date对象
18
Date date = Pair.create(Date.class);
19

提示：

1. 实际上，可以参考第二节中，通过泛型引用的对象获取Class信息，进而创建对象。

3. 泛型类的不同具体化本质上还是同一个类

泛型在编译时将会被擦除为Object(或上界类)，不同的具体化类型只是在编译时自动插入了不同的强制类型转换，本质上还是同一个类。

由于是同一个类，因此它们的类型信息完全一致，并且类上所具有的静态资源也是共享的。

25
1
// 1. 不同具体化类型的两个Pair对象
2
Pair<String, String> pair01 = new Pair<String, String>("老马", "说编程");
3
Pair<String, Integer> pair02 = new Pair<String, Integer>("老马", 100);
4

5
// 类型信息是完全一致的
6
System.out.println(Pair.class); // class com.huangyuanxin.notes.javabase.generics.Pair
7
System.out.println(Pair.class == pair01.getClass()); // true
8
System.out.println(pair01.getClass() == pair02.getClass()); // true
9
System.out.println(Pair<?, ?>.class); // err
10
System.out.println(Pair<String, Integer>.class);  // err 
11

12
// 类型也可以使用instanceof关键字进行判断
13
if (pair01 instanceof Pair){} // OK
14
if (pair01 instanceof Pair<?, ?>){} // OK，特殊情形
15
if (pair01 instanceof Pair<Integer>){} // err
16

17

18
// 2. 定义如下静态变量
19
public static String STATIC_NAME = "PAIR";
20

21
// 打印静态变量，发现也是共享的
22
Pair.STATIC_NAME = "STATIC_NAME_MODIFY";
23
System.out.println(Pair.STATIC_NAME); // STATIC_NAME_MODIFY
24
System.out.println(pair01.STATIC_NAME); // STATIC_NAME_MODIFY
25

注意：

1. 内部的first/second编译时都被擦除为Object类型，但是运行时分别指向不同的具体化类型对象。

4. 类上的泛型不能用于静态变量或静态方法

泛型类的泛型不能用于静态变量或静态方法，应为静态方法单独声明泛型，而静态变量不允许为泛型。

12
1
// 声明泛型T，仅适用于成员变量和成员方法
2
public class Singleton<T> {
3
    private static T instance; // err 静态变量不能为泛型
4

5
    public synchronized static T getInstance() { // err 不能用于静态方法
6
        if (instance == null) {
7
            //创建实例
8
        }
9
        return instance;
10
    }
11
}
12

5. 类型擦除可能会引发一些冲突

24
1
// 1. 案例一：如下，Base实现了Comparable<Base>接口 
2
class Base implements Comparable<Base>{} 
3

4
// Child继承Base，间接实现了Comparable<Base>接口，OK！
5
class Child extends Base{} 
6

7
// 如果Child想自定义compareTo()方法，发现不能实现Comparable<Child>接口
8
class Child extends Base implements Comparable<Child>{} // err，重复实现了
9

10
// 此时只能重写Base中的方法来自定义Child中的该方法
11
@Override
12
public int compareTo(Base o) {
13
    if (!(o instanceof Child)) {
14
        throw new IllegalArgumentException();
15
    }
16
    Child c = (Child) o;
17
    return 0;
18
}
19

20

21
// 2. 案例二：看起来很像方法重载，但是由于类型擦除后都是Object，因此也是不允许的
22
public static void test(DynamicArray<Integer> intArr){}
23
public static void test(DynamicArray<String> strArr){}
24

6. 不能直接创建泛型数组

如下创建泛型数组的代码是禁止的：

4
1
Pair<Object, Integer>[] options = new Pair<Object, Integer>[]{
2
        new Pair("1元", 7), new Pair("2元", 2), new Pair("10元", 1)
3
};
4

因为数组是Java直接支持的概念，它知道数组元素的实际类型，在类型不对时可快速触发运行时异常，因此编译时允许赋值给父类数组。

5
1
// 创建普通类型数组
2
Integer[] ints = new Integer[10];
3
Number[] numbers = ints; // 子类数组赋值给父类数组 ok
4
numbers[0] = 1.2; // 类型不对，触发运行时异常：java.lang.ArrayStoreException: java.lang.Double
5

但是如果允许创建泛型数组，如下：

5
1
// 创建泛型数组
2
Pair<Object, Integer>[] options = new Pair<Object, Integer>[3];
3
Object[] objs = options; // 子类数组赋值给父类数组
4
objs[0] = new Pair<Double, String>(12.34, "hello"); // 隐患代码
5

由于Pair<Double, String>和Pair<Object, Integer>的类型都是Pair，因此第二行赋值时即不会编译报错，也不会立即触发运行时异常，埋下了隐患，因此Java禁止创建泛型数组。

如果我们非要创建泛型类型的数组，可以使用原始类型来创建，这样可以跳过编译检查，但是问题还是存在的。

7
1
Pair[] options = new Pair[]{
2
        new Pair<String, Integer>("1元", 7),
3
        new Pair<String, Integer>("2元", 2),
4
        new Pair<String, Integer>("10元", 1),
5
        new Pair<String, String>("10元", "1") // 注意：数组元素类型不一致。
6
};
7

最好的解决办法是，使用泛型容器来代替泛型数组：

6
1
DynamicArray<Pair<String, Integer>> options = new DynamicArray<>();
2
options.add(new Pair<String, Integer>("1元", 7));
3
options.add(new Pair<String, Integer>("2元", 2));
4
options.add(new Pair<String, Integer>("10元", 1));
5
options.add(new Pair<String, String>("10元", "1")); // err 不兼容的类型在编译时报错
6

7. 泛型容器不能直接转换为数组

有时候我们希望将泛型容器直接转化为一个泛型数组，如下：

5
1
DynamicArray<Integer> ints = new DynamicArray<Integer>();
2
ints.add(100);
3
ints.add(34);
4
Integer[] arr = ints.toArray(); // 泛型容器 -> 泛型数组
5

实现toArray()方法时，一般是先创建一个泛型数组，然后拷贝数据再返回该数组。

由于前面已经提到，直接创建泛型数组是行不通的：E[] arr = new E[size]; // err，因此，可能会想到如下两种方式：

11
1
// 
2
public E[] toArray() {
3
    Object[] copy = new Object[size]; // 创建Object数组
4
    System.arraycopy(elementData, 0, copy, 0, size);
5
    return (E[]) copy; // 强转报错
6
}
7

8
public E[] toArray() {
9
    return (E[])Arrays.copyOf(elementData, size); // copyOf返回Object数组，强转报错
10
}
11

虽然这两者方式没有编译错误，但是在运行时都会抛出如下异常：

1
1
java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;