1. class Demo1<T>
   
2. {
   
3.         public void show(T t)
   
4.         {
   
5.                 System.out.println("show:"+t);
   
6.         }
   
7.         public void print(T t)
   
8.         {
   
9.                 System.out.println("print:"+t);
   
10.         }
    
11. }
    
12. class GenericDemo4
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 Demo1 d = new Demo1();
    
17.                 d.show(4);
    
18.                 d.print("hello");
    
19.         }
    
20. }

复制代码

T就好比多种口味的棒棒糖  但是每次你只能吃一个  下次吃的时候 口味就变了

1. 
   
2. <p>public class tist
   
3. {</p><p> public static void main(String[] args)
   
4. {
   
5.   Demo d=new Demo();/<font color="red">/此处没有指定泛型类型</font>
   
6.   d.show1(4);//正确
   
7.   d.show2("hello");//正确
   
8.   System.out.println();
   
9.   System.out.println();
   
10.   
    
11.   Demo<Integer>d1=new Demo<Integer<font color="red">>();//此处指定泛型类型为Integer所以show2不能传其他类型，</font>
    
12.           <font color="red"> //而show3是自定义的泛型与类上的无关,可以传任意类型的</font>
    
13.   d1.show1(4);//正确
    
14.   <font color="red">d1.show2("hello");//错误</font>
    
15.   d1.show3("hello");//正确
    
16. 
    
17. }
    
18. }</p><p>
    
19. class Demo<T>
    
20. {
    
21. public void show1(T t)
    
22. {
    
23.   System.out.println("show1"+t);
    
24. }
    
25. 
    
26. public void show2(T t)
    
27. {
    
28.   System.out.println("show2"+t);
    
29. }
    
30. public<Q> void show3(Q q)
    
31. {
    
32.     System.out.println("show3"+q);
    
33. }
    
34. } </p>

复制代码

class 类<泛型类型T>{
      修饰符  泛型类型T   属性；
      public  泛型类型 T   getter(){}
      public  void   sttter( 泛型类型  变量){}
这里的泛型类型指的是包装类，即integer，String,等等
泛型的主要原理是在类声明时通过一个标识，表示类中某个属性的类型或者是某个方法的返回值及参数类型。

在Demo1类中使用<T> 表示此类型是由外部调用本类时指定的，就是外部调用的什么类型，他指定的就是什么类型，返回的也就是这个类型

main函数中都没给T赋上具体的类型，会报错

玥夜 发表于 2014-8-1 11:20
T就好比多种口味的棒棒糖  但是每次你只能吃一个  下次吃的时候 口味就变了 ...

奇怪的是可以通过编译，而且可以运行

vaqh 发表于 2014-8-1 14:31
奇怪的是可以通过编译，而且可以运行

因为new对象的时候没指定泛型，所有调用其方法的时候可以传任意类型的参数进去，T就是代表的任意类型！所以编译能通过，也能运行！
如果你直接在创建对象的时候就指定泛型，那么对象的方法也必须按照你指定的泛型类型进行参数传递！否则编译不通过！！！

格子、 发表于 2014-8-1 14:45
因为new对象的时候没指定泛型，所有调用其方法的时候可以传任意类型的参数进去，T就是代表的任意类型！所 ...

恩，有那么一点明白了，谢谢