Java泛型学习二

通配符的使用

　　上一篇中知道，Box<Number>和Box<Integer>实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢？

为了弄清这个问题，我们继续看下下面这个例子:

 1 public class GenericTest {
 2
 3     public static void main(String[] args) {
 4
 5         Box<Number> name = new Box<Number>(99);
 6         Box<Integer> age = new Box<Integer>(712);
 7
 8         getData(name);
 9
10         //The method getData(Box<Number>) in the type GenericTest is
11         //not applicable for the arguments (Box<Integer>)
12         getData(age);   // 1
13
14     }
15
16     public static void getData(Box<Number> data){
17         System.out.println("data :" + data.getData());
18     }
19
20 }

我们发现，在代码//1处出现了错误提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。显然，通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类。那么，原因何在呢？

 1 public class GenericTest {
 2
 3     public static void main(String[] args) {
 4
 5         Box<Integer> a = new Box<Integer>(712);
 6         Box<Number> b = a;  // 1
 7         Box<Float> f = new Box<Float>(3.14f);
 8         b.setData(f);        // 2
 9
10     }
11
12     public static void getData(Box<Number> data) {
13         System.out.println("data :" + data.getData());
14     }
15
16 }
17
18 class Box<T> {
19
20     private T data;
21
22     public Box() {
23
24     }
25
26     public Box(T data) {
27         setData(data);
28     }
29
30     public T getData() {
31         return data;
32     }
33
34     public void setData(T data) {
35         this.data = data;
36     }
37
38 }

这个例子中，显然//1和//2处肯定会出现错误提示的。在此我们可以使用反证法来进行说明。

假设Box<Number>在逻辑上可以视为Box<Integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box<Number>不能视为Box<Integer>的父类。

好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

 1 public class GenericTest {
 2
 3     public static void main(String[] args) {
 4
 5         Box<String> name = new Box<String>("corn");
 6         Box<Integer> age = new Box<Integer>(712);
 7         Box<Number> number = new Box<Number>(314);
 8
 9         getData(name);
10         getData(age);
11         getData(number);
12     }
13
14     public static void getData(Box<?> data) {
15         System.out.println("data :" + data.getData());
16     }
17
18 }

有时候，我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢？

在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限。

 1 public class GenericTest {
 2
 3     public static void main(String[] args) {
 4
 5         Box<String> name = new Box<String>("corn");
 6         Box<Integer> age = new Box<Integer>(712);
 7         Box<Number> number = new Box<Number>(314);
 8
 9         getData(name);
10         getData(age);
11         getData(number);
12
13         //getUpperNumberData(name); // 1
14         getUpperNumberData(age);    // 2
15         getUpperNumberData(number); // 3
16     }
17
18     public static void getData(Box<?> data) {
19         System.out.println("data :" + data.getData());
20     }
21
22     public static void getUpperNumberData(Box<? extends Number> data){
23         System.out.println("data :" + data.getData());
24     }
25
26 }

此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。

在定义泛型类别时，预设可以使用任何的类型来实例化泛型类型中的类型。

但是如果想限制使用泛型类别时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口，也可以是这个类或接口本身。

比如下面的例子：　　

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

public class ListGenericFoo<T extends List>
{
    private T[] fooArray;

    public T[] getFooArray()
    {
        return fooArray;
    }

    public void setFooArray(T[] fooArray)
    {
        this.fooArray = fooArray;
    }

    public static void main(String[] args)
    {
        ListGenericFoo<LinkedList> foo1 = new ListGenericFoo<LinkedList>();
        ListGenericFoo<ArrayList> foo2 = new ListGenericFoo<ArrayList>();

        //Error: Bound mismatch
        //ListGenericFoo<HashMap> foo3 = new ListGenericFoo<HashMap>();

        LinkedList[] linkedLists = new LinkedList[10];
        foo1.setFooArray(linkedLists);

        ArrayList[] arrayLists = new ArrayList[10];
        foo2.setFooArray(arrayLists);

    }

}

　　类声明中：public class ListGenericFoo<T extends List>

