10_Java泛型

本章章节

> 10.1为什么需要泛型
> 10.2泛型类
> 10.3 泛型接口
> 10.4泛型方法
> 10.5用泛型定义数组
> 10.6建立类型为泛型类的数组
> 10.7泛型类充当泛型的实例化类
> 10.8通配符

　　Java泛型（generics）是JDK 5中引入的一个新特性，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。声明的类型参数在使用时用具体的类型来替换。泛型最主要的应用是在JDK 5中的新集合类框架中。

10.1 为什么需要泛型

　　现在我要设计一个可以表示坐标的点类，坐标由x和y组成。可是不同的人，可能想要知道的坐标不一样。有人想要坐标用整型表示；有人想要坐标用小数表示；有有人想要坐标用字符串表示，如下：

A这个人想要看到整型的坐标，例如：(10, 20)。所以我们要定义一个IntPoint类如下：

//IntPoint.java

public class IntPoint {
　　private int x;
　　private int y;

　　public IntPoint(){
　　}

　　public IntPoint(int x, int y) {
　　　　this.x = x;
　　　　this.y = y;
　　}

　　public int getX() {
　　　　return x;
　　}

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

　　public int getY() {
　　　　return y;
　　}

　　public void setY(int y) {
　　　　this.y = y;
　　}
}

B这个人想要看到小数的坐标，例如(10.5, 20.6)。所以我们要定义一个DoublePoint类如下：

//DoublePoint.java

public class DoublePoint {
　　private double x;
　　private double y;

　　public DoublePoint(){
　　}

　　public DoublePoint(double x, double y) {　　
　　　　this.x = x;
　　　　this.y = y;
　　}

　　public double getX() {
　　　　return x;
　　}

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

　　public double getY() {
　　　　return y;
　　}

　　public void setY(double y) {
　　　　this.y = y;
　　}
}

C这个人想要看到字符串的坐标。例如：("东经180度", y="北纬120度")，所以我们要定义一个StringPoint类如下：

//StringPoint.java

public class StringPoint {
　　private String x;
　　private String y;

　　public StringPoint(){
　　}

　　public StringPoint(String x, String y) {
　　　　this.x = x;
　　　　this.y = y;
　　}

　　public String getX() {
　　　　return x;
　　}

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

　　public String getY() {
　　　　return y;
　　}

　　public void setY(String y) {
　　　　this.y = y;
　　}
}

使用过程如下：

//TestPoint.java

public class TestPoint {
　　public static void main(String[] args) {
　　　　IntPoint ptInt = new IntPoint(10, 20);
　　　　System.out.println("(" + ptInt.getX() + "," + ptInt.getY() + ")");

　　　　DoublePoint ptDouble = new DoublePoint(10.5, 20.6);
　　　　System.out.println("(" + ptDouble.getX() + "," + ptDouble.getY() + ")");

　　　　StringPoint ptString = new StringPoint("东经180度", "北纬120度");
　　　　System.out.println("(" + ptString.getX() + "," + ptString.getY() + ")");
　　}
}

　　我们发现其实上面的三个类的基本形式都是一模一样的，除了表示坐标的x，y数据类型不一样而已。这样写出的代码冗余度太高，而且维护和扩展比较麻烦。比如我现在想要增加一个打印坐标的功能，我不得不在每一个坐标类都增加一个disp函数。那么有没有什么方法能帮我们做到只定义一个点类，就可以表示所有的可能呢？

第一种解决方法是利用Object类，因为Object是所有类的父类，所以将点类声明如下即可：

//ObjectPoint.java

public class ObjectPoint
{
    private Object x;
    private Object y;

    public ObjectPoint()
    {
    }

    public ObjectPoint(Object x, Object y)
    {
        this.x = x;
        this.y = y;
    }

    public Object getX()
    {
        return x;
    }

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

    public Object getY()
    {
        return y;
    }

    public void setY(Object y)
    {
        this.y = y;
    }
}

使用过程如下：

//TestPoint.java

