java 泛型

什么是泛型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

为什么要使用泛型

举个例子

public void testGeneric(){
        List arrayList = new ArrayList();
        arrayList.add("aaaa");
        arrayList.add(100);

        for(int i = 0; i< arrayList.size();i++){
            String item = (String)arrayList.get(i);
            System.out.println("泛型测试,item = " + item);
        }
    }

输出

泛型测试,item = aaaa

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

毫无疑问,在item试图获取第二个元素是报错了。
原因是ArrayList可以存放任何类型的数据，但是在使用时却都以string类型数据来使用。为了放着这样的情况，我们可以使用泛型。

我们尝试修改我们的代码

public void testGeneric(){
        List<String> arrayList = new ArrayList<String>();
        arrayList.add("aaaa");
        arrayList.add(100);

        for(int i = 0; i< arrayList.size();i++){
            String item = (String)arrayList.get(i);
            System.out.println("泛型测试,item = " + item);
        }
    }

可以看到在编译阶段编译器就能捕获类型问题，但是在java中泛型是伪泛型，因为在编译期间，java会进行类型擦除，所有的编译信息都会被擦除，有兴趣的可以去看一下这一篇文章：java 泛型进阶

如何使用泛型

泛型大致可以分为三种使用方式。

• 泛型类
• 泛型接口
• 泛型方法

1.泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化时，泛型必须制定类型，T必须为具体类型
class Generic<T>{
    private T key;

    public Generic(T key){
        this.key = key;
    }

    public T getKey() {
        return key;
    }
}

实例化

void gengrateGeneric(){
    //泛型传入类型必须是类的类型，不能传入基本数据类型，如果需要使用基本数据类型，要用包装类，如int->Integer
        Generic<Integer> generic= new Generic<Integer>(123);
    }

2.泛型接口

声明泛型接口

interface Generator<T> {
    public T method();
}

实现泛型接口，不指定类型

class GeneratorImpl1<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}

实现泛型接口，指定类型

class GeneratorImpl2<T> implements Generator<String>{
    @Override
    public String method() {
        return "hello";
    }
}

3.泛型方法

//这里将方法声明在class Generic<T>中
public static <E> void printArray( E[] inputArray )
    {
        for ( E element : inputArray ){
            System.out.printf( "%s ", element );
        }
        System.out.println();
    }

使用泛型方法

public void testGeneric3(){
        Integer[] intArray = { 1, 2, 3 };
        String[] stringArray = { "Hello", "World" };
        Generic<Integer> generic = new Generic<Integer>(1);
        // Generic<T>中的T和public static <E>互不影响，可以理解成是两个类型
        generic.printArray(intArray);
        generic.printArray(stringArray);
    }

易错点

//这是一个泛型方法吗？
public void printArray(T key)
    {
        System.out.println(key);
    }

这不是一个泛型方法，实际上T在class Generic实例化的时候后就已经确定，而printArray是类 Generic的成员函数，因此在调用函数时，T的类型就已经确定。

常用通配符

常用的通配符为： T，E，K，V，？

？ 表示不确定的 java 类型
T (type) 表示具体的一个java类型
K V (key value) 分别代表java键值中的Key Value
E (element) 代表Element

？ 无界通配符

为什么要使用通配符而不是简单的泛型呢？

举个例子

static int countLegs (List<? extends Animal > animals ) {
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

static int countLegs1 (List< Animal > animals ){
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
 	// 不会报错
    countLegs( dogs );
	// 报错
    countLegs1(dogs);
}

所以，对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?> ），表示可以持有任何类型。像 countLegs 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

上界通配符 < ? extends E>

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 E 或者 E 的子类，编译不成功
• 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

类型参数列表中如果有多个类型参数上限，用逗号分开

下界通配符 < ? super E>

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

如果你只想简单的使用泛型，这些知识就足够了，如果你想更深的了解java泛型可以看看这篇文章java 泛型进阶