JAVA泛型

1.概述
泛型是JAVA SE 1.5的新特性。
如果一个类或接口上有一个或多个类型变量，那它就是泛型。类型变量由尖括号界定，放在类或接口名的后面：
      public interface List extends Collection {


泛型的本质：将操作的数据类型被指定为一个参数。
     List list=…
     List接口里的get方法是这样的：
           T get(int index);
     通过泛型，就可以让编译器对类型进行检查

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

2.为什么要使用泛型
理解Java泛型最简单的方法是把它看成一种便捷语法，能节省你某些Java类型转换(casting)上的操作：
        1 List box = ...;
        2 Apple apple = box.get(0);
       上面的代码自身已表达的很清楚：box是一个装有Apple对象的List。get方法返回一个Apple对象实例，这个过程不需要进行类型转换。
没有泛型，上面的代码需要写成这样：
        1 List box = ...;
        2 Apple apple = (Apple) box.get(0);
     
泛型的主要好处就是让编译器保留参数的类型信息，执行类型检查，执行类型转换操作：编译器保证了这些类型转换的绝对无误。
相对于依赖程序员来记住对象类型、执行类型转换——这会导致程序运行时的失败，很难调试和解决，而编译器能够帮助程序员在编译时强制进行大量的类型检查，发现其中的错误。

如果我们试图在List装入另外一种对象，编译器就会提示错误：
          list.add(apple); // 不能编译
          类型安全的读取数据…

当我们在使用List对象时，它总能保证我们得到的是一个Apple对象：
       Apple apple = list.get(0);

3.泛型与Object
没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
 举例

public 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 showTyep() {
                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.showTyep();
                int i= intOb.getOb();
                System.out.println("value= " + i);

                System.out.println("----------------------------------");

                //定义泛型类Gen的一个String版本
                Gen<String> strOb=new Gen<String>("Hello Gen!");
                strOb.showTyep();
                String s=strOb.getOb();
                System.out.println("value= " + s);
        }
}

运行结果：
T的实际类型是: java.lang.Integer
value= 88
----------------------------------
T的实际类型是: java.lang.String
value= Hello Gen!

未使用泛型举例

public 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);
        }
}

运行结果：

T的实际类型是: java.lang.Integer

value= 88

----------------------------------

T的实际类型是: java.lang.String

value= Hello Gen!

4.泛型与继承
     假设有父类Fruit<-Apple,Strawberry，Apple<-FujiApple

以下代码无效：
     List apples;
     List fruits = ...;
     Fruits= apples;

为什么一箱苹果就不是一箱水果了呢？现在假设以上操作允许，那么下面的操作会出错误
     fruits.add(new Strawberry());

一个List中装入了各种不同类型的子类水果，这显然是不可以的，因为我们在取出List中的水果对象时，就分不清楚到底该转型为苹果还是草莓了。
所以，泛型在使用时并不考虑类与类之间的继承关系， List并不是 List的子类。

5.泛型与通配符?
不使用泛型，打印集合中所有元素的代码

void printCollection(Collection c) {
    Iterator i=c.iterator();
    for (k=0;k < c.size();k++) {
        System.out.println(i.next());
    }
}

使用泛型，打印集合中所有元素的代码

void printCollection(Collection<Object> c) {
    for (Object e:c) {
        System.out.println(e);
    }
}

使用泛型的版本只能接受元素类型为Object类型的集合如ArrayList