java泛型通配符

一、类型绑定

1、引入

我们重新看上篇写的一个泛型：

 

 

[java] view plain copy

1. class Point {  
2.     private T x;       // 表示X坐标  
3.     private T y;       // 表示Y坐标  
4.   
5.     public void setX(T x) {  
6.         this.x = x;  
7.     }  
8.   
9.     public void setY(T y) {  
10.         this.y = y;  
11.     }  
12.   
13.     public T getX() {  
14.         return this.x;  
15.     }  
16.   
17.     public T getY() {  
18.         return this.y;  
19.     }  
20. }  
21.   
22. //使用  
23. Point p1 = new Point();  
24. p1.setX(new Integer(100));  
25. System.out.println(p1.getX());  

首先，我们要知道一点，任何的泛型变量（比如这里的T）都是派生自Object，所以我们在填充泛型变量时，只能使用派生自Object的类，比如String,Integer,Double，等而不能使用原始的变量类型，比如int,double,float等。
然后，问题来了，那在泛型类Point内部，利用泛型定义的变量T x能调用哪些函数呢？

[java] view plain copy

1. private T x;    

当然只能调用Object所具有的函数，因为编译器根本不知道T具体是什么类型，只有在运行时，用户给什么类型，他才知道是什么类型。编译器唯一能确定的是，无论什么类型，都是派生自Object的，所以T肯定是Object的子类，所以T是可以调用Object的方法的。
那么问题又来了，如果我想写一个找到最小值的泛型类；由于不知道用户会传什么类型，所以要写一个接口,让用户实现这个接口来自已对比他所传递的类型的大小。
接口如下：

[java] view plain copy

1. public interface Comparable{  
2.     public boolean compareTo(T i);  
3. }  

但如果我们直接利用T的实例来调用compareTo（）函数的话，会报错，编译器截图如下：

 

这是因为，编译器根本无法得知T是继承自Comparable接口的函数。那怎么样才能让编译器知道，T是继承了Comparable接口的类型呢？
这就是类型绑定的作用了。

2、类型绑定：extends

（1）、定义
有时候，你会希望泛型类型只能是某一部分类型，比如操作数据的时候，你会希望是Number或其子类类型。这个想法其实就是给泛型参数添加一个界限。其定义形式为：

 

 

[java] view plain copy

1.   

此定义表示T应该是BoundingType的子类型（subtype）。T和BoundingType可以是类，也可以是接口。另外注意的是，此处的”extends“表示的子类型，不等同于继承。
一定要非常注意的是，这里的extends不是类继承里的那个extends！两个根本没有任何关联。在这里extends后的BoundingType可以是类，也可以是接口，意思是说，T是在BoundingType基础上创建的，具有BoundingType的功能。目测是JAVA的开发人员不想再引入一个关键字，所以用已有的extends来代替而已。
（2）、实例：绑定接口
同样，我们还使用上面对比大小的接口来做例子
首先，看加上extends限定后的min函数：

[java] view plain copy

1. public interface Comparable {  
2.     public boolean compareTo(T i);  
3. }  
4. //添加上extends Comparable之后，就可以Comparable里的函数了  
5. public static   T min(T...a){  
6.     T smallest = a[0];  
7.     for(T item:a){  
8.         if (smallest.compareTo(item)){  
9.             smallest = item;  
10.         }  
11.     }  
12.     return smallest;  
13. }  

这段代码的意思就是根据传进去的T类型数组a，然后调用其中item的compareTo()函数，跟每一项做对比，最终找到最小值。

从这段代码也可以看出，类型绑定有两个作用：

1、对填充的泛型加以限定 

2、使用泛型变量T时，可以使用BoundingType内部的函数。

这里有一点非常要注意的是，在这句中smallest.compareTo(item)，smallest和item全部都是T类型的，也就是说，compareTo对比的是同一种类型。
然后我们实现一个派生自Comparable接口的类：

[java] view plain copy

1. public class StringCompare implements Comparable {  
2.     private String mStr;  
3.   
4.     public StringCompare(String string){  
5.         this.mStr = string;  
6.     }  
7.   
8.     @Override  
9.     public  boolean compareTo(StringCompare str) {  
10.         if (mStr.length() > str.mStr.length()){  
11.             return true;  
12.         }  
13.         return false;  
14.     }  
15. }  

在这段代码，大家可能会疑惑为什么把T也填充为StringCompare类型，记得我们上面说的吗：smallest.compareTo(item)，smallest和item是同一类型！！所以compareTo的参数必须是与调用者自身是同一类型，所以要把T填充为StringCompare；
在这段代码中compareTo的实现为，对比当前mstr的长度与传进来实例的mstr长度进行比较，如果超过，则返回true,否则返回false;
最后是使用min函数：

[java] view plain copy

1. StringCompare result = min(new  StringCompare("123"),new StringCompare("234"),new StringCompare("59897"));  
2. Log.d(TAG,"min:"+result.mStr);  

结果如下：

 

这里有extends接口，我们开篇说过，extends表示绑定，后面的BindingType即可以是接口，也可以是类，下面我们就再举个绑定类的例子。

 

