Java泛型

5、类型通配符

什么是类型通配符？
类型通配符一般是使用 “?” 代替具体参数的数据类型；所以类型通配符是参数类型的实参，而不是参数类型的形参（是参数类型的实参和形参而不是参数的实参和形参，也就是说定义方法形参时用到的泛型标记只是参数类型的标识可以认为是这个参数的参数类型的形参，而 ? 则是在定义方法时用来做泛型标记的替代，表示这个参数的数据类型接受不限制数据类型的入参）；在定义方法时使用。
注意：类型通配符只能用于本来是泛型类/接口的参数做实参类型的匹配限制，如果参数本来不是泛型类/接口不能使用类型通配符（如：List、Set等等类原本的定义就是泛型类那么List、Set作为参数时就可以使用类型通配符；String、Integer等等这种本来定义就不是泛型类则不能使用类型通配符）
如：

//泛型类：
public class ConTest3<T> {

    private T name;

    public T getId() {
        return name;
    }

    public void setId(T name) {
        this.name = name;
    }
}
//使用泛型类：
public class Test3 {

    public static void main(String[] args) {
        //分别以不同的具体数据类型测试泛型
        ConTest3<Number> conTest3 = new ConTest3<>();
        conTest3.setId(111);
        test(conTest3);
        ConTest3<Integer> conTest31 = new ConTest3<>();
        conTest31.setId(1);
        test(conTest31);
        ConTest3<String> conTest32 = new ConTest3<>();
        conTest32.setId("xnwucw");
        test(conTest32);
    }