public class TestPoint
{
    public static void main(String[] args)
    {
        ObjectPoint ptObj1 = new ObjectPoint(new Integer(10), new Integer(20));
　　　　　//或ObjectPoint ptObj1 = new ObjectPoint(10, 20);

        int iV1 = Integer.parseInt(ptObj1.getX().toString());
　　　　　//或采用int iV1 = (Integer)(ptObj1.getX());强制类型转换为Integer后再自动拆箱

        int iV2 = Integer.parseInt(ptObj1.getY().toString());
        System.out.println("(" + iV1 + "," + iV2 + ")");

        ObjectPoint ptObj2 = new ObjectPoint(new Double(10.5), new Double(20.6));
　　　　　//或ObjectPoint ptObj2 = new ObjectPoint(10.5, 20.6);

        double dV1 = Double.parseDouble(ptObj2.getX().toString());
        double dV2 = Double.parseDouble(ptObj2.getY().toString());

        System.out.println("(" + dV1 + "," + dV2 + ")");

        ObjectPoint ptObj3 = new ObjectPoint(new String("东经180度"), new String("北纬120度"));
　　　　　//或ObjectPoint ptObj3 = new ObjectPoint("东经180度", "北纬120度");

        String sV1 = ptObj3.getX().toString();
        String sV2 = ptObj3.getY().toString();
        System.out.println("(" + sV1 + "," + sV2 + ")");
    }
}

　　在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。比如写ObjectPoint ptObj1 = new ObjectPoint(10, 20);的时候，容易造成一些隐藏的问题，一不小心写成：ObjectPoint ptObj1 = new ObjectPoint(10.3, 20);编译的时候不报错，但是运行的时候就会有类型不匹配问题。所以Object是一种弱类型检测，执行的时候才知道具体的数据类型，所以不安全。

　　第二种方法是利用泛型（Generics），泛型的目的在于对参数类型本身进行参数化。它属于强类型检测（在使用的时候数据类型是确定的，编译器和执行器可以进行类型检测）。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

10.2 泛型类

　　声明包含泛型的类的格式如下：

　　   [访问修饰符]  class 类名<泛型1, 泛型2, …>{

　　　　[访问权限] 泛型类型标识  变量名称;

　　　　[访问权限] 构造方法([<泛型类型>] 参数名称){}

　　　　[访问权限] 泛型类型标识  getXxx(){}

　　　　[访问权限] 返回值类型声明 setXxx(泛型类型标识 变量名称){}

　　}

比如：

/*
 * 此处声明了一个包含泛型T的泛型类，T代表所有可能的类型
 * 而T的实际类型在MyGenerics类实例化时指定。
 */
class MyGenerics<T>
{
    private T x; // x为泛型成员
    public MyGenerics(T x)
    { // 构造方法的参数类型为泛型T
        this.x = x;
    }

    public void setX(T x)
    { // setX方法的参数类型为泛型T
        this.x = x;
    }

    public T getX()
    { // setX方法的返回类型为泛型T
        return this.x;
    }
}

　　创建泛型类的实例时，可以使用一对尖括号指定泛型的真正类型，但是需要注意的是，尖括号中的类型必须是类类型，比如对于10，不能为int，而是Integer。

　　泛型对象实例化格式如下：

　　　　类名称<具体类> 对象名称 = new 类名称<具体类>();

比如：

//将T替换为Boolean，并调用一个参数 构造函数，传递的值为boolean类型
MyGenerics<Boolean> gen1 = new MyGenerics<Boolean>(true);
gen1.setX(false); // 调用setX方法，传递boolean值
System.out.println(gen1.getX()); // 调用getX方法，返回boolean值


//将T替换为Integer，并调用一个参数 构造函数，传递的值为int类型
MyGenerics<Integer> gen2 = new MyGenerics<Integer>(10);
gen2.setX(20); // 调用setX方法，传递int值
System.out.println(gen2.getX()); // 调用getX方法，返回int值

泛型使用的注意点：

　　1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。

