夯实JAVA基本之一——泛型详解(2)

前言：被温水煮惯了，梦想的东西总是不敢于尝试，失败了又怎样，最多从头来过。

上一篇给大家初步讲解了泛型变量的各种应用环境，这篇将更深入的讲解一下有关类型绑定，通配符方面的知识。

一、类型绑定

1、引入

class Point<T> {
    private T x;       // 表示X坐标
    private T y;       // 表示Y坐标

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

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

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

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

//使用
Point<Integer> p1 = new Point<Integer>();
p1.setX(new Integer(100));
System.out.println(p1.getX());

private T x;  

public interface Comparable<T>{
    public boolean compareTo(T i);
}

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

2、类型绑定：extends

<T extends BoundingType>

public interface Comparable<T> {
    public boolean compareTo(T i);
}
//添加上extends Comparable之后，就可以Comparable里的函数了
public static <T extends Comparable>  T min(T...a){
    T smallest = a[0];
    for(T item:a){
        if (smallest.compareTo(item)){
            smallest = item;
        }
    }
    return smallest;
}

public class StringCompare implements Comparable<StringCompare> {
    private String mStr;

    public StringCompare(String string){
        this.mStr = string;
    }

    @Override
    public  boolean compareTo(StringCompare str) {
        if (mStr.length() > str.mStr.length()){
            return true;
        }
        return false;
    }
}

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

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

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

class Fruit {
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public static <T extends Fruit> String getFruitName(T t){
    return t.getName();
}

class Banana extends Fruit{
    public Banana(){
        setName("bababa");
    }
}
class Apple extends Fruit{
    public Apple(){
        setName("apple");
    }
}

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

public static <T extends Fruit&Serializable> String getFruitName(T t){
    return t.getName();
}

public static <T extends Comparable & Serializable, U extends Runnable> T foo(T a, U b){
	…………
}

二、通配符

1、引入

class Point<T> {
    private T x;      
    private T y;      
    
    public Point(){
        
    }
    public Point(T x,T y){
        this.x = x;
        this.y = y;
    }

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

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

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

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

Point<Integer> integerPoint = new Point<Integer>(3,3);
…………
Point<Float> floatPoint = new Point<Float>(4.3f,4.3f);
…………
Point<Double> doublePoint = new Point<Double>(4.3d,4.90d);
…………
Point<Long> longPoint = new Point<Long>(12l,23l);
…………

2、无边界通配符：？

Point<?> point;

point = new Point<Integer>(3,3);
point = new Point<Float>(4.3f,4.3f);
point = new Point<Double>(4.3d,4.90d);
point = new Point<Long>(12l,23l);

Point<?> point;

point = new Point<Integer>(3,3);
point = new Point<Float>(4.3f,4.3f);
point = new Point<Double>(4.3d,4.90d);
point = new Point<Long>(12l,23l);

（2）、？与T的区别
大家可能会有疑问，那无边界通配符？与泛型变量T有什么区别呢？
答案是：他们俩没有任何联系！！！！！
泛型变量T不能在代码用于创建变量，只能在类，接口，函数中声明以后，才能使用。
比如：

public class Box<T> {
   public T get(){
	   …………
   };
   public void put(T element){
	   …………
   };
}

//无边界通配符填充
Box<?> box;
//其它类型填充
Box<String> stringBox;

Box<?> box;
box = new Box<String>();

再次强调，？只能出现在Box<?> box;中，其它位置都是不对的。

3、通配符？的extends绑定

我们给通配符加上限定： Point<? extends Number> point;
此时，最后两行，当将T填充为String和Object时，赋值给point就会报错！
这里虽然是指派生自Number的任意类型，但大家注意到了没： new Point<Number>();也是可以成功赋值的，这说明包括边界自身。
再重复一遍：无边界通配符只是泛型T的填充方式，给他加上限定，只是限定了赋值给它（比如这里的point）的实例类型。
如果想从根本上解决乱填充Point的问题，需要从Point泛型类定义时加上<T extends Number>:

class Point<T extends Number> {
    private T x;       // 表示X坐标
    private T y;       // 表示Y坐标

