java 泛型

为什么要使用泛型：

首先看一个例子：

public class GenericTest {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);

        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
}

定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

 在如上的编码过程中，我们发现主要存在两个问题：

1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。

改用泛型：

public class GenericTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("qqyumidi");
        list.add("corn");
        //list.add(100);   // 1  提示编译错误

        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i); // 2
            System.out.println("name:" + name);
        }
    }
}

采用泛型写法后，在//1处想加入一个Integer类型的对象时会出现编译错误，通过List<String>，直接限定了list集合中只能含有String类型的元素，从而在//2处无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。

使用泛型<>好处：

1.将运行时期出现的ClassCastException转移到了编译时期，方便于程序员解决问题，让运行时期问题减少。

2.避免了强制转换的麻烦

定义泛型类格式：

class Tools<T>{}

定义泛型方法：

 public <T> void show(T t) 注意:<>放在修饰符后面，返回值前面  {

}

例：

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 GenDemo {    public static void main(String[] args) {        // 定义泛型类Gen的一个Integer版本        Gen<Integer> intOb = new Gen<Integer>(88);        intOb.showType();        int i = intOb.getOb();        System.out.println("value= " + i);        System.out.println("----------------------------------");        // 定义泛型类Gen的一个String版本        Gen<String> strOb = new Gen<String>("Hello Gen!");        strOb.showType();        String s = strOb.getOb();        System.out.println("value= " + s);    }}

注意：

1.静态方法不可以访问定义类上的泛型

class Tools<T>
        {
            public static void method(T t)
            {
            }
        }
        错误！！

但可以将泛型定义在方法上：

 class Tools<T>
        {
            public static <T> void method(T t)
            {
            }
        }

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 GenDemo2 {
    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);
    }
}

关于类型通配符？

参看http://www.linuxidc.com/Linux/2013-10/90928.htm