　　2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。如：gen2 = gen1，则会报错。

　　3、泛型的类型参数可以有多个。

　　4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。

　　5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");

　　下面我们利用泛型来解决我们之前坐标的问题：

//GenericsPoint.java

public class GenericsPoint<T>
{
    private T x;
    private T y;

    public GenericsPoint()
    {
    }

    public GenericsPoint(T x, T y)
    {
        this.x = x;
        this.y = y;
    }

    public T getX()
    {
        return x;
    }

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

    public T getY()
    {
        return y;
    }

    public void setY(T y)
    {
        this.y = y;
    }
}

使用过程如下：

public class TestGenerics
{
    public static void main(String[] args)
    {
        GenericsPoint<Integer> gen1 = new GenericsPoint<Integer>(10, 20);
        System.out.println("(" + gen1.getX() + "," + gen1.getY() + ")");

        GenericsPoint<Double> gen2 = new GenericsPoint<Double>(10.5, 20.6);
        System.out.println("(" + gen2.getX() + "," + gen2.getY() + ")");

        GenericsPoint<String> gen3 = new GenericsPoint<String>("东经180度", "北纬120度");
        System.out.println("(" + gen3.getX() + "," + gen3.getY() + ")");
    }
}

　　需要注意的是，泛型与子类继承的限制：在泛型操作中，子类的泛型类型是无法使用父类的泛型类型接收的。

　　由前面的例子，我们知道，Object是所有类的父类，因此，所有的类型的实例都可赋值给声明为Object类型的变量。如：

Boolean f1 = new Boolean(true);

Integer f2 = new Integer(1);

Object f = f1;   //OK

f=f2;   //OK

　　但在实例化泛型类时，将泛型指定为Object类型却不存在着和其他类型之间的兼容性：

GenericsPoint<Integer> gen1 = new GenericsPoint<Integer>(10, 20);
GenericsPoint<Double> gen2 = new GenericsPoint<Double>(10.5, 20.6);
GenericsPoint<Object> gen = gen1; // gen1和gen类型并不兼容，发生编译错误

　　除了可以定义包含一个泛型的类的定义之外，还可以包含多个泛型的类定义。其定义格式如下：

[修饰符] class类名<T1, T2, …> {
    [修饰符] T1 f1;
    [修饰符] T2 f2;
    //....
}

示例如下：

class MyGenerics<T1, T2>
{
    private T1 x;
    private T2 y;

    public MyGenerics()
    {
    }

    public MyGenerics(T1 x, T2 y)
    {
        this.x = x;
        this.y = y;
    }

    public void setXY(T1 x, T2 y)
    {
        this.x = x;
        this.y = y;
    }

    public T1 getX()
    {
        return this.x;
    }

    public T2 getY()
    {
        return this.y;
    }
}

　　此时MyGenerics泛型类的实例化格式：

　　　　给出泛型T1, T2的实际类型：

　　　　　　MyGenerics<Integer, String> gen1 = new MyGenerics<Integer, String>(1001, "张三");

　　　　也可以不给出T1, T2的实际类型。此时T1,T2将被默认为是Object类型：

　　　　　　MyGenerics gen2 = new MyGenerics();

　　但通常不会这么干。

　　在泛型类中的泛型成员不能直接实例化，其实例必须要通过方法的参数传递给泛型成员，看下面的代码：

public class MyGenerics<T>
{
    private T[] array; //此处不能用new T[]实例化array

    public void setArray(T[] array)
    {
        this.array = array;
    }

    public T[] getArray()
    {
        return array;
    }
}

可以通过方法的泛型参数，将数组的实例传递给类中的泛型数组。看下面代码：

String[] color = {"red", "green", "blue"};

MyGenerics<String> gen = new MyGenerics<String>();

gen.setArray(color);  //向泛型成员array传递实际的字符串数组

String[] strs = gen.getArray();//读取泛型成员array的值，将其赋给字符串数组strs

10.3 泛型接口

