黑马程序员_泛型

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

泛型：

JDK1.5版本后出现的新特性。用于解决安全问题。是一安全机制。

好处：
1.将运行时期出现的问题ClassCastException，转移到了编译时期。
方便于程序员解决问题。让运行事情问题减少。安全。
2.避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。


在什么时候使用泛型：
通常在集合框架中使用泛型。只要看到<>就要使用泛型。


什么时候定义泛型类：

当类中要操作的引用数据类型不确定的时候。

普通泛型：

1.class Point<T>{       // 此处可以随便写标识符号，T是type的简称  
2.    private T var ; // var的类型由T指定，即：由外部指定  
3.    public T getVar(){  // 返回值的类型由外部决定  
4.        return var ;  
5.    }  
6.    public void setVar(T var){  // 设置的类型也由外部决定  
7.        this.var = var ;  
8.    }  
9.};  
10.public class GenericsDemo06{  
11.    public static void main(String args[]){  
12.        Point<String> p = new Point<String>() ; // 里面的var类型为String类型  
13.        p.setVar("it") ;        // 设置字符串  
14.        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
15.    }  
16.};  

泛型接口：

1.interface Info<T>{        // 在接口上定义泛型  
2.    public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  
3.}  
4.class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
5.    private T var ;             // 定义属性  
6.    public InfoImpl(T var){     // 通过构造方法设置属性内容  
7.        this.setVar(var) ;    
8.    }  
9.    public void setVar(T var){  
10.        this.var = var ;  
11.    }  
12.    public T getVar(){  
13.        return this.var ;  
14.    }  
15.};  
16.public class GenericsDemo24{  
17.    public static void main(String arsg[]){  
18.        Info<String> i = null;        // 声明接口对象  
19.        i = new InfoImpl<String>("汤姆") ;  // 通过子类实例化对象  
20.        System.out.println("内容：" + i.getVar()) ;  
21.    }  
22.};  
23.----------------------------------------------------------  
24.interface Info<T>{        // 在接口上定义泛型  
25.    public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  
26.}  
27.class InfoImpl implements Info<String>{   // 定义泛型接口的子类  
28.    private String var ;                // 定义属性  
29.    public InfoImpl(String var){        // 通过构造方法设置属性内容  
30.        this.setVar(var) ;    
31.    }  
32.    public void setVar(String var){  
33.        this.var = var ;  
34.    }  
35.    public String getVar(){  
36.        return this.var ;  
37.    }  
38.};  
39.public class GenericsDemo25{  
40.    public static void main(String arsg[]){  
41.        Info i = null;      // 声明接口对象  
42.        i = new InfoImpl("汤姆") ;    // 通过子类实例化对象  
43.        System.out.println("内容：" + i.getVar()) ;  
44.    }  
45.};  

泛型方法：

1.class Demo{  
2.    public <T> T fun(T t){            // 可以接收任意类型的数据  
3.        return t ;                  // 直接把参数返回  
4.    }  
5.};  
6.public class GenericsDemo26{  
7.    public static void main(String args[]){  
8.        Demo d = new Demo() ;   // 实例化Demo对象  
9.        String str = d.fun("汤姆") ; //   传递字符串  
10.        int i = d.fun(30) ;     // 传递数字，自动装箱  
11.        System.out.println(str) ;   // 输出内容  
12.        System.out.println(i) ;     // 输出内容  
13.    }  
14.};  

泛型无法向上转型：

1.class Info<T>{  
2.    private T var ;     // 定义泛型变量  
3.    public void setVar(T var){  
4.        this.var = var ;  
5.    }  
6.    public T getVar(){  
7.        return this.var ;  
8.    }  
9.    public String toString(){   // 直接打印  
10.        return this.var.toString() ;  
11.    }  
12.};  
13.public class GenericsDemo23{  
14.    public static void main(String args[]){  
15.        Info<String> i1 = new Info<String>() ;      // 泛型类型为String  
16.        Info<Object> i2 = null ;  
17.        i2 = i1 ;                               //这句会出错 incompatible types  
18.    }  
19.};  

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