Go语言视频零基础入门到精通

javalearner

1.     /**
   
2.     * @author Rollen-Holt 使用泛型
   
3.     */
   
4.     class Test< T, V> {  
   
5.         private T name;  
   
6.         private V age;  
   
7.         Test() {  
   
8.         }  
   
9.         public T getName() {  
   
10.             return name;  
    
11.         }  
    
12.         public void setName(T name) {  
    
13.             this.name = name;  
    
14.         }  
    
15.         public V getAge() {  
    
16.             return age;  
    
17.         }  
    
18.         public void setAge(V age) {  
    
19.             this.age = age;  
    
20.         }     
    
21.         public static void main(String[] args) {  
    
22.             Test< String, Integer> he = new Test< String, Integer>();  
    
23.             he.setAge(10);  
    
24.             he.setName("Rollen Holt");  
    
25.             System.out.println(he.getName() + ":" + he.getAge());  
    
26.         }  
    
27.     }
    
28.     /**  
    
29.      *   
    
30.      * @author Rollen-Holt 泛型类的构造方法定义  
    
31.      */  
    
32.     class Test< T, V> {  
    
33.         private T name;  
    
34.         private V age;  
    
35.         Test(T name, V age) {  
    
36.             this.age = age;  
    
37.             this.name = name;  
    
38.         }  
    
39.         public T getName() {  
    
40.             return name;  
    
41.         }  
    
42.         public V getAge() {  
    
43.             return age;  
    
44.         }     
    
45.         public static void main(String[] args) {  
    
46.             Test< String, Integer> he = new Test< String, Integer>("Rollen", 12);  
    
47.             System.out.println(he.getName() + "  " + he.getAge());  
    
48.         }  
    
49.     }
    
50.     /**  
    
51.      * @author Rollen-Holt 使用通配符  
    
52.      */  
    
53.     class info< T> {  
    
54.         private T name;  
    
55.         info(T name) {  
    
56.             this.name = name;  
    
57.         }  
    
58.     }  
    
59.     class Test {  
    
60.         public static void function(info< ?> temp) {  
    
61.             System.out.println("内容： " + temp);  
    
62.         }  
    
63.         public static void main(String[] args) {  
    
64.             info< String> demo = new info< String>("Rollen");  
    
65.             function(demo);  
    
66.         }  
    
67.     }
    
68.     /**  
    
69.      * @author Rollen-Holt 泛型上限  
    
70.      */  
    
71.     class info< T> {  
    
72.         info(T age) {  
    
73.             this.age = age;  
    
74.         }  
    
75.         private T age;  
    
76.     }  
    
77.     class Test {  
    
78.         public static void function(info< ? extends Number> temp) {  
    
79.             System.out.println("内容" + temp);  
    
80.         }  
    
81.         public static void main(String[] args) {  
    
82.             info< Integer> demo = new info< Integer>(1);  
    
83.             function(demo);  
    
84.         }  
    
85.     }
    
86.     /**  
    
87.      * @author Rollen-Holt 泛型下限  
    
88.      */  
    
89.     class info< T>{  
    
90.         info(T age){  
    
91.             this.age=age;  
    
92.         }  
    
93.         private T age;  
    
94.     }  
    
95.     class hello{  
    
96.         public static void function(info< ? super String> temp){  
    
97.             System.out.println("内容"+ temp);  
    
98.         }     
    
99.         public static void main(String[] args){      
    
100.          // 此处只能使用String 或者Object  
     
101.           info< String> demo=new info< String>("Rollen");  
     
102.           function(demo);  
     
103.         }  
     
104.     }
     
105. 
     
106.     /**
     
107.      * @author Rollen-Holt 泛型和子类继承的限制  
     
108.      */  
     
109.     class info< T>{  
     
110.     }  
     
111.     class hello{  
     
112.         public static void main(String[] args){  
     
113.         info< String> demo1=new info< String>();  
     
114.         info< Object> demo2=new info< Object>();  
     
115.         //demo2=demo1;   此处错误      
     
116.         }  
     
117.     }  
     
118.     /**  
     
119.      * 上面的例子说明，一个类的子类可以通过多态性被其父类实例化  
     
120.      * 但是在泛型操作中，子类的泛型类型是无法被其父类的泛型类型实例化的。  
     
121.      */  
     
122.     如果允许上面的条语句的话，会出现：  
     
123.     Exception in thread "main" java.lang.Error: Unresolved compilation problem:   
     
124.         Type mismatch: cannot convert from info< String> to info< Object>
     
125.         at hello.main(hello.java:12)
     
126.     /**  
     
127.      * @author Rollen-Holt 泛型接口的实现1  
     
128.      */  
     
129.     interface info< T> {  
     
130.         public void say();  
     
131.     }  
     
132.     // 直接在子类之后声明泛型  
     
133.      
     
134.     class hello< T> implements info< T>{  
     
135.         public static void main(String[] args){  
     
136.             info< String> demo = new hello< String>();  
     
137.             demo.say();  
     
138.         }  
     
139.         public void say(){  
     
140.             System.out.println("hello");  
     
141.         }  
     
142.     }
     
143.     /**  
     
144.      * @author Rollen-Holt 泛型接口的实现2  
     
145.      */  
     
146.     interface info< T> {  
     
147.         public void say();  
     
148.     }  
     
149.     // 在子类实现的接口中明确给出泛型类型  
     
150.     class hello implements info< String>{  
     
151.         public static void main(String[] args){  
     
152.             info< String> demo = new hello();  
     
153.             demo.say();  
     
154.         }  
     
155.         public void say(){  
     
156.             System.out.println("hello");  
     
157.         }  
     
158.     }
     
159.     /**  
     
160.      * @author Rollen-Holt 使用泛型统一传入参数的类型  
     
161.      */  
     
162.     class info< T> {  
     
163.         private T var;  
     
164.         public T getVar(){  
     
165.             return var;  
     
166.         }  
     
167.         public void setVar(T var){  
     
168.             this.var = var;  
     
169.         }  
     
170.         public String toString(){  
     
171.             return this.var.toString();  
     
172.         }  
     
173.     }  
     
174.     class hello{  
     
175.         public static void main(String[] args){  
     
176.             info< String> demo1=new info< String>();  
     
177.             info< String> demo2=new info< String>();  
     
178.             demo1.setVar("Rollen");  
     
179.             demo2.setVar("Holt");  
     
180.             printAdd(demo1, demo2);  
     
181.         }  
     
182.         // 此处传递的都是同一个String类型的  
     
183.         public static < T> void printAdd(info< T> demo1, info< T> demo2){  
     
184.             System.out.println(demo1.getVar()+" "+demo2.getVar());  
     
185.         }  
     
186.     }

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/10/28/235530500.zip