　　这样就规定了T必须是一个List继承体系中的类，即实现了List接口的类。

　　此处注意，虽然List是一个接口，但是关键字仍然是extends而不是implements。

　　并且这个List也可以后加括号指明类型，如List<String>等。

　　当没有指定泛型继承的类型或接口时，默认使用T extends Object，所以默认情况下任何类型都可以作为参数传入。

　　当不使用泛型时，比如那些声明时带有<T>的集合类型，如果使用时没有指定类型，泛型类别为Object。不会报错，但是会有警告。

　　<? extends SomeClass>是一个限界通配符（bounded wildcard），？代表了一个未知的类型，并且它是SomeClass的子类，也可以是SomeClass本身。

　　这里面SomeClass是统配符的上界（upper bound of the wildcard）。

　　相应的也有限定下界的，使用关键字super。

　　通配符所代表的其实是一组类型，但具体的类型是未知的。

类型通配声明

　　看下面的代码：

   　GenericFoo<Integer> foo1 = null;
     GenericFoo<Boolean> foo2 = null;
     //此时foo1只能接受GenericFoo<Integer>类型的实例，foo2只能接受GenericFoo<Boolean>类型的实例

　　如果希望有一个变量foo可以指向下面所有的实例：

      //foo = new GenericFoo<ArrayList>();

      //foo = new GenericFoo<LinkedList>();

　　可以这样声明:

    GenericFoo<? extends List> foo = null;

    foo = new GenericFoo<ArrayList>();

    foo = new GenericFoo<LinkedList>();

　　注意这种形式不同于前面的限制泛型可用类型时提到的形式。

　　前面提到的形式是在声明泛型的类的时候限制了可以用的泛型类型，而现在这种形式是在使用的时候限制了引用的类型，使得引用指向继承了某一个类或接口的类型。

　　如果该应用指向其他类型，则会编译报错：

    //Error:Type mismatch
    foo = new GenericFoo<HashMap>();

　　也可以限制引用指向某个类或接口的继承层次之上的类或接口：

　　比如：

    //引用指向继承层次之上
   GenericFoo<? super List> ge= null;
   ge = new GenericFoo<Object>();

　　使用<?>或是<? extends SomeClass>的声明方式，意味着您只能通过该名称来取得所参考的实例的信息，或者是移除某些信息，但不能增加或者改写它的信息。

　　因为只知道当中放置的是SomeClass的子类，但不确定是什么类的实例，编译器不让您加入信息，理由是，如果可以加入信息的话，那么您就得记得取回的是什么类型的实例，然后转换为原来的类型方可进行操作，这样就失去了使用泛型的意义。在方法参数中使用万用字符时，编译器会阻止任何可能破坏引用参数所指集合的行为，也就是说你可以操作集合元素，但不能新增集合元素，如此才能保障执行期间的安全性，因为编译器会阻止执行期间的恐怖行动。

　　在声明函数时，以下两种声明功能相同：

　　

public <T extends Animal> void takething(ArrayList<T> list)
public void takething(ArrayList<? extends Animal> list)

但是如果方法中有两个参数，使用时就会有差别，具体如下：

public <T extends Animal> void takething(ArrayList<T> one,ArrayList<T> two)

public void takething(ArrayList<? extends Animal> one,ArrayList<? extends Animal> two)

最后，GenericFoo<? extends Object>等价于GenericFoo<?>，但是它们与GenericFoo<Object>不同，因为GenericFoo<Object>限定了类型为Object。

参考资料：

http://www.cnblogs.com/mengdd/archive/2013/01/21/2869778.html

http://www.cnblogs.com/lwbqqyumidi/p/3837629.html

http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html

http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html

http://www.cnblogs.com/Fskjb/archive/2009/08/23/1552506.html

http://www.cnblogs.com/yinhaiming/articles/1749738.html

http://www.cnblogs.com/nerxious/archive/2012/12/21/2828121.html

http://www.cnblogs.com/anrainie/archive/2012/03/09/2387177.html