• <strong>
  
• <strong>
  

概述

Java泛型（generics）是JDK 5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许程序员在编译时监测非法的类型。使用泛型机制编写的程序代码要比那些杂乱地使用Object变量，然后再进行强制类型转换的代码具有更好的安全性和可读性。泛型对于集合类尤其有用，例如，ArrayList就是一个无处不在的集合类。

泛型的本质是参数化类型，也就是所操作的数据类型被指定为一个参数。

什么是泛型

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

• 把类型当作是参数一样传递
• 只能是引用类型

相关术语：

• ArrayList< E >中的E称为类型参数变量
• ArrayList< Integer >中的Integer称为实际类型参数
• 整个称为ArrayList< E >泛型类型
• 整个ArrayList< Integer >称为参数化的类型ParameterizedType

一个栗子

一个被举了无数次的例子：

<code>List arrayList = new ArrayList();arrayList.add("六脉神剑");arrayList.add(100);for(int i = 0; i< arrayList.size();i++){    String item = (String)arrayList.get(i);    Log.d("泛型测试","item = " + item);}/<code>

毫无疑问，程序的运行结果会以崩溃结束：

<code>java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String/<code>

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

<code>List<string> arrayList = new ArrayList<string>();...//arrayList.add(100); 在编译阶段，编译器就会报错/<string>/<string>/<code>

特性

泛型只在编译阶段有效。看下面的代码：

<code>List<string> stringArrayList = new ArrayList<string>();List<integer> integerArrayList = new ArrayList<integer>();Class classStringArrayList = stringArrayList.getClass();Class classIntegerArrayList = integerArrayList.getClass();if(classStringArrayList.equals(classIntegerArrayList)){    Log.d("泛型测试","类型相同");}/<integer>/<integer>/<string>/<string>/<code>

输出结果：D/泛型测试: 类型相同。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

泛型基础

泛型有三种使用方式，分别为：

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

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类的最基本写法（这么看可能会有点晕，会在下面的例子中详解）：

<code>class 类名称 {  private 泛型标识 /*（成员变量类型）*/ var;   .....  }}/<code>

一个最普通的泛型类：

<code>//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型//在实例化泛型类时，必须指定T的具体类型public class Generic{     //key这个成员变量的类型为T,T的类型由外部指定      private T key;    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定        this.key = key;    }    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定        return key;    }} 
/<code>

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

