Java泛型基础-优快云博客

整理自：http://www.cnblogs.com/lwbqqyumidi/p/3837629.html

一、为何要使用泛型

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”异常。

二、使用泛型：泛型类

创建类名的时候在类名后面加< T> 。

泛型的基本使用方法见如下代码：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        System.out.println("name:" + name.getData());
    }

}

class Box<T> {

    private T data;

    public Box() {

    }

    public Box(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

}

那么现在有一个问题：对于不同传入的类型实参，生成的相应对象实例的类型是不是一样的呢？

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);


        System.out.println(name.getClass() == age.getClass());    // true

    }

}

最后屏幕打印出来的是“true”，由此我们得出：

由此，我们发现，在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box），当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

同时，我们还需要注意一点，在逻辑上Box< Number >不能视为Box< Integer >的父类（虽然Integer是Number的子类），所以自然没有java的多态特性不能用于这种泛型使用方式上。

三、使用泛型：泛型方法

现在我们讲解如何创建泛型方法：


     public static void main(String[] args){
        // 实例化泛型类
        Point<Integer, Integer> p1 = new Point<Integer, Integer>();
        p1.setX(10);
        p1.setY(20);
        p1.printPoint(p1.getX(), p1.getY());

        Point<Double, String> p2 = new Point<Double, String>();
        p2.setX(25.4);
        p2.setY("东京180度");
        p2.printPoint(p2.getX(), p2.getY());
    }
}

    // 定义泛型类
    class Point<T1, T2>{
        T1 x;
        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 <T1, T2> void printPoint(T1 x, T2 y){
        T1 m = x;
        T2 n = y;
        System.out.println("This point is：" + m + ", " + n);
    }

注意最后的泛型方法在返回类型“ < T1, T2 > ”的后面还有void参数，这个我没有验证过，不知道是否正确。

下面还有一种使用类型通配符的用法：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

}

那个“？”就是类型通配符

同时，我们还能设定 类型通配符上限和类型通配符下限，如下所示：

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);

        //getUpperNumberData(name); // 1
        getUpperNumberData(age);    // 2
        getUpperNumberData(number); // 3
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

    public static void getUpperNumberData(Box<? extends Number> data){
        System.out.println("data :" + data.getData());
    }

}

类型通配符上限通过形如Box< ? extends Number >形式定义，相对应的，类型通配符下限为Box< ? super Number >形式，其含义与类型通配符上限正好相反，在此不作过多阐述了。

四、注意点

在静态环境下不允许类的参数是泛型类型！(包括静态方法等)
即如下代码是非法的：

public class Test<E>
{
    private static E o1;   //静态成员变量,非法

    public static void start(E o1)   //静态方法，非法
    {
        //do something
    }
}

还有其他的注意点感觉平时很少遇到，所以不在此罗列，详情看《Java语言程序设计-进阶篇》P10。