Java泛型分析
泛型是JAVA中应用频率很高的一个知识点，广泛引用在面向对象编程，各种框架的搭建等方面。以下是这篇博客的 大纲。
一.什么是泛型以及为什么要使用泛型
二.泛型的使用(泛型类，泛型接口，泛型方法，边界符，通配符，类型擦除)
三.泛型的使用场景
四.泛型的注意事项
一.什么是泛型以及为什么要使用泛型
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
泛型再实际生产中应用很多，比如列举出List接口中的一部分代码如下，就用到了很多泛型的概念。
public interface List extends Collection {
Iterator iterator();
T[] toArray(T[] a);
boolean add(E e);
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
ListIterator listIterator();
ListIterator listIterator(int index);
} 在jdk1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是必须要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常(ClassCastException)，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
二.泛型的使用(泛型类，泛型接口，泛型方法，通配符，边界符，类型擦除)
2.1泛型类
2.1.1泛型类的最基本写法
class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
private 泛型标识 /*（成员变量类型）*/ var;
.....
}
}
2.1.2测试类
//这里的T即Type的首字母，代表类型的意思，常用的还有E（element）、K（key）、V（value）等。当然不用这些字母指代类型参数也完全可以。
//在实例化泛型类时，必须指定T的具体类型
public class Test {
//param这个成员变量的类型为T,T的类型由外部指定
private T param;
//泛型构造方法形参key的类型也为T，T的类型由外部指定
public Test(T param) {
this.param = param;
}
//泛型方法getParam的返回值类型为T，T的类型由外部指定
public T getParam() {
return param;
}
} //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Test testInteger = new Test(123);
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Test testString = new Test("param");
2.1.3注意事项
1)泛型的类型参数只能是类类型，不能是简单类型。
2)不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
if(test_num instanceof Test
}
2.2泛型接口
泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中。注意，在声明泛型接口实现类的时候，分为将泛型的声明传入实现类与不传入实现类
//定义一个泛型接口
public interface MyCollection {
public T next();
} 2.2.1如果将泛型声明带入实现类，如下
class Test implements MyCollection{
@Override
public T next() {
return null;
}
} 2.2.2如果不带入泛型声明，那么这里就需要声明泛型对应的实际参数类型，比如下面这样
public class Test implements MyCollection {
private String[] testCollection = new String[]{aaa", "bbb", "ccc"};
@Override
public String next() {
Random rd= new Random();
return testCollection[rd.nextInt(3)];
}
}
2.3泛型方法
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。
2.3.1泛型方法的使用
如下列出的部分List的源码里面的部分抽象方法，如果参数或者返回值是该泛型接口或者泛型类中存在的，比如List中的E，那么方法的访问修饰符与返回类型之间就不需要加
public interface List extends Collection {
Iterator iterator();
T[] toArray(T[] a);
boolean add(E e);
boolean containsAll(Collection c);
E set(int index, E element);
E remove(int index);
ListIterator listIterator();
ListIterator listIterator(int index);
} 泛型方法的基本语法如下：
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这个泛型类做形参而已。
public void showKeyValue1(Generic 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) {
}
} 2.3.2静态泛型方法注意事项
静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。如下
public class Test {
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void insert(T t){..},此时编译器会提示错误信息：
"Testcannot be refrenced from static context"
*/
public static void insert(T t){
}
} 2.3.3泛型方法总结
泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。
2.4通配符
当具体类型不确定的时候，这个通配符就是?；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用?通配符来表未知类型。
例如ClassclassType = Class.forName("java.lang.String");
Class
Class
Class是个通配泛型，?可以代表任何类型
比如：Class
2.5边界符
2.5.1泛型的上下边界说明
在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。形如””的代码叫做通配符的子类型限定(上边界)。与之对应的还有通配符的超类型限定(下边界)，格式是这样的：。
2.5.2边界符的应用
拿个自己项目中的某个方法来说
public List extractData(){
}
这样返回的List里面的元素类型只能是继承自SourceBean的了。
再来一个泛型方法的例子：
//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下边界，即在泛型声明的时候添加
//public T test(Test args)，编译器会报错："Unexpected bound"
public T test(Test args){
} 通过上面的两个例子可以看出：泛型的上下边界添加，必须与泛型的声明在一起 。
2.6类型擦除
类型擦除相关的，具体可以看这篇博客Java泛型类型擦除部分
三.泛型的使用场景
java中的泛型这一概念提出的目的，其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
一提到泛型，相信大家用到最多的就是在集合中，其实，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。
泛型的本质就是将数据类型参数化，可以将泛型定义在接口,类和方法上。简单举几个场景：
不想写多个重载函数的场景。
约束对象类型的场景，可以定义边界（T extends ...），如JDK集合List，Set。
用户希望返回他自定义类型的返回值场景，如Json返回Java bean。
在用反射的应用中，也经常会用到泛型，如Class
对网页，对资源的分析，返回场景，一般都有泛型。
其实泛型的应用还是很广的，一句话就是希望将数据类型参数化的地方，就可以用它
写框加和抽象必备技能：在写框架或者工具类的时候需要用的，泛型的类型检查可以避免一些错误或者运行时类型检查，可以少些instanceof 判断
JDK集合，Future
四.泛型的注意事项
1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends super等关键字，例如
5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName(Java.lang.String);
6、不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
7、不能创建一个确切的泛型类型的数组。