java 之 泛型

 1 public class Test {
 2     
 3     //泛型方法
 4     public <T> void printClass(T a){
 5         System.out.println(a.getClass());
 6     }
 7 
 8     public static void main(String[] args){
 9         
10         Test t=new Test();
11         t.printClass(t);                    
12     }
13 }

输出：

class Test

泛型方法中，<T>在返回值的定义前面，如果有返回值，返回值也可以是<T>，就可以是这样：

//泛型方法，它什么也没干
    public <T> T printClass(T a){
        return a;
    }

可以这样理解：<>告诉编译器，这里里面的东西到时候给我替换了，于是，调用这个方法时，传入了某个类型a,则这些代码中的T都被临时变为a的类型了。

当然，<>中可以随便写

 1 //<> 里面可以随便写
 2 public <X> void printClass(X a){
 3         System.out.println(a.getClass());
 4     }
 5 
 6 public <a> void printClass(a a){
 7         System.out.println(a.getClass());
 8     }
 9 
10 public <Xa> void printClass(Xa a){
11         System.out.println(a.getClass());
12     }

以上代码都可以编译通过的。

下面复杂一点，泛型边界控制：

 1 public class Test {
 2     
 3     //泛型方法
 4     public <T extends Test> void printClass(T a){
 5         System.out.println(a.getClass());
 6     }
 7     
 8     public class Gen {
 9         
10     }
11 
12     public static void main(String[] args){
13         
14         Test t=new Test();
15         Gen g=t.new Gen();
16         t.printClass(g);                    
17     }
18 }

输出：

Exception in thread "main" java.lang.Error: 无法解析的编译问题：
    边界不匹配：类型 Test 的通用方法 printClass（T）不适用于参数（Test.Gen）。推断类型 Test.Gen 并不是有界参数 <T 到 Test> 的有效替代项。

    at Test.main(Test.java:17)

上面的 <T extends Test>  ，要求这个泛型参数必须是继承于Test或者实现了Test接口，把class gen改写为 class gen extends Test即可以编译通过运行。

再复杂一点，

 1 public class Test {
 2     
 3     //泛型方法,要求参数必须是继承了泛型类Gen的对象，而泛型类Gen的泛型可以定义为任意
 4     public <T extends Gen<?>> void printClass(T a){
 5         System.out.println(a.getClass());
 6     }
 7     
 8     public class Gen<T> {
 9         
10     }
11     
12     //继承了泛型类Gen，并定义泛型类的类型参数是String
13     public class Gen1 extends Gen<String>{
14         
15     }
16     //继承了泛型类Gen,并定义泛型类的类型参数是Gen1
17     public class Gen2 extends Gen<Gen1>{
18         
19     }
20     
21     public static void main(String[] args){
22         
23         Test t=new Test();
24         Gen1 g1=t.new Gen1();        
25         t.printClass(g1);    
26         Gen2 g2=t.new Gen2();
27         t.printClass(g2);
28         
29     }
30 }

输出：

class Test$Gen1
class Test$Gen2

到这里为止，所有的泛型都只运用到了方法的传入参数，那么对于方法的返回值怎么泛型呢：

 1 public class Test {
 2     
 3     //泛型方法,传入参数a为任意类型，返回值为传入值的类型
 4     public static <T> T getA(T a){
 5         return a;
 6     }
 7     
 8     //泛型方法,传入参数a为整形，返回值为传入值的类型
 9     @SuppressWarnings("unchecked")
10     public static <T> T getB(String a){
11         return (T)a;
12     }
13 
14     //返回值为String ,参数a的类型为任意
15     public static <T> String getC(T a){
16         return a.toString();
17     }
18     
19     
20     public static void main(String[] args){
21         int a=1;
22         int b=getA(a);
23         System.out.println(b);
24         String s1="test";
25         String s=getA(s1);    
26         System.out.println(s);
27         
28         s=getB(s);
29         System.out.println(s);
30         
31         s=getC(a);
32         System.out.println(s);
33     }
34 }

输出：

1
test
test
1

泛型的使用，很常见的比如容器，看看下面的示例，就知道自己该如何定义泛型了：

 1 public class Test {
 2     
 3     //这是个泛型接口，定义了一个泛型方法
 4     public interface  Eat <T> {
 5         public void doEat(T t);
 6         
 7     }
 8 
 9     
10     //实现了Eat接口，使Eat接口的泛型类型为Shit这个内部类
11     public class Dog implements Eat<Dog.Shit>{
12 
13         public Dog(){
14             System.out.println("这是狗");
15             //这里只是掩饰，Dog自己并不是自产自销的家伙
16             Shit s=new Shit();
17             this.doEat(s);
18         }
19         
20         
21         //内部类
22         public class Shit{
23             public Shit(){
24                 System.out.println("这是一坨");
25             }            
26         
27         }
28 
29 
30         @Override
31         public void doEat(Shit t) {
32             // TODO Auto-generated method stub
33             System.out.println("狗吃了一坨");
34         }
35 
36         
37     }
38     
39     public class Bull implements Eat<Bull.Grass>{
40         
41         public Bull(){
42             System.out.println("这是Bull");
43             Grass g=new Grass();
44             this.doEat(g);
45         }
46 
47         //内部类
48         public class Grass {
49             public Grass(){
50                 System.out.println("这是Grass");
51             }
52         }
53 
54         @Override
55         public void doEat(Grass t) {
56             // TODO Auto-generated method stub
57             System.out.println("Bull吃了Grass");
58             
59         }
60         
61     }
62     
63 
64     public static void main(String[] args){
65         Test t=new Test();
66         Dog d=t.new Dog();
67         Bull b=t.new Bull();
68     }
69 }

输出：

这是狗
这是一坨
狗吃了一坨
这是Bull
这是Grass
Bull吃了Grass

将泛型用到这样的接口中看来还是有很多好处的。