    /**
     * 定义使用泛型的方法，此时的形参ConTest3 conTest3本来是必须明确指定具体的数据类型，如：ConTest3 conTest3
     * 但这种方式则限制了这个泛型的实参只能是Number类型，即使Integer这种子类型的入参也是不行的会编译不通过，因为参数必须是ConTest3类型的，而不能是其他的具体数据类型
     * 此时如果还要支持ConTest3 conTest3入参，那么即使重载方法也是不行的，因为参数个数和类型、顺序还是一样的（都是ConTest3类型）
     * 此时如果想要一个方法支持不同具体数据类型的泛型类入参，那么只能使用类型通配符即?替代具体数据类型也就是写成ConTest3 conTest3，这样就可以使用不同
     * 具体数据类型的泛型类入参调用方法（为什么需要类型通配符）
     * @param conTest3
     */
    public static void test(ConTest3<?> conTest3){
        System.out.println(conTest3.getId());
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

类型通配符上限
语法：

类/接口<? extends 实参类型>   //限制使用方法时该参数的泛型的具体数据类型，只能是这里定义的实参类型，或实参类型的子类型，其他类型包括实参类型的父类型都不行（实参类型代表的具体数据类型可以是定义方法时指定的具体数据类型或者定义方法时也是用泛型标记代替实参类型但这个泛型标记和泛型类的标记是一样的，那么这个方法的泛型标记所代表的实参类型的具体数据类型就是和使用这个泛型类时定义的具体数据类型一致；如果方法是泛型方法且这个代表实参类型的泛型标记是定义泛型方法的泛型标记包含的那么就和泛型类的泛型标记无关（和 定义泛型方法 时泛型标记的规则一致））
例如：public TreeSet(Collection<? extends E> c) {
        this();
        addAll(c);
    }
TreeSet的这个构造器可以传递一个 Collection，而这个Collection集合采用了类型通配符上限，其中的实参类型是泛型标识E，而这个泛型标识E和public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable{}
TreeSet泛型类定义的泛型标识一样，那么也就是这个E所代表的具体数据类型和创建TreeSet对象的数据类型一致，如：TreeSet<String> treeSet = new TreeSet<>();那么此时要传入一个Collection集合就只能是String或String的子类   
1
2
3
4
5
6
7

//对于extends上限限制还有一些其他用法，比如：
package com.ceshi.jichu.generic;

/**
 * @version 1.0
 * @Description 测试其他extends情况
 * extends本来用于类型通配符代表的方法实参的数据类型限制
 * 但泛型类和泛型方法的定义也可以使用extends限制泛型的数据类型上限
 */
public class Test4<T extends Number> {

    public <T extends Object> T get(T t){
        return t;
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

拿上面的例子来说明就是：

	//调用test方法时，传入的实参为ConTest3泛型类类型，具体的数据类型只能是Number或Number的子类类型（如：Integer、Long等），如果传入非Number或Number子类型的具体数据类型（包括Number的父类型都不行）则编译不通过报错，那么修改后上面例子的conTest32对象，test(conTest32)则会报错
    public static void test(ConTest3<? extends Number> conTest3){
        System.out.println(conTest3.getId());
    }
1
2
3
4

类型通配符下限
语法：

类/接口<? super 实参类型>   //限制使用方法时该参数的泛型的具体数据类型，只能是这里定义的实参类型，或实参类型的父类型，其他类型包括实参类型的子类型都不行（实参类型代表的具体类型可以是定义方法时指定的具体数据类型或者定义方法时也是用泛型标记代替实参类型但这个泛型标记和泛型类的标记是一样的，那么这个方法的泛型标记所代表的实参类型的具体数据类型就是和使用这个泛型类时定义的具体数据类型一致；如果方法是泛型方法且这个代表实参类型的泛型标记是定义泛型方法的泛型标记包含的那么就和泛型类的泛型标记无关（和 定义泛型方法 时泛型标记的规则一致））
例如：public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
TreeSet的这个构造器可以传递一个 Comparator 比较器，而这个比较器采用了类型通配符下限，其中的实参类型是泛型标识E，而这个泛型标识E和public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable{}
TreeSet泛型类定义的泛型标识一样，那么也就是这个E所代表的具体数据类型和创建TreeSet对象的数据类型一致，如：TreeSet<String> treeSet = new TreeSet<>();那么此时要传入一个 Comparator 就只能是String或String的父类
1
2
3
4
5
6

类型通配符上下限例子：

package com.ceshi.jichu.generic;


import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

/**
 * @version 1.0
 * @Description 测试类型通配符上下限
 */
public class TestWildcard {

    public static void main(String[] args) {
        List<Tree> treeList = new ArrayList<>();
        List<Branch> branchList = new ArrayList<>();
        List<Leaf> leafList = new ArrayList<>();
        //测试类型通配符上限限制的入参数据类型
        test1(treeList);
        test1(branchList);
        test1(leafList);
        //测试类型通配符下限限制的入参数据类型
        test2(treeList);
        test2(branchList);
        test2(leafList);
    }

    /**
     * 类型通配符上限
     * @param list
     */
    public static void test1(List<? extends Branch> list){
        for (Branch branch : list) {
            //遍历元素时全部用Branch来接收，也就是使用类型通配符的上限数据类型来接收（因为真实的元素要么是子类要么就是Branch）
            System.out.println("遍历上限限制泛型类型元素："+branch);
        }
        Tree tree = new Tree();
        Branch branch = new Branch();
        Leaf leaf = new Leaf();
        //最高Branch类，那么父类的元素肯定不能添加
        list.add(tree);
        //由于不知道具体的元素数据类型，那么添加会报错
        list.add(branch);
        list.add(leaf);
    }

    /**
     * 类型通配符下限
     * @param list
     */
    public static void test2(List<? super Branch> list){
        for (Object o : list) {
            //遍历元素时全部用Object来接收，也就是使用Java最顶级的父类数据类型来接收（因为真实的元素是Branch或Branch的父类而Branch的父类不知道会定义什么类型，所以统一Object来接收）
            System.out.println("遍历下限限制泛型类型元素："+o);
        }
        Tree tree = new Tree();
        Branch branch = new Branch();
        Leaf leaf = new Leaf();
        list.add(tree);
        //下限约束可以新增本身及子类类型的元素，但不能新增父类类型的元素，因为真实的元素至少是Branch级别的，那么Branch及其子类是可以采用Branch及其父类接收的，但不能确定究竟是哪个父类
        //所以Branch的父类类型元素不能新增，虽然可以添加本身及子类，但也只是编译不报错，运行时List里面只能是具体的某个数据类型，所以运行时可能会报错
        list.add(branch);
        list.add(leaf);
    }

}

/**
 * 树类，父类
 */
class Tree{

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Tree{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 树枝类，本类
 */
class Branch extends Tree {

}

/**
 * 树叶类，子类
 */
class Leaf extends Branch{

}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

6、类型擦除

泛型是jdk1.5之后才引入的概念，在这之前是没有泛型的，而泛型代码能够很好的和之前代码兼容则因为泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，这一特性被称之为类型擦除（也就是说写代码的时候代码中有泛型的信息，并且编译时也有这些泛型信息，但是当泛型信息所涉及的类、接口、方法等一旦被加载那么这个类在堆内存中的Class对象里面就没有泛型信息了，已经使用其他的具体数据类型做了泛型替代也就是将泛型相关信息做了擦除）。

类型擦除情况：
a、无限制类型擦除（对泛型没有约束，那么替换为Object类型）

b、有限制类型擦除（对泛型有约束，extends是上限约束，那么就将泛型替换为上限类型）

c、擦除方法中类型定义的参数（和b一样extends约束替换为上限类型，如果没有extends上限限制，那么和a一样使用Object类型替换）

d、桥接方法（也就是说生成的实现类的Class对象除了类中本来有的泛型接口的实现方法，还有一个Object返回类型的同名称实现方法）

例子：

package com.database.pool.testpool.enumtest;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;

/**
 * 测试类型擦除，测试无限制和有限制
 */
public class TestType<T,E extends Number> implements TestBridging<Integer>{

    private T t;

    private E e;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }

    private <T extends List> T show1(T t){
        return t;
    }

    @Override
    public Integer info() {
        return null;
    }
}

/**
 * 接口用于测试桥接方法
 * @param 
 */
interface TestBridging<T>{
    T info();
}


/**
 * 通过读取对象的Class对象信息获取相关类型进行类型擦除验证
 */
class TestClear{
    public static void main(String[] args) {
        TestType<String,Integer> testType = new TestType<>();
        Class<? extends TestType> aClass = testType.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("字段名称："+declaredField.getName()+" 字段类型："+declaredField.getType());
        }
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("方法名称："+declaredMethod.getName()+" 方法返回值类型："+declaredMethod.getReturnType());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

7、泛型数组定义

约束：可以声明带泛型的数组引用，但不能直接创建带泛型的数组对象（也就是可以定义泛型类型的数组变量，但不能直接给这个泛型类型的数组变量创建带有泛型数据类型的数组对象，不论是Java原生的泛型类型的数组还是自定义泛型类型的数组都不能直接创建泛型数据类型的数组只能创建数组变量）

以ArrayList为例：

比如：ArrayList<String>[] arrayList = new ArrayList<String>()[3]
申明arrayList这个变量是可以的，但是后面的 new ArrayList<String>()[3]会报错，不能直接创建带有泛型数据类型的数组对象，因为泛型指定的类型会在加载时做类型擦除，那么就可能会把泛型替换为Object类型，而数组的元素类型则是明确指定的数据类型，这两种情况是不兼容的

T[] t = new T[5]   这种方式会报错
但申明泛型数组变量是可以的：T[] t = null;
1
2
3
4
5

两种方式定义：
a、定义泛型数组变量时，直接创建泛型数组对象 （虽然也是直接创建泛型数组对象，但没有带泛型数据类型参数）

比如上面的示例正确定义方式：
ArrayList<String>[] arrayList = new ArrayList[3];在创建数组对象时不指定泛型的数据类型即可，但由于前面定义变量时为String类型，因此这个数组中添加元素时必须是ArrayList<String>类型
1
2

b、通过 java.lang.reflect.Array的newInstance(Class,int) 方法创建T[]数组（泛型数组）

两种方式示例：

package com.ceshi.jichu.generic;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * 测试泛型数组，Java原生泛型类类型数组和自定义泛型类类型数组，这里以ArrayList为例
 * ArrayList的定义是public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable，是泛型定义的
 * 那么在定义ArrayList的时候需要指定具体的数据类型加载时会发生类型擦除，数组也是需要在定义时指定元素具体的数据类型，一旦发生类型擦除则可能是Object等类型那么和数组的定义数据类型不兼容
 * 因此直接创建泛型类类型的数组报错会报错，那么以下两种方式创建泛型数组
 */
public class TestArray {

    public static void main(String[] args) {
        //正常数组的定义类似下面这种：
        Integer[] integers = new Integer[5];
        //那么如果是泛型的数组应当怎么定义呢？
        //第一种方式创建变量时直接定义数组对象方式
        //ArrayList[] arrayList = new ArrayList()[3];直接创建泛型类类型的数组报错
        ArrayList<String>[] arrayList = new ArrayList[3];//去掉泛型数据类型创建就可以
        Set<String>[] sets = new Set[5];//去掉泛型数据类型创建就可以
        //创建数组元素
        ArrayList<String> stringArrayList = new ArrayList<>();
        stringArrayList.add("aaaa");
        arrayList[0] = stringArrayList;
        System.out.println("第一种方式定义数组变量时直接创建泛型类类型数组对象获取元素结果：" + arrayList[0].get(0));

        //第二种方式，针对自定义泛型类创建自定义泛型类类型数组，方式具体创建方式在ArrayType类的构造器中，这是只针对泛型类内部定义泛型类型数组的创建方式
        ArrayType<String> arrayType = new ArrayType<>(String.class, 5);
        arrayType.set("bbbb", 0);
        System.out.println("第二种方式newInstance创建泛型类内部泛型数组获取元素结果：" + arrayType.get(0));
        String[] array = arrayType.getArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println("读取泛型类内部数组每个元素：" + " 元素下标：" + i + " 元素值：" + array[i]);
        }

        //第一、二种方式结合，针对自定义泛型类内部有泛型类型的数组且将泛型类本身也作为泛型数组定义
        ArrayType<String>[] arrayTypes = new ArrayType[5];//第一种方式直接创建泛型类类型数组对象
        arrayTypes[0] = arrayType;
        System.out.println("两种方式结合通过第一种方式直接创建泛型类类型数组并获取内部定义的泛型类型数组获取元素结果：" + arrayTypes[0].get(0));

        //直接创建泛型数组---推荐使用泛型集合替代泛型数组
        List<ArrayType<String>> list = new ArrayList<>();
        list.add(arrayType);
    }

}

/**
 * 第二种方式创建数组
 *
 * @param 
 */
class ArrayType<T> {

    //泛型数组定义变量，另外做创建泛型数组对象操作
    public T[] array;

    //泛型集合可以直接定义变量并创建对象，推荐使用泛型集合替代泛型数组
    private List<T> list = new ArrayList<>();

    //使用正常的数组定义方式，创建泛型数组对象会报错
    //T[] t = new T[5];

    //tClass也就是使用ArrayType时定义的具体数据类型的Class对象，length是数组的长度
    public ArrayType(Class<T> tClass, int length) {
        //第二种方式创建泛型数组，Array.newInstance
        array = (T[]) Array.newInstance(tClass, length);
    }

    public void set(T param, int index) {
        array[index] = param;
    }

    public T get(int index) {
        return array[index];
    }

    public T[] getArray() {
        return array;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

注意：一般使用泛型时如果有需要使用泛型数组那么一般用泛型集合比如List、Set、Map等根据情况来代替泛型数组，因为集合比数组拥有更多功能且可以直接创建泛型集合对象。