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

javalearner

1. import java.util.ArrayList;
   
2. import java.util.Collection;
   
3. import java.util.List;
4. 
   
5. /**
   
6. * 范型编程
   
7. */
8. 
   
9. // 父类
   
10. class Parent{
    
11.         public String name;
    
12.         public Parent(String name){
    
13.                 this.name = name;
    
14.         }
    
15.         public String toString(){
    
16.                 return "name = " + this.name;
    
17.         }
    
18. }

复制代码

  
  

1. // 子类
   
2. class Child extends Parent{
   
3.         public int age;
   
4.         public Child(String name, int age){
   
5.                 super(name);
   
6.                 this.age = age;
   
7.         }
   
8.         public String toString(){
   
9.                 return super.toString() + ";  age = " + age;
   
10.         }
    
11. }
12. 
    
13. public class GeneralProgram {
    
14.         /**
    
15.            * 在命令行输出一个集
    
16.          * 使用问号？通配符，？代表任何类型，所以它的参数可以是任何类型的Collection。
    
17.          */
    
18.         public static void printCollection(Collection< ?> collect){
    
19.                 if (collect == null){
    
20.                         return;
    
21.                 }
    
22.                 for(Object obj : collect){
    
23.                         System.out.print(obj + "    ");
    
24.                 }
    
25.                 System.out.println();
    
26.         }
    
28.            /**
    
29.          * 使用有限制的通配符“? extends”，可以接受任何Parent及其子类的Collection
    
30.          * @param collect
    
31.          */
    
32.         public static void printNames(Collection< ? extends Parent> collect){
    
33.                 if (collect == null){
    
34.                         return;
    
35.                 }
    
36.                 for(Parent parent : collect){
    
37.                         System.out.print(parent.name + "    ");
    
38.                 }
    
39.                 System.out.println();
    
40.         }
    
41.    
42.      /**
    
43.          * 范型方法，将一个任意类型的数组，添加到列表中。
    
44.          * @param < T> 代表一个任意的类
    
45.          * @param datas        数组对象
    
46.          * @return
    
47.          */
    
48.        
49.     public static < T> List< T> arrayToList(T[] datas){
    
50.                 if (datas == null){
    
51.                         return null;
    
52.                 }
    
53.                 List< T> list_T = new ArrayList< T>();
    
54.                 for (T x : datas){
    
55.                         list_T.add(x);
    
56.                 }
    
57.                 return list_T;
    
58.         }
    
60.         /**
    
61.          * 范型方法，在一组Parent对象中查找名字为name的Parent对象
    
62.          * @param < T>        可以是Parent对象或者子类对象
    
63.          * @param parents        Parent对象组
    
64.          * @param name        目标name
    
65.          * @return        匹配的Parent对象
    
66.          */
    
67.        
68.      public static < T extends Parent> T findParent(T[] parents, String name) {
    
69.                 if (parents == null) {
    
70.                         return null;
    
71.                 }
    
72.                 T parent = null;
    
73.                 // 依次遍历Parent对象组
    
74.                 for (T x : parents) {
    
75.                         // 如果Parent对象的name与参数name匹配，则退出遍历
    
76.                         if (x.name.equals(name)) {
    
77.                                 parent = x;
    
78.                                 break;
    
79.                         }
    
80.                 }
    
81.                 // 返回
    
82.                 return parent;
    
83.         }
    
84.        
    
85.         public static void main(String[] args) {
    
86.                 /** * 指定具体的类型 ** */
    
87.                 // 声明一个用于装字符串的列表，该列表只能装字符串类型的对象
    
88.                 List< String> list_S = new ArrayList< String>();
    
89.                 list_S.add("first");
    
90.                 list_S.add("second");
    
91.                 list_S.add("third");
    
92.                
93.         // 不能装整数对象
    
94.                 Integer iObj = 10;
    
95.                 // list_S.add(iObj);// error!!!
    
96.                 // 在从列表中取值时，不用作强制类型转换。
    
97.                 String firstS = list_S.get(0);
    
98.                 String thirdS = list_S.get(2);
    
99.                 System.out.println("firstS: " + firstS + "; thirdS: " + thirdS);
    
100.                
101.         /** **范型和继承** */
     
102.                 // String 继承 Object
     
103.                 String s = "sss";
     
104.                 Object o = s;
     
105.                 // 但List< String>不继承List< Object>
     
106.                 // List< Object> list_O = list_S;// error!!!
     
107.                
108.         /** * 通配符 *** */
     
109.                 // 调用具有“？”通配符的方法
     
110.                 List< Integer> list_I = new ArrayList< Integer>();
     
111.                 list_I.add(5555);
     
112.                 list_I.add(6666);
     
113.                 list_I.add(7777);
     
114.                 // 该方法既可以打印整型列表，也可以打印字符串列表
     
115.                 printCollection(list_I);
     
116.                 printCollection(list_S);
     
117.                
118.         // 调用具有“? extends” 通配符的方法
     
119.                 // 只接受父类以及子类类型的列表
     
120.                 List< Parent> list_Parent = new ArrayList< Parent>();
     
121.                 list_Parent.add(new Parent("parentOne"));
     
122.                 list_Parent.add(new Parent("parentTow"));
     
123.                 list_Parent.add(new Parent("parentThree"));
     
124.                 List< Child> list_Child = new ArrayList< Child>();
     
125.                 list_Child.add(new Child("ChildOne", 20));
     
126.                 list_Child.add(new Child("ChildTow", 22));
     
127.                 list_Child.add(new Child("ChildThree", 21));
     
128.                 printNames(list_Parent);
     
129.                 printNames(list_Child);
     
130.                
131.         // 不能接受其他类型的参数
     
132.                 // printNames(list_S);// error!!!
     
133.                 /** * 范型方法 *** */
     
134.                
135.         // arrayToList方法将任意类型的对象数组变成相应的列表
     
136.                 Integer[] iObjs = { 55, 66, 77, 88, 99 };
     
137.                 // 转换整型数组
     
138.                 List< Integer> result_I = arrayToList(iObjs);
     
139.                 printCollection(result_I);
     
140.                
141.         String[] ss = { "temp", "temptemp", "hehe", "he", "hehehe" };
     
142.                 // 转换字符串数组
     
143.                 List< String> result_S = arrayToList(ss);
     
144.                 printCollection(result_S);
     
145.                 // findParent方法在一组Parent对象中根据name查找Parent
     
146.                 Parent[] parents = { new Parent("abc"), new Parent("bcd"),new Parent("def") };
     
147.                
148.         Parent parent = findParent(parents, "bcd");
     
149.                 System.out.println("找到的bcd：" + parent);
     
150.                 Child[] children = { new Child("abc", 22), new Child("bcd", 23),ew Child("def", 22) };
     
151.                 Child child = findParent(children, "bcd");
     
152.                 System.out.println("找到的bcd：" + child);
     
153.                 // 但是不能在字符串数组中进行查找
     
154.                 // String sss = findParent(ss, "temp");// error!!!
     
155.         }
     
156. }
     
157. 运行结果：
     
158. C:java>java   GeneralProgram
159. firstS: first; thirdS: third
160. 5555    6666    7777
161. first    second    third
162. parentOne    parentTow    parentThree
163. ChildOne    ChildTow    ChildThree
164. 55    66    77    88    99
165. temp    temptemp    hehe    he    hehehe
166. 找到的bcd：name = bcd
167. 找到的bcd：name = bcd;  age = 23
168. 
     
169.                      

复制代码

   
     
     
      
      

        
      

        
      
     
   

1. 
   
2.                         

复制代码

  


源码下载：http://file.javaxxz.com/2014/10/30/235643328.zip