　　在JDK1.5之后，不仅仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法类似，也是在接口名称后面加上<T>。

　　泛型接口定义格式：

　　　　[访问权限]  interface  接口名称<泛型标识>{}

比如：

interface I<T1, T2>{
　　void fun1(T1 t);
　　T2 fun2();
}

　　泛型接口实现的两种方式：

　　　　定义子类：在子类的定义上也声明泛型类型。

　　　　定义子类：如果实现接口的子类不想使用泛型声明，则在实现接口的时候直接指定好其具体的操作类型即可。如果不指定，则此时泛型会自动变为Object。

　　实现泛型接口时，类在定义时可以不声明泛型接口中的泛型，此时接口中的泛型也会自动变为Object类型。如下：

public class IC implements I
{

    public void fun1(Object t)
    {…} //对应接口方法fun1的实现

    public Object fun2()
    {…} //对应接口方法fun2的实现

}

如果需要在实现泛型接口时，保留接口中的泛型，类在定义时就必须要保留泛型接口中的泛型声明。如下：

public class IC<T1, T2> implements I<T1, T2>{

public void fun1(T1 t){…} //对接口方法getT1的实现

public T2 fun2(){…} //对接口方法getT2的实现

}

此时可以声明泛型接口的变量，并利用泛型实现类进行实例化。如下：

I<String, Integer> i = new IC<String, Integer>();

在实现泛型接口时，也可直接指定接口中的泛型的实际类型。如下：

//实现接口I时，直接指定泛型T1、T2的类型
class IC implements I<String, Integer>
{

　　//由于指定接口I中T1类型为String，fun1参数t的类型必须为String
    public void fun1(String t)
    {…}

　　//由于指定接口I中T2类型为Integer，fun2返回类型必须为Integer
    public Integer fun2()
    {…}

}

同理，当包含泛型的类有继承关系的时候，如需保留父类泛型，需要在声明时加入父类泛型。如下：

public class SubGeneric<T1, T2, T3> extends Generic<T1, T2>
{
    private T3 f;

    public void setF(T3 f)
    {
        this.f = f;
    }

    public T3 getF()
    {
        return f;
    }
}

如果不保留父类中的泛型声明，则继承下来的T1与T2自动变为Object类型。建议父类中的泛型声明在子类中都要保留。

如果在继承时，不想保留父类中的泛型，但也不想使用默认的Object类型，此时可以直接指定父类中的泛型。如下：

public class SubGeneric<T3> extends Generic<String, Object>
{
    private T3 f;

    public void setF(T3 f)
    {
        this.f = f;
    }

    public T3 getF()
    {
        return f;
    }
}

10.4 泛型方法

　　之前的所有的泛型除了可以为类中的属性制定类型之外，也可以定义方法，泛型方法所在的类中是否是泛型类本身是没有任何关系的。泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型，使用如下的格式定义泛型方法。

　　泛型方法的简单定义：

　　　　[访问权限] <泛型标识>  泛型标识  方法名称([泛型标识  参数名称])

　　调用泛型方法和调用普通方法没有任何不同，只需传递含有具体类型的实参即可。比如：

class Demo
{
    public <T> T fun(T t)
    {    // 可以接收任意类型的数据
        return t;           // 直接把参数返回
    }
}

public class GenericsDemo
{
    public static void main(String args[])
    {
        Demo d = new Demo();       // 实例化 Demo 对象
        String str = d.fun("张三");     // 传递字符串
        int i = d.fun(30);             // 传递数字，自动装箱
        System.out.println(str);        // 输出内容
        System.out.println(i);         // 输出内容
    }
}

可以将泛型方法和泛型类结合起来使用，如下范例：

class Info<T>
{
    private T value;

    public Info(T value)
    {
        this.value = value;
    }

    public T getValue()
    {
        return this.value;
    }

    public void setValue(T value)
    {
        this.value = value;
    }

    public String toString()
    {
        return this.value.toString();
    }

}

public class TestGenerics
{
    public static <K> void conn(Info<K> a, Info<K> b)
    {
        System.out.println(a + " " + b);
    }

