泛型的作用及使用场景

在没有泛型之前，从集合读取到的每一个对象都必须进行转换。如果有人不小心插入了类型错误的对象，在运行时的转换处理就会出错。有了泛型之后，可以告诉编译器每个集合中接受哪些对象类型。编译器自动地为你的插入进行转化，并在编译时告知是否插入了类型错误的对象。这样可以使程序既更安全，也更清楚。

《Effective Java》 第5章 泛型

语法

1. 普通使用

public class Point {  
  
    private T data;  
  
    public T getData() {  
        return data;  
    }  
  
    public void setData(T data) {  
        this.data = data;  
    }  
}  

2. 受限

class Info{    // 此处泛型只能是数字类型  
    private T var ;        // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){    // 直接打印  
        return this.var.toString() ;  
    }  
};  

3. 泛型接口（两种写法）

interface Info{        // 在接口上定义泛型  
    public T getVar() ;    // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl implements Info{    // 定义泛型接口的子类  
    private String var ;                // 定义属性  
    public InfoImpl(String var){        // 通过构造方法设置属性内容  
        this.setVar(var) ;      
    }  
    public void setVar(String var){  
        this.var = var ;  
    }  
    public String getVar(){  
        return this.var ;  
    }  
};  

interface Info{        // 在接口上定义泛型  
    public T getVar() ;    // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl implements Info{    // 定义泛型接口的子类  
    private T var ;                // 定义属性  
    public InfoImpl(T var){        // 通过构造方法设置属性内容  
        this.setVar(var) ;      
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
};  

4. 泛型方法

class Demo{  
    public  T fun(T t){            // 可以接收任意类型的数据  
        return t ;                    // 直接把参数返回  
    }  
};

5. 泛型数组

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

6. 泛型嵌套

class Info{        // 接收两个泛型类型  
    private T var ;  
    private V value ;  
    public Info(T var,V value){  
        this.setVar(var) ;  
        this.setValue(value) ;  
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
};  
class Demo{  
    private S info ;  
    public Demo(S info){  
        this.setInfo(info) ;  
    }  
    public void setInfo(S info){  
        this.info = info ;  
    }  
    public S getInfo(){  
        return this.info ;  
    }  
};  

public class GenericsDemo{  
    public static void main(String args[]){  
        Demo> d = null ;        // 将Info作为Demo的泛型类型  
        Info i = null ;    // Info指定两个泛型类型  
        i = new Info("李兴华",30) ;     // 实例化Info对象  
        d = new Demo>(i) ;    // 在Demo类中设置Info类的对象  
        System.out.println("内容一：" + d.getInfo().getVar()) ;  
        System.out.println("内容二：" + d.getInfo().getValue()) ;  
    }  
}; 

注意

1. 泛型、 两种写法的区别

是可以任意写，不受限制,

如若泛型是声明返回值的类型，或者是声明在类层次的

例如：

private static  T fun1(List list) {
}

和

public interface Main {
    public void fun(T t);
}
//然后

public class MainImpl {
    @override
    public void fun(String str) {
    }
}

2、子类无法使用父类的泛型类型进行接受

class Info{  
    private T var ;        // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){    // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo23{  
    public static void main(String args[]){  
        Info i1 = new Info() ;   // 泛型类型为String  
        Info