java泛型总结

1 说明

1）Generics是对java语言类型系统的一种扩展，以支持创建可以按类型进行参数化的类或者方法。

2）泛型的优点：

　　1. 类型安全（使用泛型时，编译器可以捕获附加类型信息，从而类型错误在编译时被捕获而不是运行时来进行检测）

　　2. 消除强制类型转换，减少了代码出错的可能性，并且使代码更加可读

2 泛型类实例

不使用泛型，此种情况需要类型转换

package com.wish.generic;

public class Person {
    private Object x;
    private Object y;
    private Object z;
    public Object getX(){
        return x;
    }
    public void setX(Object x){
        this.x =x;
    }
    public Object getY(){
        return y;
    }
    public void setY(Object y){
        this.y =y;
    }
    public Object getZ(){
        return z;
    }
    public void setZ(Object z){
        this.z =z;
    }
    public static void main(String[] args) {
        Person s = new Person();
        s.setY(20);
        int x = (Integer)s.getX();
        System.out.println(x);
    }

}

使用泛型：

package com.wish.generic;

public class PersonG<T1,T2>{
    private T1 x;
    private T2 y;
    public T1 getX(){
        return x;
    }
    public void setX(T1 x){
        this.x = x;
    }
    public T2 getY(){
        return y;
    }
    public void setY(T2 y){
        this.y = y;
    }
    public static void main(String[] args){
        PersonG<Integer,String> pg = new PersonG<Integer,String>(); //实例化时即可定义类型
        pg.setX(20);
        pg.setY("this is a string");
        System.out.println(pg.getX());
        System.out.println(pg.getY());
    }
}

3.泛型方法

说明：

　　1)泛型的声明必须在方法的修饰符（public，static，final，abstract等）之后，返回值声明之前

　　2）和泛型类一样，可以声明多个泛型，用逗号隔开

泛型方法类：

package com.wish.generic;
public class GenFunction {
    public static<T> void display(T t){
        System.out.println(t.getClass());
    }
}

测试类：

package com.wish.generic;

public class Driver {
    public static void main(String[] args) {
        GenFunction.display(11);
        GenFunction.display(11f);
        GenFunction.display("abcd");
    }
}

输出：

class java.lang.Integer
class java.lang.Float
class java.lang.String

关于类型擦除的说明：类型擦除是指运行期不关注泛型的类型信息，但是t.getClass返回的是实例的类型类型而不是泛型的信息

4.注意事项

1）Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉（类型擦除）

2）泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。