黑马程序员——泛型

-------  android培训 、 java培训 、期待与您交流！ ----------

Generic：泛型

泛型：广泛的类型。就是给对象指定数据类型的安全机制。泛型是JDK1.5 版本以后出现的新特性。用于解决数据的安全问题。是一个安全机制。

好处：

1、将运行时期出现问题 ClassCastException，转移到了编译时期。防便于程序员解决问题。让运行时问题减少，提高安全。

2、避免了强制转换的麻烦。

泛型格式：通过  <>  尖括号来定义要操作的引用数据类型。

泛型又可以细分为：

1、泛型集合

2、泛型类

3、泛型接口

4、高级泛型

一、泛型集合

在使用java提供的对象时，什么时候写泛型呢？通常在集合框架中很常见。只要见到<>就是定义泛型。其实<>就是用来接收数据类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>尖括号中即可。

1）Demo：

[java]  view plain copy

1. import java.util.ArrayList;    
2. import java.util.Iterator;    
3. public class GenericDemo {    
4.     public static void main(String[] args) {    
5.         //泛型1-----加了“ <> ”。就表示泛型结构，为了定义容器的数据类型，减少出错。    
6.         ArrayList<String> al = new ArrayList<String>();     
7.         al.add("aaa");    
8.         al.add("xxx");    
9.         al.add("sadf");    
10.         //泛型2-----同时指定迭代器的数据类型    
11.         Iterator<String> it = al.iterator();    
12.         while(it.hasNext()){    
13.             //泛型3-----这时候就不需要强转了，避免了强制转换的麻烦//(String)    
14.             String s = it.next();    
15.             System.out.println(s+":"+s.length());    
16.         }    
17.     }    
18. }   

2) 长度比较器

//实现了比较器接口

[java]  view plain copy

1. class LenComparator implements Comparator<String>{    
2. //重写接口中的compare 方法    
3.     @Override    
4.     public int compare(String o1, String o2) {    
5.         int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));    
6.         if(num==0)    
7.             return o2.compareTo(o1);    
8.         return num;    
9.     }    
10. }  

二、泛型类，泛型方法和泛型接口

1) 什么时候定义泛型类？当类中需要操作的引用数据类型不确定的时候，早期定义 Object 来完成扩展，现在定义泛型来完成扩展。

2) 泛型类定义的泛型在整个类中有效。如果被方法使用，那么泛型类的对象要明确操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

3) 特殊之处：

静态不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法中。

4) 定义泛型类：

1、可以定义泛型类：class DemoGe<T>

2、可以定义泛型方法：public <S> void show(S s)

3、可以同时定义泛型类和泛型方法。

5) 泛型类的 Demo 示例：

[java]  view plain copy

1. public class GenericDemo4 {    
2.     public static void main(String[] args) {    
3.         DemoGe2 dg = new DemoGe2();    
4.         dg.show("xxx");    
5.         dg.show(124);    
6.         dg.show('a');    
7.         dg.show("[123,xxx,OOO]");    
8.     }    
9. }    
10. /**   
11.  * 定义：泛型类   
12.  * T 随意参数   
13.  * @param <T>   
14.  */    
15. class DemoGe<T>{    
16.     public void show(T t){    
17.         System.out.println("show-->"+t);    
18.     }    
19.     public void print(T t){    
20.         System.out.println("print-->"+t);    
21.     }    
22. }    
23. /**   
24.  * 定义：泛型方法   
25.  * 将泛型定义在方法上   
26.  */    
27. class DemoGe2{    
28.     public <S> void show(S s){    
29.         System.out.println("show-->"+s);    
30.     }    
31.     public <P> void print(P p){    
32.         System.out.println("print-->"+p);    
33.     }    
34. }    
35. /**   
36.  * 定义：泛型类与方法同时存在   
37.  */    
38. class DemoGe3<T>{    
39.     public void show(T s){    
40.         System.out.println("show-->"+s);    
41.     }    
42.     public <P> void print(P p){    
43.         System.out.println("print-->"+p);    
44.     }    
45.     //静态不可以访问类上定义的泛型    
46.     //public static void method(T m){           
47.     //  System.out.println("method:"+m);    
48.     //}    
49.     public static <M> void method2(M m){    
50.         System.out.println("method2:"+m);    
51.     }    
52. }   

6) 泛型接口 Demo：

[java]  view plain copy

1. interface Inter<T>{    
2.     void show(T t);    
3. }    
4. class InterImpl<T> implements Inter<T>{    
5.     @Override    
6.     public void show(T t) {    
7.         System.out.println("show:"+t);    
8.     }    
9. }    

三、高级泛型

高级泛型：用 ? 表示，可以接收 ArrayList 中的任意元素。

[java]  view plain copy

1. public static void printColl(ArrayList<?> al){    
2.         Iterator<?> it = al.iterator();    
3.         while(it.hasNext()){    
4.             System.out.println(it.next());      
5.             //定义泛型不能使用length()这个方法    
6.             //但是可以使用  toString()  方法    
7.         }    
8. }