泛型是什么

泛型类和泛型方法有类型参数，这使得它们可以准确地描述用特定类型实例化时会发生什么。在没有泛型类之前，程序员必须使用Objct编写适用于多种类型的代码。这很烦琐，也很不安全。

随着泛型的引入，Java有了一个表述能力很强的类型系统，允许设计者详细地描述变量和方法的类型要如何变化。

泛型程序设计（generic programming)意味着编写的代码可以对多种不同类型的对象重用。

下面的代码就是没有使用泛型的集合

        // 该集合我想要存放int类型的数据
        List list = new ArrayList();
        list.add(100); // 加入int
        list.add("hello"); // 放入字符串
        list.add(true); // 放入布尔类型

        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i); // 获取到的值是Object
            int k = (Integer) o; // 强制转换
            System.out.println(k);
        }

可以发现上面的代码在集合中什么都能放入，并没有进行类型检查。而且在获取集合元素的时候返回的是Object，我们还要进行强转。运行看看一下，结果如下

可以发现报错了，这就是因为在集合里面存放了其他类型的数据。集合不使用泛型那么就是存储的Object数据，我们将其转换为Integer所以就出现了ClassCastException。现在就已经可以发现java的弊端了，没有一个参数检查机制，代码极不安全，泛型就是用来弥补这点的。看下面泛型代码。

        List<Integer> list = new ArrayList<>();
        list.add(100);
        // list.add("hello") // 类型检查，编译都不能通过
        // list.add(true) // 编译不能通过

        for (int i = 0; i < list.size(); i++) {
            Integer k = list.get(i); // 返回的直接就是Integer
            System.out.println(k);
        }

我们可以在<>里面指定要存储的元素类型，这就是泛型，使用泛型后在往集合添加元素的时候就会进行检查，如果不是指定的元素，那么就会出现编译错误，程序编译都不能通过。使用泛型后，集合返回的就直接是指定的类型，也就不需要强转类型转换了。

通过上面的代码，大家应该初步体会到了泛型的好处和强大，下面就来学习如何自定义泛型类和泛型方法

自定义泛型类

泛型类就是有一个或多个类型变量的类。下面我就通过MyTool这个类来进行说明

public class MyTool<T> {
    private T info;

    public MyTool(T info) {
        this.info = info;
    }

    public T getInfo() {
        return info;
    }
}

上面的MyTool这个类就是一个泛型类，在这个类中引入了一个类型变量T，用尖括号(<>)括起来的，放在类名后面。这个T就是我们在创建对象的时候指定的。

MyTool<String> myTool = new MyTool<>("这是自定义泛型类");

我们在尖括号(<>)里面写的类型就会成为T的类型，这里<>里面写的类型为String，那么T就是代表String。

对于 new MyTool<>(“这是自定义泛型类”) 这部分代码，我们在构造器中传入了一个字符串，原因就是T代表的是字符串，而我们的构造器中要传入的内容就是T，也就是字符串，没有问题。

对于在上面的MyTool类，由于我们指定的T为String，所以可以将其理解为就是一个普通类，如下

public class MyTool {
    private String info;

    public MyTool(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }
}

现在，对于泛型类的基本使用基本就说完了，我们自定义泛型类就是在类后面加上<>，在这里面写上类型变量，然后再类中使用这个类型变量即可。对于类型变量，我们一般都是使用大写字母，而且很简短，在Java库使用变量E表示集合的元素类型，K和V分别表示表的键和值的类型。T(必要时还可以用相邻的字母U和S)表示“任意类型”。
注意：对于类型变量并不是一定为一个大小字母，只不过是约定俗成罢了，例如，下面代码也是正确的

public class TypeParameter<AAAAA> {
    private AAAAA aaaaa;
}

但是还是建议大家就写为一个大写字母，遵顼java规范。

对于泛型类，我们在<>里面可以写上多个类型变量，使用逗号分隔，例如下面代码

public class MulTypeParam<K,V> {
}

这样定义以后，我们在使用这个对象就要在<>里面传入2个变量

MulTypeParam<Integer, String> typeParam = new MulTypeParam<>();

这样写的话，那么K就代表Integer类型，V就代表String类型

自定义泛型方法

上面说的是自定义泛型类，现在来讲一下泛型方法。下面就是一个简单示例

public class SimpleGenericMethod {

    public static <T> T getMiddleInfo(T... ts) {
        int index = ts.length / 2;
        return ts[index];
    }
}

对于泛型方法，我们并不需要放在泛型类中，放在普通类中也没有问题。对于泛型方法，我们将类型变量放在<>中，<>放在返回值前面，修饰符后面。

上面的方法就是接收T类型的参数，然后返回一个T。下面就是对泛型方法的调用

String middleInfo = SimpleGenericMethod.<String>getMiddleInfo("java", "python", "c", "c++", "php");

可以发现在泛型方法中，我们是在方法前面添加了一个<>，然后指定了类型。但是对于大多数情况下，<>都可以省略，编译器会根据传入的参数推断出类型。
在几乎所有情况下，泛型方法的类型推导都可以正常工作。下面写法就是省略<>写法

String middleInfo = SimpleGenericMethod.getMiddleInfo("java", "python", "c", "c++", "php");

类型推导的原则就是寻找参数的公共父类。

对于泛型方法，我们也可以在<>里面定义多个类型变量

    public static <X, Y> Y towTypeParam(X x, Y y) {
        return y;
    }

上面代码就表示传入一个X类型的变量和一个Y类型的变量，然后返回一个Y类型变量。

类型变量的限定

在很多的情况下，我们使用泛型时，并不是上面类型的参数都能传入，而是有所现在，比如是某个类的子类，或者必须实现某个接口。下面就来说明如何完成这些对泛型的限制。

先来看一个例子

public interface Eat {
    
    void eat();
}

public class TypeParamRestrict {

    public static <T> void eats(T... ts) {
        for (T t : ts) {
            ((Eat) t).eat();
        }
    }
}

看看上面这个eats有上面问题呢？可以发现，我们并没有检查T类型的参数，T不一定是一个实现接口的Eat的对象，这样调用就会出错，所以，我们应该对T进行限制，写法如下

public class TypeParamRestrict {

    public static <T extends Eat> void eats(T... ts) {
        for (T t : ts) {
            t.eat();
        }
    }
}

T extends Eat就表示传入的类型必须是为Eat，或者Eat的子类。这里使用extends可能有人很疑惑，Eat不是接口吗？为什么是使用extends，事实上，这里选择extends是为了更接近子类的概念，对于接口和类都是使用extends。使用了限定符后，就不需要进行类型转换了，T已经是Eat的子类，所以可以直接掉用eat方法。

上面这样写了以后，再调用eats这个方法，参数就必须是实现Eat接口的类。

对于一个类型变量，我们还可以有多个限定，例如下面代码

<T extends Eat & Serializable>

使用&就表示必须且的意思，表示T要同时实现Eat和Serializable接口。
注意：对于限定，可以有多个接口，但是只能有一个是类，而且必须写为第一个限定。为什么只能有一个限定类，因为java是单继承的。类型变量不可能同时实现多个类

总结

泛型程序设计（generic programming)就是意味着编写的代码可以对多种不同类型的对象重用。

关于泛型的更多知识，参考以下内容

泛型程序设计基础
类型擦除、桥方法、泛型代码和虚拟机
泛型的限制及其继承规则
泛型的通配符(extends,super,?)