认识泛型

java 泛型是java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
1：泛型类

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.};  

2： 泛型接口

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.};  

3：泛型方法

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 extends Number>{ // 指定上限，只能是数字类型  
2.    private T var ;     // 此类型由外部决定  
3.    public T getVar(){  
4.        return this.var ;     
5.    }  
6.    public void setVar(T var){  
7.        this.var = var ;  
8.    }  
9.    public String toString(){       // 覆写Object类中的toString()方法  
10.        return this.var.toString() ;      
11.    }  
12.};  
13.public class GenericsDemo27{  
14.    public static void main(String args[]){  
15.        Info<Integer> i = fun(30) ;  
16.        System.out.println(i.getVar()) ;  
17.    }  
18.    public static <T extends Number> Info<T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定  
19.        Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info  
20.        temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中  
21.        return temp ;   // 返回实例化对象  
22.    }  
23.};  

泛型数组

1.public class GenericsDemo30{  
2.    public static void main(String args[]){  
3.        Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组  
4.        fun2(i) ;  
5.    }  
6.    public static <T> T[] fun1(T...arg){  // 接收可变参数  
7.        return arg ;            // 返回泛型数组  
8.    }  
9.    public static <T> void fun2(T param[]){   // 输出  
10.        System.out.print("接收泛型数组：") ;  
11.        for(T t:param){  
12.            System.out.print(t + "、") ;  
13.        }  
14.    }  
15.};  

最后说一下泛型的好处，Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型在使用中还有一些规则和限制：
    1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
    2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
    3、泛型的类型参数可以有多个。
    4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上成为“有界类型”。