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

《Effective Java》 第5章 泛型

语法

1. 普通使用

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

2. 受限

class Info<T extends Number>{    // 此处泛型只能是数字类型  
    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<T>{        // 在接口上定义泛型  
    public T getVar() ;    // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl implements Info<String>{    // 定义泛型接口的子类  
    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<T>{        // 在接口上定义泛型  
    public T getVar() ;    // 定义抽象方法，抽象方法的返回值就是泛型类型  
}  
class InfoImpl<T> implements Info<T>{    // 定义泛型接口的子类  
    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> 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> T[] fun1(T...arg){    // 接收可变参数  
        return arg ;            // 返回泛型数组  
    }  
    public static <T> void fun2(T param[]){    // 输出  
        System.out.print("接收泛型数组：") ;  
        for(T t:param){  
            System.out.print(t + "、") ;  
        }  
    }  
};  

6. 泛型嵌套

class Info<T,V>{        // 接收两个泛型类型  
    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<S>{  
    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<Info<String,Integer>> d = null ;        // 将Info作为Demo的泛型类型  
        Info<String,Integer> i = null ;    // Info指定两个泛型类型  
        i = new Info<String,Integer>("李兴华",30) ;     // 实例化Info对象  
        d = new Demo<Info<String,Integer>>(i) ;    // 在Demo类中设置Info类的对象  
        System.out.println("内容一：" + d.getInfo().getVar()) ;  
        System.out.println("内容二：" + d.getInfo().getValue()) ;  
    }  
}; 

注意

1. 泛型<?>、 <T>两种写法的区别

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

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

例如：

private static <T> T fun1(List<T> list) {
}

和

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

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

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

class Info<T>{  
    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<String> i1 = new Info<String>() ;   // 泛型类型为String  
        Info<Object> i2 = null ;  
        i2 = i1 ;  
    }  
};  

就会报如下错误：

GenericsDemo23.java:17: 不兼容的类型  
找到： Info<java.lang.String>  
需要： Info<java.lang.Object>  
                i2 = i1 ;  

3、如果同一方法参数使用泛型，应该保证泛型类型一致

class Info<T>{    // 指定上限，只能是数字类型  
    private T var ;        // 此类型由外部决定  
    public T getVar(){  
        return this.var ;      
    }  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public String toString(){        // 覆写Object类中的toString()方法  
        return this.var.toString() ;      
    }  
};  
public class GenericsDemo{  
    public static void main(String args[]){  
        Info<Integer> i1 = new Info<Integer>() ;  
        Info<String> i2 = new Info<String>() ;  
        i1.setVar(30) ;        // 设置内容  
        i2.setVar("aoyoungboy") ;        // 设置内容  
        add(i1,i2) ;  
    }  
    public static <T> void add(Info<T> i1,Info<T> i2){  
        System.out.println(i1.getVar() + " " + i2.getVar()) ;  
    }  
};  

就会报如下错误：

javac GenericsDemo.java  
GenericsDemo29.java:19: 无法将 GenericsDemo 中的 <T>add(Info<T>,Info<T>) 应用  
于 (Info<java.lang.Integer>,Info<java.lang.String>)  
add(i1,i2) ;