（3）、实例：绑定类
我们假设，我们有很多种类的水果，需要写一个函数，打印出填充进去水果的名字：
为此，我们先建一个基类来设置和提取名字：

 

[java] view plain copy

1. class Fruit {  
2.     private String name;  
3.   
4.     public String getName() {  
5.         return name;  
6.     }  
7.     public void setName(String name) {  
8.         this.name = name;  
9.     }  
10. }  

然后写个泛型函数来提取名字：

[java] view plain copy

1. public static  String getFruitName(T t){  
2.     return t.getName();  
3. }  

这里泛型函数的用法就出来了，由于我们已知水果都会继承Fruit基类，所以我们利用就可以限定填充的变量必须派生自Fruit的子类。一来，在T中，我们就可以利用Fruit类中方法和函数；二来，如果用户填充进去的类没有派生自Fruit，那编译器就会报错。
然后，我们新建两个类，派生自Fruit，并填充进去它们自己的名字:

[java] view plain copy

1. class Banana extends Fruit{  
2.     public Banana(){  
3.         setName("bababa");  
4.     }  
5. }  
6. class Apple extends Fruit{  
7.     public Apple(){  
8.         setName("apple");  
9.     }  
10. }  

最后调用：

[java] view plain copy

1. String name_1 = getFruitName(new Banana());  
2. String name_2 = getFruitName(new Apple());  
3. Log.d(TAG,name_1);  
4. Log.d(TAG,name_2);  

结果如下：

 

 

（4）、绑定多个限定
上面我们讲了，有关绑定限定的用法，其实我们可以同时绑定多个绑定,用&连接，比如：

 

 

[java] view plain copy

1. public static  String getFruitName(T t){  
2.     return t.getName();  
3. }  

再加深下难度，如果我们有多个泛型，每个泛型都带绑定，那应该是什么样子的呢：

[java] view plain copy

1. public static  T foo(T a, U b){  
2.     …………  
3. }  

大家应该看得懂，稍微讲一下：这里有两个泛型变量T和U,将T与Comparable & Serializable绑定，将U与Runnable绑定。
好了，这部分就讲完了，下面讲讲有关通配符的用法。

二、通配符

通配符是一个非常令人头疼的一个功能，理解与掌握难度比较大，下面我尽力去讲明白它与泛型变量的区别与用法。

1、引入

重新来看我们上篇用的Point泛型定义：

[java] view plain copy

1. class Point {  
2.     private T x;        
3.     private T y;        
4.       
5.     public Point(){  
6.           
7.     }  
8.     public Point(T x,T y){  
9.         this.x = x;  
10.         this.y = y;  
11.     }  
12.   
13.     public void setX(T x) {  
14.         this.x = x;  
15.     }  
16.   
17.     public void setY(T y) {  
18.         this.y = y;  
19.     }  
20.   
21.     public T getX() {  
22.         return this.x;  
23.     }  
24.   
25.     public T getY() {  
26.         return this.y;  
27.     }  
28. }  

这段代码很简单，引入了一个泛型变量T，然后是有两个构造函数，最后分别是利用set和get方法来设置和获取x,y的值。这段代码没什么难度，不再细讲。
我们看看下面这段使用的代码：

[java] view plain copy

1. Point integerPoint = new Point(3,3);  
2. …………  
3. Point floatPoint = new Point(4.3f,4.3f);  
4. …………  
5. Point doublePoint = new Point(4.3d,4.90d);  
6. …………  
7. Point longPoint = new Point(12l,23l);  
8. …………  

在这段代码中，我们使用Point生成了四个实例:integerPoint,floatPoint,doublePoint和longPoint；
在这里，我们生成四个实例，就得想四个名字。如果我们想生成十个不同类型的实例呢？那不得想十个名字。
光想名字就是个事，（其实我并不觉得想名字是个什么大事…… T _ T ，没办法，想不出更好的例子了…… ）
那有没有一种办法，生成一个变量，可以将不同类型的实例赋值给他呢？

2、无边界通配符：？

（1）、概述
先不讲无边界通配符是什么，同样拿上面的例子来看，如果我们这样实现：

[java] view plain copy

1. Point point;  
2.   
3. point = new Point(3,3);  
4. point = new Point(4.3f,4.3f);  
5. point = new Point(4.3d,4.90d);  
6. point = new Point(12l,23l);  

在这里，我们首先，利用下面的代码生成一个point实例，注意到，在填充泛型时，用的是?

[java] view plain copy

1. Point point;  

然后，各种类型的Point实例，都可以赋值给point了：

[java] view plain copy

1. point = new Point(3,3);  
2. point = new Point(4.3f,4.3f);  
3. point = new Point(4.3d,4.90d);  
4. point = new Point(12l,23l);  

这里的?就是无边界通配符。通配符的意义就是它是一个未知的符号，可以是代表任意的类。
所以这里可能大家就明白了，这里不光能将泛型变量T填充为数值类型，其实任意Point实例都是可以传给point的：比如这里的Point(),Point