标签：
1.java中泛型类似于C++中的模板，最主要的目的就是避免重复写代码，实现代码重用。
例如maxmin函数，maxmin(int,int),maxmin(long,long),maxmin(double,double),因为参数的不同，可能需要分别写三个maxmin.
使用泛型后public <T>T maxmin(T,T),写一个就行了。
2.java中的泛型只能适用于对象，基本类型如int，long不能使用，必须使用其对象类型Integer,Long.
3.java中的泛型主要是类都是Object的子类，而Object变量可以引用其他子类，所以泛型可以看成以下这种方式
public Object maxmin(Object,Object)
4.java中的泛型编译后只保留一份代码拷贝.
而C++的模板虽然我们只写了一份模板代码，但是因为有几个不同的参数的调用，相应的编译
后就要产生几份对应的代码，例如template<class T> T maxmin(T,T).如果软件中调用了maxmin(int,int)和maxmin(long,long)
编译后会产生两份代码拷贝。
结合代码说明：
public class Test1{
public static void main(String[] args){
Test1 aTest1=new Test1();
//Disp1(123.456);//error
aTest1.Disp1(123.456);
Disp2(345);
Gclass1<String> aGclass1=new Gclass1<String>("abfsf");
aGclass1.Display();
Gclass1<Long> bGclass1=new Gclass1<Long>(12345l);
bGclass1.Display();
Gclass2 aGclass2=new Gclass2("what a fuck object");
aGclass2.Display();
Gclass2 bGclass2=new Gclass2(123.456);
bGclass2.Display();
Gclass4 aGclass4=new Gclass4("this is Gclass4");
Gclass3<Gclass4> aGclass3=new Gclass3<Gclass4>(aGclass4);
aGclass3.Display();
EGclass4 aEGclass4=new EGclass4("this is EGclass4");
Gclass3<EGclass4> bGclass3=new Gclass3<EGclass4>(aEGclass4);
bGclass3.Display();
}
public <FUCK>FUCK Disp1(FUCK t){
FUCK bT=null;
bT=t;
System.out.println("this is Disp1(): "+bT);
return bT;
}
public static void Disp2(int temp){
System.out.println("this is Disp2(): "+temp);
}
}
class Gclass1<T>{
Gclass1(T t){this.aT=t;}
public void Display(){
System.out.println("Gclass1 disp: "+this.aT);
}
private T aT=null;
}
class Gclass2{
Gclass2(Object t){this.aT=t;}
public void Display(){
System.out.println("Gclass2 disp: "+this.aT);
}
private Object aT=null;
}
class Gclass3<T extends Gclass4>{
Gclass3(T t){this.aT=t;}
public void Display(){
System.out.println("GGclass3 disp(): "+this.aT.getClass());
this.aT.Display();
}
private T aT=null;
}
class Gclass4<T>{
Gclass4(T t){this.aT=t;}
public void Display(){
System.out.println("GGclass4 disp(): "+this.aT);
}
public T aT=null;
}
class EGclass4 <T> extends Gclass4<T>{
EGclass4(T t){
super(t);
}
public void Display(){
System.out.println("EGclass4 disp(): "+super.aT);
}
}
/////////////////////////////////////////////////
输出结果
this is Disp1(): 123.456
this is Disp2(): 345
Gclass1 disp: abfsf
Gclass1 disp: 12345
Gclass2 disp: what a fuck object
Gclass2 disp: 123.456
GGclass3 disp(): class Gclass4
GGclass4 disp(): this is Gclass4
GGclass3 disp(): class EGclass4
EGclass4 disp(): this is EGclass4
//////////////////////////////////////////////////////////////////////////////////////////
首先是一个公共类Test1，静态函数main通过对象aTest1调用了一个非静态静态泛型函数Disp1（如果不通过对象，直接调用非静态不合法）
然后直接调用了静态函数Disp2;
创建了泛型类Gclass1，Gclass2。其中Gclass2通过Object创建，与Gclass1效果一样。
创建了泛型类Gclass4，她的子类泛型类EGclass4
创建了泛型类Gclass3，通过<T extends Gclass4>限制参数类型为Gclass4或其子类。
因为做了限定，所以采用Gclass3声明变量时只能用Gclass4或其子类
Gclass3<Gclass4> aGclass3=new Gclass3<Gclass4>(aGclass4);
Gclass3<EGclass4> aGclass3=new Gclass3<EGclass4>(aEGclass4);
标签：
原文地址：http://www.cnblogs.com/wudymand/p/4275084.html
