开始之前先说几句废话，公司有个可爱的人事要对刚入职的同事提供java的系统培训，邀我做一个关于泛型的讲解，其实我对泛型了解的也不是很透彻，加上有时候比较忙，就一直在拖着，怎奈我那可爱的同事，又找资料，又找我的。再这样拖着确也于心不忍，于是抽个周末查了些资料，参考网上的资料，猝成此文，不得不说自己真的好久没有写过文章了，感谢我那可爱的同事！下面开始。
Java泛型（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。在没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。如
package com.demo.generice;
public class GenDemo2 {
public static void main(String[] args) {
// 定义类Gen2的一个Integer版本
Gen2 intOb = new Gen2(new Integer(88));
intOb.showTyep();
int i = (Integer) intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
// 定义类Gen2的一个String版本
Gen2 strOb = new Gen2("Hello Gen!");
strOb.showTyep();
String s = (String) strOb.getOb();
System.out.println("value= " + s);
}
}
class Gen2 {
private Object ob; // 定义一个通用类型成员
public Gen2(Object ob) {
this.ob = ob;
}
public Object getOb() {
return ob;
}
public void setOb(Object ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
package com.demo.generice;
public class GenDemo3 {
public static void main(String[] args) {
// 定义泛型类Gen的一个Integer版本
GenericeDemo<Integer> intOb = new GenericeDemo(88);
intOb.showTyep();
int i = intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
// 定义泛型类Gen的一个String版本
GenericeDemo<String> strOb = new GenericeDemo("Hello Gen!");
strOb.showTyep();
String ss = strOb.getOb();
System.out.println("value= " + ss);
GenericeDemo<AA> sss = new GenericeDemo<AA>(new AA());
sss.showTyep();
System.out.println("value= " + sss.getOb());
}
}
class AA {
@Override
public String toString() {
return "I am "+this.getClass().getSimpleName();
}
}
class GenericeDemo<T>{
private T ob; // 定义泛型成员变量
public GenericeDemo(T ob) {
this.ob = ob;
}
public T getOb() {
return ob;
}
public void setOb(T ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}// 定义泛型类Gen的一个String版本
GenericeDemo<String> strOb = new GenericeDemo("Hello Gen!");
strOb.setOb(99);//这句话会报错有了上面的介绍，也许你真的想要走进泛型的世界了，想要正确理解泛型首要前提是理解类型擦除（typeerasure）。Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List<Object>和List<String>等类型，在编译之后都会变成List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方式与C++模板机制实现方式之间的重要区别。
类型擦除的基本过程也比较简单，首先是找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话，则使用这个上界。把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明，即去掉<>的内容。比如T get()方法声明就变成了Object get()；List<String>就变成了List。接下来就可能需要生成一些桥接方法（bridge method）。这是由于擦除了类型之后的类可能缺少某些必须的方法。比如考虑下面的代码：
package com.demo.generice;
public class MyString implements Comparable<String> {
public int compareTo(String str) {
return 0;
}
}当类型信息被擦除之后，上述类的声明变成了class MyString implements Comparable。但是这样的话，类MyString就会有编译错误，因为没有实现接口Comparable声明的int compareTo(Object)方法。这个时候就由编译器来动态生成这个方法。也就是所谓的桥接方法。由于这个类型擦除的存在，java的泛型有一些独特的地方。
java类型擦除带来的约束与缺陷（http://blog.csdn.net/lonelyroamer/article/details/7868820，这人的写的很详细）。
a,不能用基本类型实例化类型参数
不能用类型参数代替基本类型。因此，没有Pair<double>，只有Pair<Double>。当然，其原因是类型擦除。擦除之后，Pair类含有Object类型的域，而Object不能存储double值。
b,运行时类型查询只适用于原始类型
虚拟机中的对象总有一个特定的非泛型类型。因此，所有的类型查询只产生原始类型。
如：arrayList instanceof ArrayList<String>于arrayList instanceof ArrayList<Integer>无异。
同样的道理，getClass 方法总是返回原始类型。例如，
Pair<String> stringPair = ....;
Pari<Employee> employeePair=...;
stringPair.getClass()==employeePair.getClass();
其比较的结果是true。
c,不能抛出也不能捕获泛型类实例
不能抛出也不能捕获泛型类的对象。事实上，泛型类扩展Throwable都不合法,但是，在异常声明中可以使用类型变量,是合法的.
d,参数化类型的数组不合法
e,不能实例化类型变量
总之，需要记住有关Java 泛型转换的事实：
• 虚拟机中没有泛型，只有普通的类和方法。
• 所有的类型参数都用它们的限定类型替换。
• 桥方法被合成来保持多态。
• 为保持类型安全性，必要时插入强制类型转换。
说了这么多，泛型都有哪些应用呢？（http://blog.csdn.net/lonelyroamer/article/details/7864531,还是那个人写的，还不错）
1、泛型类的定义和使用
一个泛型类（generic class）就是具有一个或多个类型变量的类。定义一个泛型类十分简单，只需要在类名后面加上<>，再在里面加上类型参数：
Pair类引入了一个类型变量T，用尖括号<>括起来，并放在类名的后面。泛型类可以有多个类型变量。例如，可以定义Pair类，其中第一个域和第二个域使用不同的类型：
public class Pair<T,U>{......}
注意：类型变量使用大写形式，且比较短，这是很常见的。在Java库中，使用变量E表示集合的元素类型，K和V分别表示关键字与值的类型。（需要时还可以用临近的字母U和S）表示“任意类型”。
2、泛型接口的定义和使用 定义泛型接口和泛型类类似。
3、泛型方法实际上，还可以定义一个带有类型参数的简单方法。如下
class ArrayAlg{
public static <T> T getMiddle(T[] a){
return a[a.length/2];
}
}这个方法是在普通类中定义的，而不是在泛型类中定义的。然而，这是一个泛型方法，可以从尖括号和类型变量看出这一点。注意，类型变量放在修饰符（这里是public static）的后面，返回类型的前面。泛型方法可以定义在普通类中，也可以定义在泛型类中。当调用一个泛型方法时，在方法名前的尖括号中放入具体的类型：
String[] names = new String[]{"John","Q","public","private"};
// String middle = ArrayAlg.<String>getMiddle(names);
String middle = ArrayAlg.getMiddle(names);//（这样也是可以的）泛型变量的类型限定
知道了泛型类，泛型方法我们很容易写出这样的代码，
- public static <T> T get(T t1,T t2) {
- if(t1.compareTo(t2)>=0);//编译错误
- return t1;
- }
- public static <T extends Comparable> T get(T t1,T t2) { //添加类型限定
- if(t1.compareTo(t2)>=0);
- return t1;
- }
1、不管该限定是类还是接口，统一都使用关键字 extends
2、可以使用&符号给出多个限定，比如
- public static <T extends Comparable&Serializable> T get(T t1,T t2)
- public static <T extends Object&Comparable&Serializable> T get(T t1,T t2)
通配符类型（http://blog.csdn.net/lonelyroamer/article/details/7927212，还是那个家伙的文章，呵呵）
通过上面的例子，我们已经知道有些情况下我们需要对类型进行限定。java为我们提供了通配符类型。
通配符有三种：
1、无限定通配符 形式<?>
2、上边界限定通配符 形式< ? extends Number> //用Number举例
实例
在实际的应用中泛型有什么用呢？仅仅用一个例子说明，
现在有一个业务需求,收钱时需要是我们本公司的员工(继承User),同时亦需要具备收银员的功能(实现Cashier),此时我们当然可以想到接受1个User然后判断User是否实现了Cashier接口,但在泛型的世界中,我们可以怎么做?请看以下例子
1. public static <T extends User & Cashier> void CollectMoney(T t){
2.
3. }
好了以上就是我对泛型的一些简单的理解，如有不对的地方，欢迎大家指出。不得不说这篇文章，参考了网上很多同学的文章，甚至有些地方是直接拷贝的，在此表示感谢，希望他们不要介意。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
