1、什么是泛型

所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参将在声明变量、创建对象、调用方法时动态的指定。

2、为什么要使用泛型

先看下这个例子：

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("字符串");
        list.add(122);

        for (int i = 0; i <list.size() ; i++) {
            String str = (String) list.get(i);
            System.out.println(str);
        }
    }

我们运行上面的代码，就会抛出如下的异常。

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

我们知道ArrayList可以存放任意对象类型，我们先向list中存放了一个String类型的数据，接着又存放了一个Integer类型的数据，在使用的时候就抛出了异常。为了解决类似这样的问题，泛型应运而出。

对于上面的例子的例子做如下改造：

List<String> list = new ArrayList();
list.add("字符串");
list.add(122);  // add(java.long.String) in list connot be applied to (int)

当我们使用泛型后，再存放Integer类型的数据，就会直接报错，这就是再编译时检测，而上面的是在运行时才去检测的，这样就能很大程度的解决程序员犯错了。

与非泛型代码相比，使用泛型的代码具有许多优点：

• 在编译时进行更强的类型检查。Java编译器将强类型检查应用于泛型代码，并在代码违反类型安全时发出错误。修复编译时错误比修复运行时错误更容易，运行时错误很难找到。
• 消除类型转换。 当使用的时候不需要强制转换类型。
• 使程序员能够实现泛型算法。 通过使用泛型，程序员可以实现泛型算法，这些算法可以处理不同类型的集合，可以自定义，并且类型安全且易于阅读。

3、泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

3.1、泛型类

泛型类型用于类的定义中，就称之为泛型类，泛型类的基本写法如下：

public class Generic<T> {}
public class Generic<T1,T2,...,Tn> {}

在类名之后，类型参数部分由尖括号<>分隔。它指定了类型参数（也称为类型变量）T，当然了也可以定义多个参数。
下面看一个例子：

/**
 * 在实例化泛型类时，必须指定T的具体类型
 * @param <T> 此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
 */
public class Generic<T> {
    //key这个成员变量的类型为T,T的类型由外部指定
    private T key;

    //泛型构造方法形参key的类型也为T，T的类型由外部指定
    //这里需要注意的是构造器名是Generic ，而不是Generic<T>。
    public Generic(T key) {
        this.key = key;
    }
    
    //泛型方法getKey的返回值类型为T，T的类型由外部指定
    public T getKey() {
        return key;
    }
}

运行下面代码：

Generic<String> genericStr = new Generic<>("测试泛型类");
Generic<Integer> genericInt = new Generic<>(100);
System.out.println("泛型测试---》"+genericStr.getKey());
System.out.println("泛型测试---》"+genericInt.getKey());

// 运行结果如下：
// 泛型测试---》测试泛型类
// 泛型测试---》100

对于多种类型的参数其实是一样的做法，比如我们熟悉的HashMap就是多种类型参数:

//HashMap的源码
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable {...}
//HashMap的使用
Map<String,String> map = new HashMap<>();

3.2、泛型接口

其实泛型接口和泛型类的定义使用基本上是一样的。模拟我们常用的list接口来演示下泛型接口

//定义一个泛型接口
public interface MyList<T> {
    public T add(T t);
}

当实现泛型接口的类，未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中

public class MyArrayList<T> implements MyList<T> {
    @Override
    public T add(T t) {
        return t;
    }

    public static void main(String[] args) {
        MyList<String> list = new MyArrayList<>();
        list.add("aaaa");
        MyList<Integer> list1 = new MyArrayList<>();
        list1.add(0);
    }
}

在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型。

public class MyArrayList implements MyList<String> {
    @Override
    public String add(String s) {
        return s;
    }
}

3.3、泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型。基本写法如下：

/**
 * @param <T>  这个<T>非常重要，可以理解为声明此方法为泛型方法。
 *           只有声明了<T>的方法才是泛型方法。泛型类中的使用了泛型的成员方法并不是泛型方法。
 */
public <T> void Generic(T t) {}

下面看下具体例子看下泛型方法的实现：

public class TestGeneric {

    public <T> void getKey(T t) {
        System.out.println("测试泛型方法---》" +t);
    }

    public static void main(String[] args) {
        TestGeneric testGeneric = new TestGeneric();
        testGeneric.getKey("字符串");
        testGeneric.getKey(0);
    }
}

//输出结果
//测试泛型方法---》字符串
//测试泛型方法---》0

3.4、泛型通配符

称为通配符的问号(?)表示未知类型。通配符可以在多种情况下使用：作为参数，字段或局部变量的类型；有时作为返回类。通配符从不用作泛型方法调用，泛型类实例创建或超类型的类型参数。下面详细地讨论通配符，包括上界通配符，下界通配符和通配符捕获。

下面我们看一个例子：

    List<?> list = new ArrayList<String>();
    //我们可以正常获取list中的元素，不会引起编译错误
    Object object = list.get(0);
    //调用add方法会引起编译错误
    list.add("字符串");

这种带通配符的 List仅表示它是各种泛型List的父类，并不能把元素添加到其中，否则会引起编译错误。因为程序无法确定list集合中的元素类型，所以不能向其中添加对象，而程序第哦啊用get()方法来返回List<?>集合指定索引处的元素，其返回值是一个未知类型，但肯定是一个Object，因此返回值赋给一个Object类型的变量是可以的。

3.4.1、上界通配符

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型，要声明上界通配符，请使用通配符(?)，然后使用extends关键字

public static void main(String[] args) {
    List<Integer> integers = new ArrayList<>();
    integers.add(1);
    List<Double> doubles = new ArrayList<>();
    doubles.add(2.0d);
    List<String> strings = new ArrayList<>();
    strings.add("通配符上界");

    print(integers);
    print(doubles);
    //编译直接报错
    //print(strings);
}
public static void print(List<? extends Number> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

3.4.2、下界通配符

通配符将未知类型限制为特定类型,下界通配符表示为通配符(?)，后跟`super关键字

    public static void main(String[] args) {
        List<Integer> integers = new ArrayList<>();
        integers.add(0);
        List<Number> numbers = new ArrayList<>();
        numbers.add(123);
        numbers.add(10.0d);
        List<Double> doubles = new ArrayList<>();
        doubles.add(0.2d);
        print(integers);
        print(numbers);
        //编译报错
        //print(doubles);
    }

    public static void print(List<? super Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

上面我们可以看到定义了下界Integer后，我们就无法在使用Double类型了，只能使用Integer类型、Number类型、Object类型了。

4、泛型总结

使用泛型的时候，要考虑泛型的限制:

• 无法实例化具有基本类型的泛型类型
• 无法创建类型参数的实例
• 无法声明类型为类型参数的静态字段
• 无法创建参数化类型的数组
• 无法创建捕获或抛出参数化类型的对象
• 无法重载每个重载的形式参数类型都擦除为相同原始（raw）类型的方法。
• 无法将Casts或instanceof与参数化类型一起使用

泛型，我们用到最多的可能就是集合了。在实际开发中，我们合理的使用泛型可以简化我们的开发，提高为我们的开发效率。