Java泛型--解析泛型擦除机制
（本文主要帮助应用Java泛型，并不太深入，仅根据本人在阅读Java编程思想泛型这一章节遇到的问题给出一些解释，JAVA小菜，错误难免）
一、泛型类：
泛型类只需要在声明类名后面加即可，其中T可换成其他任意字符。如：class Test(){}
二、泛型接口：
声明形式与使用方法与泛型类相同。
三、泛型方法：
声明泛型方法，只需将泛型参数列表置于返回值之前即可，例如：public void f(T x){}。
这里需要注意的是，泛型方法的返回值不能直接作为参数传递给另一个方法，例如有方法A，其声明为public int A(){}。另一泛型方法B，其声明为public void b(T x){}。那么不可以直接b(A())。这主要是因为泛型的擦除机制所引起的
四、泛型擦除机制（本文的主要知识点。前三点可能看完会有点疑惑，这将在第4点给出答案。）
1、问题引入，一个让人迷惑的泛型程序代码
public class ErasedTypeEquivalence
{
public static void main(String[] args)
{
Class c1=new ArrayList.getClass();
Class c2=new ArrayList.getClass();
System.out.println(c1==c2);
}
}/*这段代码的输出结果为true*/ 这里让人疑惑的是ArrayList和ArrayList很容易让人认为是不同的类型。而实际上他们是相同的类型。原因就是下面要讲的Java泛型的擦除机制。
2、擦除机制带来的问题：
在Java中，无法在泛型代码内部获得任何有关泛型参数类型的信息（不过你可以获得它的类名）。
import java.util.*;
class Frob{}
class Fnorkle{}
class Quark<Q>{}
class Particle<POSITION,MOMENTUM>{}
public class Fanxing
{
public static void main(String[] args)
{
List list=new ArrayList();
Map map=new HashMap();
Quark quark=new Quark();
Particle p=new Particle();
System.out.println(Arrays.toString(list.getClass() .getTypeParameters()));
System.out.println(Arrays.toString(map.getClass(). getTypeParameters()));
System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
}
}/*输出结果:
[E]
[K, V]
[Q]
[POSITION, MOMENTUM]*/ 这里输出的只是泛型在定义时候的那个字符，而没有输出泛型参数类型。
3、extends关键字。
问题引入，先看代码：
class HasF()
{
public void f()
{
system.out.println()
}
}
class Manipulator
{
private T obj;
public Manipulator(T x){ Obj=x; }
public void manipulate(){ obj.f() ;}
}
public class Manipulation
{
public static void main(String[] args)
{
HasF hf=new HasF();
Manipulator manipulator=new Manipulator(hf);
manipulator.manipulate();
}
}
/*这段代码将会产生错误，因为在类Manipulator 的manipulate 方法中，有obj.f();。如果在C++中，这段代码自然是不会报错，只要传入HasF即可（这被称为潜在类型机制），然而Java中有擦除机制，obj将被擦除为“Object”类型的，那么obj去调用f()自然是要报错。解决的办法就是使用extends关键字（当然，利用Java反射机制解决也可以，不过这里主要采用泛型的方法）。只要这么去定义Manipulator，这段程序便不会报错：class Manipulator。
*/ 4、擦除机制的内部实现：
Java泛型擦除，分两个时间阶段：其一是编译期，也就是在你敲代码的时候；其二是编译后运行期，也就是你运行代码的时候。在编译期，编译器是可以知道泛型参数信息的（前面说没有办法获得泛型参数类型信息，这是因为获得泛型参数类型信息是需要函数的，函数只能在运行期才起作用），所以这段时间，Java的泛型就有点像C++的了，当然，只是有点。因为像下面这样的代码，Java无法通过编译，而C++可以（在3里说过C++有潜在类型机制，而Java没有）。如下：
class HasF{ public void f(){} }
class Test
{
private T obj;
public Test(T x){ obj=x; }
public invokeF(){ obj.f(); }//这里报错，无法通过编译
}
class TestMain()
{
HasF hasF=new HasF();
Test test=new Test(hasF);
test.invokeF();
} 可能你会感到疑惑，既然编译器在编译期能够知道泛型参数的类型，那么理应向C++泛型那样给你编译通过才是，但为何这里不给编译通过，而是给你报了个编译错误？原因就是在运行期，将会发生泛型的擦除。发生擦除之后，上面的Test类代码将变成下面这样：
class Test
{
private Object obj;
public Test(Object x){ obj=x; }
public invokeF(){ obj.f(); } //这里必然报错
}于是聪明的编译器在编译期就给你报了错，使你立即去修改你的代码，而不是等到代码运行的时候。
擦除机制一定就是把泛型参数擦除为Object吗？不是的。泛型擦除遵循下面这条规则：有限定的擦除为限定类型，无限定的擦除为Object。上述情形就是无限定的情形。接下来看看有限定的情形，同样把上面的Test类的T修改为T extends HasF。擦除之后Test类的代码变为：
class Test
{
private HasF obj;
public Test(HasF x){ obj=x; }
public invokeF(){ obj.f(); } //这里obj是HasF类型，所以此时这里便正确了
}最后再扩展一下，泛型多重限定的擦除，先在增加一个类：
class HasG{ public g(){} }
然后把Test类修改为多重限定，即:
class Test<T extends HasF & HasG>
{
private T obj;
public Test(T x){ obj=x; }
public invokeF(){ obj.f(); }
public invokeF(){ obj.g(); }
}由于加了限定，此时代码是正确的。那么这种情况下，在运行时，怎么擦除？擦除之后的代码如下：
class Test<T extends HasF & HasG>
{
private HasF obj;
public Test(HasF x){ obj=x; }
public invokeF(){ obj.f(); }
public invokeF(){ ((HasG) obj).g(); } //这里发生了个强转
}看到这里，你应该可以得出这样的一个结论，泛型参数在运行时会被擦除，所以它所起的作用仅仅是在编译期提醒你，你应该使用什么类型的参数，从而在编译期避免引入错误的类型。
5、泛型中创建数组的推荐方式：Array.newInstance()
6、擦除补偿：
擦除补偿，主要是在类里面包含一个泛型的参数，然后将一个类实例传递给这个参数。示例代码如下：
class Employee{}
class ClassAsFactory
{
T x;
public ClassAsFactory(Class kind)
{
try {
x=kind.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
public void getXName()
{
System.out.println(x.getClass().getSimpleName());
}
}
public class Generic
{
public static void main(String[] args)
{
ClassAsFactory
fe=new ClassAsFactory(Employee.class);
fe.getXName();
}
} 7、泛型数组：
①成功创建泛型数组的唯一方式是创建一个被擦除类型的数组，然后对其进行转型。例如ArrayList al=(ArrayList[])new ArrayList[10]。
②在进行数组转型时，需要注意数组转型也是Java向上向下转型的一种：
例如： Object objs[]=new Object[10];
String strs[]=(String[])objs;
这将产生错误，因为把Object转为String明显是向下转型，而objs又不是通过String向上转型得来的，所以必然产生错误。若数组是向上转型，则正确。
例如：String strs[]=new String[10];
Object objs[]=strs;
另外，在Java中数组也是一种对象，它是Object类型的。
③Java泛型数组：代码如下：
class GenreicArr
{
public GenreicArr(){}
}
public class GenericArrayTest
{
private T[] array;
public GenericArrayTest(int sz)
{
array=(T[])new Object[sz];
//array=(T[])new GenreicArr[sz];
}
public T[] rep(){return array;}
public static void main(String[] args)
{
try
{
GenericArrayTest
gai=new GenericArrayTest(10);
// System.out.println(Arrays.toString(gai.getClass().getTypeParameters()));
Object oa=gai.rep();
GenreicArr[] ga=gai.rep();//可通过编译，但是运行时发生错误。
} catch (Exception e) {
e.printStackTrace();
}
}
} 从上面的分析我们可以得出这样的结论：在创建泛型数组时，需要注意
Java数组转型的问题，例如：GenreicArr[] ga=gai.rep()，虽然可以通过编译
但是这里的泛型数组是这样的：array=(T[])new Object[sz]，是Object类型的，所以这里是一个向下转型。虽然在泛型中，这可以通过编译，但是在运行时，依然会报错。若把GenericArrayTest的构造函数的第一行代码注释掉，把被注释的第二行代码打开，那就不会报错了。
④更好的创建Java泛型的方式：
在上面代码中，我们是这样创建泛型数组的，先泛化定义T[] array，然后再在GenericArrayTest实例化的时候立即强转：array=(T[])new Object[sz]，这可能导致数组实际类型的丢失，因为数组一创建出来就立即被转型了。如：array=(T[])new Object[sz]中，Object数组一创建出来就立马被强转了（若这里的Object是一个自定义类型，而T是其父类，那这自定义类型将丢失）。所以，一个更好的方式是定义array的时候，将array定义为Object[]，即
Object[] array=new Object[size]。当需要使用的时候，再进行强转，所以上面的rep函数可以这么去重写：public T[] rep(){return(T[]) array;}。可以看见这种方式似乎更显得灵活些，而且这种方式更符合我们的编码习惯：我们可以按照一般方式去创建数组，在需要泛型的时候将其进行强转即可。而且这种方式可以让我们更加清楚数组运行时的类型（这句话的意思是，例如有个自定义的User类，上面的array定义为User[] array=new User[size]，一目了然，array数组运行时的类型就是User类型。当你阅读JDK中ArrayList等类的源码的时候，你会发现，里面大量采用了③中所说的创建泛型数组的方式，正如Think in java中所说Java类库中出现的某些惯用方法，并不代表这就是正确的解决之道，你不能认为它就是应该在你代码中遵循的示例）。
8、泛型边界（通配符）：
Java泛型边界主要有三种：上界，下界，无界。
① 下界类似前面所说的extends关键字，只是“T ”换成了“?”。
首先，先来看一个令人感到迷惑的问题，且看下面代码：
class Fruit{}
class Apple extends Fruit{}
public class Puzzle
{
public static void main(String[] args)
{
//下面的代码将发生错误
ArrayList flist = new ArrayList();
}
} 这段代码里，有个令人困惑的问题：
Java泛型不是有擦除机制么，那么ArrayList与ArrayList应该相同类型的才对，即都会被擦除为ArrayList。事实上也确实如此，因为当你这么做：
System.out.println(ArrayList.getClass()==ArrayList.getClass())
你将会发现输出结果为true。而且在编译期，编译器是知道泛型参数类型的，那么为何这段代码会发生错误？其实这里隐含地涉及一个向下转型的问题。
Java泛型的主要目标之一就是将这种错误检测转移到编译期。所以，ArrayList flist，编译器可以知道Fruit的类型，从而在编译期限定你flist应该存放Fruit及其子类对象，否则发生编译错误。
那么可能有人会说，ArrayList flist = new ArrayList()应该没问题啊，Apple是Fruit的子类。实际上，编译器对代码的了解很少。当你在定义一个ArrayList，实际上ArrayList，ArrayList()与ArrayList将在运行时被擦除为相同的代码。从这点来看，似乎
ArrayList flist = new ArrayList()也应当可以。事实上，“<>”内的泛型参数，只是为了让你知道，你的ArrayList要存放什么东西，并通过编译期报错来告诉你，你可能存放了你预期之外的对象。像ArrayList flist = new ArrayList()，这段代码你究竟是想放什么对象到flist？你可能会说，都差不多。如果两种都可以放，那到时候取出对象的时候，你怎么知道你取出的是Fruit还是Apple对象？而且恰好此时你正要进行一个向下转型，或者你此时取出但是一个Fruit对象，而你想把它转为Apple，那么此时就要出错了。为了准确，你应该告诉编译器更多的信息。所以你应当做如下修改：ArrayList
interface HasColor{ java.awt.Color getColor(); }
class Dimension{ public int x,y,z; }
class ColorDimension<T extends Dimension & HasColor>
{
T item;
ColorDimension(T item){ this.item=item; }
int getX(){ return item.x; }
int getY(){ return item.y; }
int getZ(){ return item.z; }
java.awt.Color color(){ return item.getColor(); }
}为了简单，这里只继承了两层，当然还可以继承三层乃至更多。除此之外，泛型参数还能实现接口。应当注意到HasColor是一个接口。于是还能这样：
class ColorDimension
{
代码略
}
②上界，也叫逆变。跟下界类似，只不过把extends关键字换成super。
class Fruit{}
class Apple extends Fruit{}
class Jonathan extends Apple{}
class SuperTypeWildCards
{
public static void writeTo()
{
List super Apple> apples1=new ArrayList();
List extends Apple> apples2=new ArrayList();
//apples1.add(new Fruit()); //报错
apples1.add(new Jonathan());
apples2.add(null);
}
} apples2为何只能放null的原因在上面已经说过，不再赘述。这里可能你会感到很奇怪，为什么apples1，不是应当放的是Apple的超类么？怎么却放了Apple的子类？而且放超类还报错！原因跟apples2只能放null是一样的，还是因为类型安全的问题：
当你往apples添加Apple的子类对象，当你把这些对象向上转型为apples所限定的基类，如此例，往apples添加了Jonathan，当你把Jonathan对象向上转型为Apple或者Fruit，都是安全的。而当你往apples添加Fruit对象的时候，此时你也想把这个对象朝apples所限定的方向去转型，那么此时将可能发生向下转型！因为Apple和Fruit都是Apple的超类，若允许你放Fruit，同时也放了Apple，那么你如何去分辨哪些是Apple哪些是Fruit？若此时需要转型为Apple，而正好你取到的对象是Fruit，此时就是把Fruit转型为Apple，这将导致错误。
③无界（通配符），无界被限定为单一边界：
无界通配符，可以接受范围更加宽泛的泛型参数：接受所有类型。如：
List> apples=new ArrayList<Fruit>();
List> apples=new ArrayList();
List> apples=new ArrayList<Jonathan>(); 此时可以发现无论是子类还是父类对象都可以被apples接受。当然apples.add方法能接收的参数只能是null，原因同上。
9、几个泛型所带来的问题：
①基本类型不能作为泛型参数，例如ArrayList是不允许的，不过java对基本类型都有包装类
②实现参数化接口（基类劫持接口），例如：
interface Payable<T>{}
class Employee implements Payable<Employee>{}
class Hourly extends Employee implements Payable<Hourly>{}这里Hourly将不能编译，因为擦除会将Payable与Payable简化为相同的类Payable。这就意味着Hourly实现了两次Payable接口。但是有个有趣的现象，当你把Payble去掉泛型，Hourly则编译通过。
③重载问题：
public UserList<W,T>
{
void f(List<T> t){}
void f(List<W> w){}
}这段代码将无法编译。
10、自限定类型
自限定其实就是让泛型参数只能接受自己的类型，例如：
class SelBounded<T extends SelBounded<T>>{}自限定的价值在于可以产生协变参数类型。
扩展补充：
一、参数协变：
1、 方法覆盖的问题：
Classclass Base{}
class Derived extends Base{}
interface OrdinaryGetter{ Base get(); }
interface DerivedGetter extends OrdinaryGetter{ Derived get(); }这里OrdinaryGetter的get方法将被DerivedGetter的get方法覆盖，这是完全合乎逻辑的,然而在早期的Java版本，却是不合法的。解决之道，就是参数协变（这是针对早期Java版本而言的）。
2、 方法重载的问题：
class OrdinarySetter
{
void set(Base base)
{
System.out.println("OrdinarySetter.set(Base)");
}
}
class DerivedSetter extends OrdinarySetter
{
void set(Derived derived)
{
System.out.println("DerivedSetter.set(Derived)");
}
}
class OrdinaryArguments
{
public static void main(String[] args)
{
Base base =new Base();
Derived derived=new Derived();
DerivedSetter ds=new DerivedSetter();
ds.set(base);
ds.set(derived);
}
}/*输出结果：OrdinarySetter.set(Base)
DerivedSetter.set(Derived)*/说明基类的get还存在，DerivedSetter重载了get方法，即DerivedSetter有两个get方法。使用参数协变，将可以实现覆盖，从而使得DerivedSetter仅拥有一份自己的方法。将代码进行修改，
class OrdinarySetter<T extends OrdinarySetter>
{
void set(T base)
{
System.out.println("OrdinarySetter.set(Base)");
}
}
class DerivedSetter extends OrdinarySetter<DerivedSetter>{}二、类型擦除与多态冲突和解决方法：桥方法
（本段摘自博客：http://blog.csdn.net/lonelyroamer/article/details/7868820）
现在有这样一个泛型类：
class Pair {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
} 然后我们想要一个子类继承它
class DateInter extends Pair<Date> {
@Override
public void setValue(Date value) {
super.setValue(value);
}
@Override
public Date getValue() {
return super.getValue();
}
} 在这个子类中，我们设定父类的泛型类型为Pair，在子类中，我们覆盖了父类的两个方法，我们的原意是这样的：
将父类的泛型类型限定为Date，那么父类里面的两个方法的参数都为Date类型：“
public Date getValue() {
return value;
}
public void setValue(Date value) {
this.value = value;
} 所以，我们在子类中重写这两个方法一点问题也没有，实际上，从他们的@Override标签中也可以看到，一点问题也没有，实际上是这样的吗？
分析：
实际上，类型擦除后，父类的的泛型类型全部变为了原始类型Object，所以父类编译之后会变成下面的样子：
class Pair {
private Object value;
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
} 再看子类的两个重写的方法的类型：
@Override
public void setValue(Date value) {
super.setValue(value);
}
@Override
public Date getValue() {
return super.getValue();
} 先来分析setValue方法，父类的类型是Object，而子类的类型是Date，参数类型不一样，这如果实在普通的继承关系中，根本就不会是重写，而是重载。
我们在一个main方法测试一下：
public static void main(String[] args) throws ClassNotFoundException {
DateInter dateInter=new DateInter();
dateInter.setValue(new Date());
dateInter.setValue(new Object());//编译错误
} 如果是重载，那么子类中两个setValue方法，一个是参数Object类型，一个是Date类型，可是我们发现，根本就没有这样的一个子类继承自父类的Object类型参数的方法。所以说，却是是重写了，而不是重载了。
为什么会这样呢？
原因是这样的，我们传入父类的泛型类型是Date，Pair，我们的本意是将泛型类变为如下：
class Pair {
private Date value;
public Date getValue() {
return value;
}
public void setValue(Date value) {
this.value = value;
}
} 然后再子类中重写参数类型为Date的那两个方法，实现继承中的多态。
可是由于种种原因，虚拟机并不能将泛型类型变为Date，只能将类型擦除掉，变为原始类型Object。这样，我们的本意是进行重写，实现多态。可是类型擦除后，只能变为了重载。这样，类型擦除就和多态有了冲突。JVM知道你的本意吗？知道！！！可是它能直接实现吗，不能！！！如果真的不能的话，那我们怎么去重写我们想要的Date类型参数的方法啊。
于是JVM采用了一个特殊的方法，来完成这项功能，那就是桥方法。
首先，我们用javap -c className的方式反编译下DateInter子类的字节码，结果如下：
class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {
com.tao.test.DateInter();
Code:
0: aload_0
1: invokespecial #8 // Method com/tao/test/Pair.""
:()V
4: return
public void setValue(java.util.Date); //我们重写的setValue方法
Code:
0: aload_0
1: aload_1
2: invokespecial #16 // Method com/tao/test/Pair.setValue
:(Ljava/lang/Object;)V
5: return
public java.util.Date getValue(); //我们重写的getValue方法
Code:
0: aload_0
1: invokespecial #23 // Method com/tao/test/Pair.getValue
:()Ljava/lang/Object;
4: checkcast #26 // class java/util/Date
7: areturn
public java.lang.Object getValue(); //编译时由编译器生成的巧方法
Code:
0: aload_0
1: invokevirtual #28 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法
;
4: areturn
public void setValue(java.lang.Object); //编译时由编译器生成的巧方法
Code:
0: aload_0
1: aload_1
2: checkcast #26 // class java/util/Date
5: invokevirtual #30 // Method setValue:(Ljava/util/Date; 去调用我们重写的setValue方法
)V
8: return
} 从编译的结果来看，我们本意重写setValue和getValue方法的子类，竟然有4个方法，其实不用惊奇，最后的两个方法，就是编译器自己生成的桥方法。可以看到桥方法的参数类型都是Object，也就是说，子类中真正覆盖父类两个方法的就是这两个我们看不到的桥方法。而打在我们自己定义的setvalue和getValue方法上面的@Oveerride只不过是假象。而桥方法的内部实现，就只是去调用我们自己重写的那两个方法。
所以，虚拟机巧妙的使用了巧方法，来解决了类型擦除和多态的冲突。
不过，要提到一点，这里面的setValue和getValue这两个桥方法的意义又有不同。
setValue方法是为了解决类型擦除与多态之间的冲突。
而getValue却有普遍的意义，怎么说呢，如果这是一个普通的继承关系：
那么父类的setValue方法如下：
public ObjectgetValue() {
return super.getValue();
} 而子类重写的方法是：
public Date getValue() {
return super.getValue();
} 其实这在普通的类继承中也是普遍存在的重写，这就是协变。
关于协变：。。。。。。
并且，还有一点也许会有疑问，子类中的巧方法 Object getValue()和Date getValue()是同 时存在的，可是如果是常规的两个方法，他们的方法签名是一样的，也就是说虚拟机根本不能分别这两个方法。如果是我们自己编写Java代码，这样的代码是无法通过编译器的检查的，但是虚拟机却是允许这样做的，因为虚拟机通过参数类型和返回类型来确定一个方法，所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情，然后交给虚拟器去区别。
参考资料：①Java编程思想
②博客：http://blog.csdn.net/lonelyroamer/article/details/7868820