java泛型

一、概念

1. 泛型：泛型是Java SE 1.5的新特性，即“参数化类型”。顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）

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

3. 为什么使用泛型

    List list = new ArrayList();
    list.add("qqyumidi");
    list.add("corn");
    list.add(100);

    for (int i = 0; i < list.size(); i++) {
        String name = (String) list.get(i); // 这里会报错，因为list添加的时候默认是Object类型，可以任意添加但是取出来的时候就无法确定类型了
        System.out.println("name:" + name);
    }

4. 在java中是”不能创建一个确切的泛型类型的数组”的（但List<?>[] ls = new ArrayList<?>[10]是可以的），数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的   

---

二、特性

1. Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段

2. 泛型擦除具体来说就是在编译成字节码时首先进行类型检查，接着进行类型擦除（即所有类型参数都用他们的限定类型替换，包括类、变量和方法）

3. 在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box），当然，在逻辑上我们可以理解成多个不同的泛型类型

4. 泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型

5. 代码示例

	/**
     * 测试不同的泛型实参，类型是否相同
     * */
    public void testEquals(){
        List<String> stringList = new ArrayList<String>();
        List<Integer> integerList = new ArrayList<Integer>();
        Boolean flag = stringList.getClass().equals(integerList.getClass());
        System.out.println("flag=" + flag); // 结果为ture
    }

---

三、泛型的使用

1. 泛型类

1）概念

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

	（2）泛型的类型参数只能是类类型，不能是简单类型

	（3）不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错

		if(ex_num instanceof Generic<Number>){ }

2）代码示例		

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

	    // key这个成员变量的类型为T,T的类型由外部指定  
	    private T key;

		// 泛型构造方法形参key的类型也为T，T的类型由外部指定
	    public Generic(T key) { 
	        this.key = key;
	    }

	    // 泛型方法getKey的返回值类型为T，T的类型由外部指定
	    public T getKey(){ 
	        return key;
	    }
	}

2. 泛型接口

1）泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中

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

	public class FruitGenerator<T> implements Generator<T>{

	    @Override
	    public T next(){
	        return null;
	    }
	}

	如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"

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

	public class FruitGenerator implements Generator<String>{

	    @Override
	    public String next(){
	        return null;
	    }
	}

3. 泛型方法

1）概念

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

	（2）如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法，因为静态方法无法访问类上定义的泛型

2）泛型方法介绍

	public <T> T testMethod(Class<T> tClass) throws IllegalAccessException, InstantiationException {
        T instance = tClass.newInstance();
        return instance;
    }	

	（1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法

	（2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法（这是判断是否为泛型方法的重要标志）

	（3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T

	（4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

3）特例介绍

	（1）在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同	

		public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型

    （2）在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型   
    
    	public <T> void show_2(T t){
            System.out.println(t.toString());
        } 

 4）泛型方法与可变参数      
 
 	public <T> void printMsg( T... args){
	    for(T t : args){
	        Log.d("泛型测试","t is " + t);
	    }
	}
	printMsg("111",222,"aaaa","2323.4",55.55); 

---

四、类型通配符

1. 类型通配符一般是使用 ? 代替具体的类型实参

2. 注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类, 和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型

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

4. 我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类

	1）上界 		   <? extends List>           只准传入某种类型的子类，适用于只读情况下

	2）下界         <？ super List>            只准传入某种类型的父类，适用于只写情况下

	public class Collections {
	    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
	        for (int i=0; i<src.size(); i++)
	            dest.set(i, src.get(i));
	    }
	}

5. 在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加	

	public <T extends Number> T showKeyName(Generic<T> container){
	    System.out.println("container key :" + container.getKey());
	    T test = container.getKey();
	    return test;
	}

	如写成，public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"

---

参考网址

Java总结篇系列：Java泛型

java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一

Java泛型详解（待）

注：文章是经过参考其他的文章然后自己整理出来的，有可能是小部分参考，也有可能是大部分参考，但绝对不是直接转载，觉得侵权了我会删，我只是把这个用于自己的笔记，顺便整理下知识的同时，能帮到一部分人。
ps : 有错误的还望各位大佬指正,小弟不胜感激