浅谈泛型

   泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
     在网上看到有一个人这样比喻：
   泛型一般在集合里会用到，比如，一个房子对象，房子什么人都可以住，这样就存在安全问题，但是这样，房子<我的家人>，这样就只有我的家人才能住进去，这就是泛型。
   下面看几个例子：

泛型类：
例1、

class Gen<T>{
    private  T ob;
    public Gen(T ob){
        this.ob=ob; 
    }
    public T getOb() {
        return ob;
    }
    public void setOb(T ob) {
        this.ob = ob;
    }
    public void showType(){

        System.out.println("T的实际类型是："+ ob.getClass().getName());
    }
}


public class FanXinDemo {

    public static void main(String[] args) {
        //定义泛型Gen的一个为Integer的版本
        Gen<Integer> inob = new Gen<Integer>(88);
        inob.showType();
        int i = inob.getOb();
        System.out.println("value的值为"+ i);
        System.out.println("-------------------------------------");
        //定义泛型Gen的一个String的版本

        Gen<String> iGen = new Gen<String>("Hello world");
        iGen.showType();
        String st= iGen.getOb();
        System.out.println("value的值为"+ st);

    }
}

运行结果为：

没有使用泛型：

例2、

class Gen2 {
    private Object ob; // 定义一个通用类型成员

    public Gen2(Object ob) {
        this.ob = ob;
    }

    public Object getOb() {
        return ob;
    }

    public void setOb(Object ob) {
        this.ob = ob;
    }

    public void showTyep() {
        System.out.println("T的实际类型是: " + ob.getClass().getName());
    }
}

public class FanXinDemo {
    public static void main(String[] args) {
        // 定义类Gen2的一个Integer版本
        Gen2 intOb = new Gen2(new Integer(88));
        intOb.showTyep();
        int i = (Integer) intOb.getOb();
        System.out.println("value= " + i);
        System.out.println("---------------------------------");
        // 定义类Gen2的一个String版本
        Gen2 strOb = new Gen2("Hello Gen!");
        strOb.showTyep();
        String s = (String) strOb.getOb();
        System.out.println("value= " + s);
    }
}

运行结果：

可以看出，两个例子的运行结果一样。但是例2需要强制类型转换。

class StringFoo {
    private String x;

    public StringFoo(String x) {
        this.x = x;
    }

    public String getX() {
        return x;
    }

    public void setX(String x) {
        this.x = x;
    }
}

class DoubleFoo {
    private Double x;

    public DoubleFoo(Double x) {
        this.x = x;
    }

    public Double getX() {
        return x;
    }

    public void setX(Double x) {
        this.x = x;
    }
}
/**
因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了
*/
class ObjectFoo {
    private Object x;

    public ObjectFoo(Object x) {
        this.x = x;
    }

    public Object getX() {
        return x;
    }

    public void setX(Object x) {
        this.x = x;
    }
}

public class FanXinDemo {
    public static void main(String[] args) {
         ObjectFoo strFoo = new ObjectFoo(new String("Hello Generics!"));
         ObjectFoo douFoo = new ObjectFoo(new Double(new Double("33")));
         ObjectFoo objFoo = new ObjectFoo(new Object());
         System.out.println("strFoo.getX=" + (String) strFoo.getX());
         System.out.println("douFoo.getX=" + (Double) douFoo.getX());
         System.out.println("objFoo.getX=" + objFoo.getX());

    }
}

解说：在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法。

泛型实现：
强制类型转换很麻烦，我还要事先知道各个Object具体类型是什么，才能做出正确转换。否则，要是转换的类型不对，比如将字符串强制转换为Integer，那么编译的时候不会报错，可是运行的时候就挂了。那有没有不强制转换的办法—-有，改用 Java5泛型来实现。

class GenericsFoo<T> {
    private T x;

    public GenericsFoo(T x) {
        this.x = x;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }
}

public class GenericsFooDemo {
    public static void main(String args[]) {
        GenericsFoo<String> strFoo = new GenericsFoo<String>("Hello Generics!");
        GenericsFoo<Double> douFoo = new GenericsFoo<Double>(new Double("33"));
        GenericsFoo<Object> objFoo = new GenericsFoo<Object>(new Object());
        System.out.println("strFoo.getX=" + strFoo.getX());
        System.out.println("douFoo.getX=" + douFoo.getX());
        System.out.println("objFoo.getX=" + objFoo.getX());
    }
}
两种方法的运行结果：

关于泛型在集合中的运用，大概的概括一下：

泛型可以用””代表，任意类型的。
解释： “”是泛型的默认值，可以被任意类型所代替，如：
List list = new ArayList()；这个就定义了一个String类型的”泛型“集合，那么T的类型就是字符串。
List list = new ArayList()；
可以赋值给list：list.add(“StringBatch”);
可以获取到list的值：list.get(0),结果就是”StringBatch“；
这个时候T的类型也是String。也就是说T是动态的，可以被任意指定类型。