<code>    public static void main(String[] args) {        //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型//传入的实参类型需与泛型的类型参数类型相同，即为Integer.        Generic<integer> genericInteger = new Generic<integer>(123456);//传入的实参类型需与泛型的类型参数类型相同，即为String.        Generic<string> genericString = new Generic<string>("key_vlaue");        System.out.println( genericString.getKey());    }/<string>/<string>/<integer>/<integer>/<code>

结果

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：

首先定义一个泛型接口

<code>package com.atguigu.ct.producer.Test;/** * 六脉神剑 * @param  */public interface Generator {    T eat();}/<code>

当实现泛型接口的类，未传入泛型实参时： 由于没有传入具体的参数，所以这个实现接口的类，也必然是泛型类，不然编译不过

<code>package com.atguigu.ct.producer.Test;/** * 六脉神剑 * @param  */public class FruitGenerator implements Generator {    @Override    public T eat() {        return null;    }}/<code>

当实现泛型接口的类，传入泛型实参时：这个时候就不能是泛型类了，因为泛型接口已经明确类型了

<code>package com.atguigu.ct.producer.Test;/** * 六脉神剑 * @param  */public class FruitGenerator implements Generator<string> {    @Override    public String eat() {        return null;    }}/<string>/<code>

类型通配符

我们知道Ingeter是Number的一个子类，同时在特性章节中我们也验证过Generic与Generic实际上是相同的一种基本类型。那么问题来了，在使用Generic作为形参的方法中，能否使用Generic的实例传入呢？在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢？

为了弄清楚这个问题，我们使用Generic这个泛型类继续看下面的例子：

<code>public void showKeyValue1(Generic<number> obj){    Log.d("泛型测试","key value is " + obj.getKey());}/<number>/<code>

<code>Generic<integer> gInteger = new Generic<integer>(123);Generic<number> gNumber = new Generic<number>(456);showKeyValue(gNumber);// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.integer> // cannot be applied to Generic<java.lang.number>// showKeyValue(gInteger);/<java.lang.number>/<java.lang.integer>/<number>/<number>/<integer>/<integer>/<code>

通过提示信息我们可以看到Generic不能被看作为`Generic的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic类型的类，这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型。由此类型通配符应运而生。

我们可以将上面的方法改一下：

<code>public void showKeyValue1(Generic> obj){    Log.d("泛型测试","key value is " + obj.getKey());}/<code>

类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参 。重要说三遍！此处’？’是类型实参，而不是类型形参 ！ 此处’？’是类型实参，而不是类型形参 ！再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

泛型方法

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。

尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

<code>/** * 泛型方法的基本介绍 * @param tClass 传入的泛型实参 * @return T 返回值为T类型 * 说明： *     1）public 与 返回值中间非常重要，可以理解为声明此方法为泛型方法。 *     2）只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。 *     3）表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。 */public  
 T genericMethod(Class tClass)throws InstantiationException ,  IllegalAccessException{        T instance = tClass.newInstance();        return instance;}Object obj = genericMethod(Class.forName("com.test.test"));/<code>

光看上面的例子有的同学可能依然会非常迷糊，我们再通过一个例子，把我泛型方法再总结一下。

<code>public class GenericTest {   //这个类是个泛型类，在上面已经介绍过   public class Generic{             private T key;        public Generic(T key) {            this.key = key;        }        //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。        //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。        //所以在这个方法中才可以继续使用 T 这个泛型。        public T getKey(){            return key;        }        /**         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。        public E setKey(E key){             this.key = keu        }        */    }    /**      * 这才是一个真正的泛型方法。     * 首先在public与返回值之间的必不可少，这表明这是一个泛型方法，并且声明了一个泛型T     * 这个T可以出现在这个泛型方法的任意位置.     * 泛型的数量也可以为任意多个      *    如：public  K showKeyName(Generic container){     *        ...     *        }     */    public  T showKeyName(Generic container){        System.out.println("container key :" + container.getKey());        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。        T test = container.getKey();        return test;    }    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<number>这个泛型类做形参而已。    public void showKeyValue1(Generic<number> obj){        Log.d("泛型测试","key value is " + obj.getKey());    }    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类    public void showKeyValue2(Generic> obj){        Log.d("泛型测试","key value is " + obj.getKey());    }     /**     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "     * 虽然我们声明了 
,也表明了这是一个可以处理泛型的类型的泛型方法。     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。    public  T showKeyName(Generic container){        ...    }      */    /**     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。     * 所以这也不是一个正确的泛型方法声明。    public void showkey(T genericObj){    }    */    public static void main(String[] args) {    }}/<number>/<number>/<code>

再看一个泛型方法和可变参数的例子：

<code>public  void printMsg( T... args){    for(T t : args){        Log.d("泛型测试","t is " + t);    }}/<code>

printMsg("111",222,"aaaa","2323.4",55.55);

泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

<code>public void showKeyValue1(Generic extends Number> obj){    Log.d("泛型测试","key value is " + obj.getKey());/<code>

<code>Generic<string> generic1 = new Generic<string>("11111");Generic<integer> generic2 = new Generic<integer>(2222);Generic<float> generic3 = new Generic<float>(2.4f);Generic<double> generic4 = new Generic<double>(2.56);//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类//showKeyValue1(generic1);showKeyValue1(generic2);showKeyValue1(generic3);showKeyValue1(generic4);/<double>/<double>/<float>/<float>/<integer>/<integer>/<string>/<string>/<code>

再看有个下边界

<code>    super Type>       public TreeSet(Comparator super E> comparator) {        this(new TreeMap<>(comparator));    }/<code>

值得注意的是：无论是设定通配符上限还是下限，都是不能操作与对象有关的方法，只要涉及到了通配符，它的类型都是不确定的！

泛型的应用

最简单 我们的Dao 我的service impl 肯定是用到了的 这样可以封装一些通用的方法了

作者：六脉神剑
链接：https://juejin.im/post/5df1b667f265da3398562739

閱讀更多 追逐仰望星空 的文章

關鍵字: 知识点 程序员 限流