    public static void main(String[] args)
    {
        Info<Integer> infoInt1 = new Info<Integer>(10);
        Info<Integer> infoInt2 = new Info<Integer>(20);
        conn(infoInt1, infoInt2);

        Info<String> infoStr1 = new Info<String>("张三");
        Info<String> infoStr2 = new Info<String>("李四");
        conn(infoStr1, infoStr2);
    }
}

10.5 用泛型定义数组

　　在使用泛型方法的时候，也可以传递或返回一个泛型定义的数组。例如：

public class TestGenerics
{
    public static <T> T[] fun1(T... arr)
    {
        return arr;
    }

    public static <T> void fun2(T arr[])
    {
        for (T val : arr) {
            System.out.print(val + "  ");
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        Integer i[] = fun1(1, 2, 3, 4, 5, 6);
        fun2(i);

        String str[] = fun1("aaa", "bbb", "ccc", "ddd");
        fun2(str);
    }
}

　　泛型定义的数组在接收数据的时候，必须保证数据的一致性。即传入的参数类型必须统一。假如修改传入的参数类型，使其与其他参数类型不一致，编译时就会报错。例如：

　　　　Integer i[] = fun1(1, 2, 3, 4, 5.0f, 6); // 编译报错

10.6 建立类型为泛型类的数组

　　除了可以用泛型去定义数组外，还可以定义泛型类的数组。如果要建立泛型类的数组，需要注意new关键字后面不要加入泛型的实际类型名。如下：

　Generic<String>[]  gs;   //声明泛型类的数组

//先对泛型数组进行初始化
gs = new Generic[5]; //不要写成new Generic<String>[5]

//再分别为每一个数组元素进行初始化
gs[0]=new Generic<String>(); //为第一个数组元素赋值

//…

实例如下：

class Info<T>
{
    private T value;

    public Info(T value)
    {
        this.value = value;
    }

    public T getValue()
    {
        return this.value;
    }

    public void setValue(T value)
    {
        this.value = value;
    }

    public String toString()
    {
        return this.value.toString();
    }
}


@SuppressWarnings("unchecked")
public class TestGenerics
{
    public static void main(String[] args)
    {
        Info<String>[] info = new Info[5];

        for (int i = 0; i < info.length; i++) {
            info[0] = new Info<String>("hello" + i);
            System.out.println(info[0]);
        }
    }
}

10.7 泛型类充当泛型的实例化类

　　之前所讲解的全部泛型操作，都是直接用一个实际的类来实例化的。Java中也允许用一个泛型类来实例化另一个泛型类。这种结构称为泛型嵌套。

　　首先定义了两个泛型类Info和Demo，如下所示：

class Info<T, V>
{    //  接收两个泛型类型

    private T var;
    private V value;

    public Info(T var, V value)
    {
        this.setVar(var);
        this.setValue(value);
    }

    public void setVar(T var)
    {
        this.var = var;
    }

    public void setValue(V value)
    {
        this.value = value;
    }

    public T getVar()
    {
        return this.var;
    }

    public V getValue()
    {
        return this.value;
    }
}

class Demo<S>
{
    private S info;

    public Demo(S info)
    {
        this.setInfo(info);
    }

    public void setInfo(S info)
    {
        this.info = info;
    }

    public S getInfo()
    {
        return this.info;
    }
}

现在希望Demo类中info属性是Info类的这种类型。但是Info类本身使用的时候需要设置两个泛型。如下所示：

public class GenericsDemo
{
    public static void main(String args[])
    {
        Info<String, Integer> i = new Info<String, Integer>("张三", 30);
        Demo<Info<String, Integer>> d = new Demo<Info<String, Integer>>(i);

        System.out.println("内容一：" + d.getInfo().getVar());
        System.out.println("内容二：" + d.getInfo().getValue());
    }
}

10.8 通配符

　　在开发中对象的引用传递是最常见的，但是在泛型类的操作中，进行引用传递的时候泛型类型必须匹配才可以传递，否则是无法传递的。例如：

class Info<T>
{
    private T var;