   …………
}

明显在point.setX(Integer(122));时报编译错误。但point.getX()却不报错。
这是为什么呢？
首先，point的类型是由Point<? extends Number>决定的，并不会因为point = new Point<Integer>(3,3);而改变类型。
即便point = new Point<Integer>(3,3);之后，point的类型依然是Point<? extends Number>，即派生自Number类的未知类型！！！这一点很好理解，如果在point = new Point<Integer>(3,3);之后，point就变成了Point<Integer>类型，那后面point = new Point<Long>(12l,23l);操作时，肯定会因为类型不匹配而报编译错误了，正因为，point的类型始终是Point<? extends Number>，因此能继续被各种类型实例赋值。
回到正题，现在说说为什么不能赋值
正因为point的类型为 Point<? extends Number> point，那也就是说，填充Point的泛型变量T的为<? extends Number>，这是一个什么类型？未知类型！！！怎么可能能用一个未知类型来设置内部值！这完全是不合理的。
但取值时，正由于泛型变量T被填充为<? extends Number>，所以编译器能确定的是T肯定是Number的子类，编译器就会用Number来填充T
也就是说，编译器，只要能确定通配符类型，就会允许，如果无法确定通配符的类型，就会报错。

4、通配符？的super绑定

class CEO extends Manager {
}

class Manager extends Employee {
}

class Employee {
}

 List<? super Manager> list;

从上面的代码中可以看出new ArrayList<Employee>()，new ArrayList<Manager>()都是正确的，而new ArrayList<CEO>()却报错，当然是因为CEO类已经不再是Manager的父类了。所以会报编译错误。
这里还要注意一个地方，从代码中可以看出new ArrayList<Manager>()是可以成功赋值给 List<? super Manager> list的，可见，super关键字也是包括边界的。即边界类型（这里是Manager）组装的实例依然可以成功赋值。
（2）、super通配符实例内容：能存不能取
上面我们讲了，extends通配符，能取不能存，那super通配符情况又怎样呢？我们试试看：

先看存的部分：

List<? super Manager> list;
list = new ArrayList<Employee>();
//存
list.add(new Employee()); //编译错误
list.add(new Manager());
list.add(new CEO());

list.add(new Manager());
list.add(new CEO());

List<Employee> list = new ArrayList<Employee>();
list.add(new Manager());
list.add(new CEO());

List<? super Manager> list;
list = new ArrayList<Employee>();
//存
list.add(new Employee()); //编译错误
list.add(new Manager());
list.add(new CEO());

在这段代码中，Object object = list.get(0);是不报错的，而Employee employee = list.get(0);是报错的；
我们知道list中item的类型为<? super Manager>，那编译器能肯定的是<? super Manager>肯定是Manger的父类；但不能确定，它是Object还是Employee类型。但无论是填充为Object还是Employee，它必然是Object的子类！
所以Object object = list.get(0);是不报错的。因为 list.get(0);肯定是Object的子类；
而编译器无法判断list.get(0)是不是Employee类型的，所以Employee employee = list.get(0);是报错的。
这里虽然看起来是能取的，但取出来一个Object类型，是毫无意义的。所以我们认为super通配符：能存不能取；

5、通配符？总结

总结 ? extends 和 the ? super 通配符的特征，我们可以得出以下结论：
◆ 如果你想从一个数据类型里获取数据，使用 ? extends 通配符（能取不能存）
◆ 如果你想把对象写入一个数据结构里，使用 ? super 通配符（能存不能取）
◆ 如果你既想存，又想取，那就别用通配符。


好了，快累死了，这部分真是太难讲了，有关通配符捕获和编译器类型擦除的知识，就不讲了，在实际项目中基本用不到，有兴趣的同学可以自行去补充下。
下篇给大家讲下反射。

如果本文有帮到你，记得加关注哦

本文涉及源码下载地址：http://download.csdn.net/detail/harvic880925/9275551

请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/49883589 谢谢

参考文章：

1、《 java 泛型编程（一）》
2、《Java泛型--泛型应用--泛型接口、泛型方法、泛型数组、泛型嵌套》
3、《Java泛型编程最全总结》
4、《java 通配符解惑》
5、《《Java编程思想》学习笔记8——泛型编程高级》
6、《步步理解 JAVA 泛型编程(三)》
7、《Java-泛型编程-类型擦除(Type Erasure)》
8、《Java泛型--泛型入门》
9、《Java泛型--通配符》
10、《在 Java 的泛型类型中使用通配符》
11、《Java 理论与实践: 使用通配符简化泛型使用》
12、《Java 泛型学习三 通配符》
13、《Java泛型-- 通配符（转载）》

夯实JAVA基本之一——泛型详解(2)

原文：http://blog.csdn.net/harvic880925/article/details/49883589