JDK 1.5 新特性——泛型

　　Java中的泛型(Generics)跟C++中的模版大同小异，都是为了简化代码，为变成提供了方便！

1.类型安全

     泛型的主要目标是提高Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度

上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中。

2.消除强制类型转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

3.潜在的性能收益

    泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型

转换）插入生成的字节码中。但是更多类型 信息可用于编译器这一事实，为未来版本的JVM 的优化带来可能.

JDK5以前的List操作:

     类List的函数add接受一个Object参数：

public boolean add(java.lang.Object element);//存入的是Object对象，不能确定对象类型

    类List的函数get函数从中取出一个对象:

public java.lang.Object get(int index) throws IndexOutOfBoundsException//取出的也是Object对象，需要强制类型转换

一般编码示例:

List stringList1 = new ArrayList();
stringList1.add("Java 5");
stringList1.add("with generics");
String s1 = (String) stringList1.get(0);

　　如果我们能限制装入对象的数据类型,使其保持一致,就能很好的解决这个问题,这样取数据的时候将不要数据类

型的强制转化，这时泛型便应运而生。

ArrayList <String> al = new ArrayList() <String>;
al.add("one"):
//al.add(1);//编译不通过
Employee emp=employeeList.get(0);//不需要强制类型转换

/*
 * 局限性，一旦类确定， 就必行用相同的数据类型
 * 
 * */
class Student {
    public String getName() {
        return "student";
    }
}

class Worker {

}

class Tool<T> {
    private T t = null;

    public void setMyClass(T t) {
        this.t = t;
    }

    public T getMyClass() {
        return t;
    }

    @Override
    public String toString() {
        return t.getClass().getName();
    }
}

public class GenClass {
    public static void main(String[] args) {
        Tool<Student> s = new Tool<Student>();
        s.setMyClass(new Student());
        System.out.println(s.getMyClass());
    }
}

/**
 * 泛型类+泛型方法+静态泛型方法
 */
class Gen<T> {
    /*
     * 使用泛型类的泛型
     */
    public void show(T t) {
        System.out.println(t);
    }

    /*
     * 泛型方法
     */
    public <M> void show1(M m) {
        System.out.println(m);
    }

    /*
     * 静态泛型方法
     */
    public static <S> void show2(S s) {
        System.out.println(s);
    }

}

public class GenClassAndMethod {

    public static void main(String[] args) {
        Gen.show2(123);
        Gen<String> g = new Gen<String>();
        g.show("325");
        // g.show(123);//报错
        g.show1(123);// √

    }
}

/**
 * 泛型接口
 */
interface face<T> {
    public void show(T t);
}

/*
 * 实现接口的时候明确所操作的数据类型
 */
class ImpClass1 implements face<String> {

    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

/*
 * 实现接口的时候不明确所操作的数据类型
 * 
 * 用户操作的时候在定义数据类型
 */
class ImpClass2<T> implements face<T> {

    @Override
    public void show(T s) {
        System.out.println(s);
    }
}

public class GenInterfase {
    public static void main(String[] args) {
        ImpClass1 impClass1 = new ImpClass1();
        impClass1.show("123");
        ImpClass2<Integer> i2 = new ImpClass2<Integer>();
        // i2.show("1243");//报错
        i2.show(123);
    }

package bin.ykb.advanced;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 占位符
 */

public class Placeholder {
    private static void show1(ArrayList<?> as) {//直接利用占位符对操作类型进行占位,对任意类型的ArrayList<> 都可以操作,原理和泛型方法差不多
        Iterator<?> i = as.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }
    }

    private static void show2(ArrayList<String> as) {// 这是为ArrayList<String>量身定做打印,没有什么扩展性
        Iterator<String> i = as.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }
    }

    public static void main(String[] args) {
        ArrayList<String> as = new ArrayList<String>();
        as.add("a");
        as.add("b");
        as.add("c");

        ArrayList<Integer> ai = new ArrayList<Integer>();
        ai.add(1);
        ai.add(2);
        ai.add(3);

        show1(as);
        show1(ai);
        System.out.println("============");
        show2(as);
        // show2(ai);
    }
}

 最后就是泛型限定。

<? extends Person> 参数只能是Person或Person 类的子类

　　
<? super Person> 参数只能是Person,或Person类的父类

　　参见java.util.Collections  中的方法

　　public static <T> boolean addAll(Collection<? super T> c, T... elements)

 参考：

　　　　http://blog.csdn.net/jiang_bing/article/details/6912115

转载请注明出处：

博客园_yokoboy

http://www.cnblogs.com/yokoboy/archive/2012/07/25/2608165.html