    public void setVar(T var)
    {
        this.var = var;
    }

    public T getVar()
    {
        return this.var;
    }

    public String toString()
    {
        return this.var.toString();
    }
}

public class GenericsDemo
{
    public static void main(String args[])
    {
        Info<String> i = new Info<String>();
        i.setVar("xiaoxiao");
        fun(i);
    }

    public static void fun(Info<Object> temp)
    { //接收Object泛型类型的Info对象
        System.out.println("内容：" + temp);
    }
}

由前面的知识我们知道，这里企图利用Info<Object>来接收Info<String>类型的变量，编译出错。

　　解决方法：

　　　　1. 泛型对象进行引用传递的时候，类型必须一致。将fun函数改成如下形式：

public static void fun(Info<String> temp){
　　System.out.println("内容：" + temp);
}

　　　　2. 将fun()方法中Info参数的泛型取消掉（不建议）：

public static void fun(Info temp){
　　System.out.println("内容：" + temp);
}

　　　　3. 利用通配符：

public static void fun(Info<?> temp){
　　System.out.println("内容：" + temp);
}

　　通配符“?”，表示可以接收任意的内容。但是使用“?”声明的对象，此时不能修改。如下：

public static void fun(Info<?> temp){
　　temp.setVar("star"); //不能修改，报错
　　System.out.println("内容：" + temp);
}

　　所以使用“?”表示只能接收，不能修改。

10.8.1 受限泛型

　　之前设置泛型类型的时候，只要是类就可以任意设置。但是在Java的泛型中可以指定一个泛型的上限和下限。

　　在引用传递中，泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。而范围下限使用super关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object 类。

　　设置上限：

　　　　声明对象：类名称<?  extends  类>  对象名称

　　　　定义类：[访问权限]  类名称<泛型标识  extends 类>{}

　　设置下限：

　　　　声明对象：类名称<?  super  类>  对象名称

　　

·设置上限实例（Info泛型类跟前面一样）：

public class GenericsDemo
{
    public static void main(String args[])
    {
        Info<Integer> i1 = new Info<Integer>();
        Info<Float> i2 = new Info<Float>();

        i1.setVar(30);
        i2.setVar(30.1f);

        fun(i1);
        fun(i2);
    }

    public static void fun(Info<? extends Number> temp)
    { // 只能接收Number及其子类
        System.out.println(temp);
    }
}

　　如果你在main方法中增加下面几行，则编译报错，因为fun方法已经限制了上限，必须是Number类及其子类。如下：

Info<String> i3 = new Info<String>();
i3.setVar("xiaoxiao");
fun(i3); //报错

　　你还可以在声明Info的时候才用class Info<T extends Number>{}的形式，则此时利用Info<String> i3 = new Info<String>()就会报错。

　　　　定义泛型类时，如果写成下面的代码：

　　　　　　public class Info<T>{}

　　　　相当于下面的定义方式：

　　　　　　public class Info<T extends Object>{}

·设置下限实例：

　　当使用的泛型只能在本类及其父类类型上应用的时候，就必须使用泛型的范围下限来配置。如下：

public class GenericsDemo
{
    public static void main(String args[])
    {
        Info<String> i1 = new Info<String>();     // 声明String的泛型对象
        Info<Object> i2 = new Info<Object>();     // 声明Object的泛型对象

        i1.setVar("hello");
        i2.setVar(new Object());

        fun(i1);
        fun(i2);
    }

    public static void fun(Info<? super String> temp)
    {//只能接收String或Object类型泛型
        System.out.print(temp + "、");
    }
}

　　在main方法中增加下面几行，则编译出错。因为fun已经设置了下限，则此时传递的必须是String类及其父类，如下：

Info<Integer> i3 = new Info<Integer>();
i3.setVar(30);
fun(i3);

感谢阅读。如果感觉此章对您有帮助，却又不想白瞟