作者： 一字马胡
转载标志 【2017-11-03】

更新日志

日期	更新内容	备注
2017-11-03	添加转载标志	持续更新

1、上界通配符

首先，需要知道的是，Java语言中的数组是支付协变的，什么意思呢？看下面的代码：

    static class A extends Base{
        void f() {
            System.out.println("A.f");
        }
    }

    static class B extends A {
        void f() {
            System.out.println("B.f");
        }
    }

    static class C extends B {
        void f() {
            System.out.println("C.f");
        }
    }

    static {

        A[] arrayA = new A[3];

        arrayA[0] = new A();
        arrayA[1] = new B();
        arrayA[2] = new C();

        for (A item : arrayA) {
            item.f();
        }
        
    } 

//output
A.f
B.f
C.f

我们明明让数组的类型为A，但是向其中加入B、C也是可以行得通的，为什么呢？我们发现B继承了A，属于A的子类，C继承了B，属于B的子类，Java中的继承是可以传递的，所以C依然属于A的子类，所以B和C都是A的子类，另外一点，在Java中，类型向上转换是非常自然的，不需要强制转换会自动进行，也就是说，B和C的实例都可以自动转换为类型A的实例。好了，有了这样的背景知识，我们可以来看一下上界通配了，在java中，可以使用<? extends Type> 来界定一个上界，<? extends Type>的意思是所有属于Type的子类，Type是上界，不能突破天界啊，我们具体化一下，<? extends A>的意思就是，所有A的子类都可以匹配这个通配符。所有我们的B、C的实例以及他们的子类的实例都可以匹配，但是Base就不可以，因为Base是A的父类，而我们的上界是A啊，所以当然不能是Base了。很自然的，我们有下面的代码：

        A a = new B();
        A b = new C();
        C c = new C();

       List<? extends A> list = new ArrayList<A>();
    
      list.add(a);
      list.add(b);
      list.add(c);

我们觉得很自然这样做是无可厚非的，对吧？但是编译器很显然不允许我们这样做，为什么？我们的list的类型使用了上界通配符啊，而且匹配的是所有A的子类，而我们add的都是A的子类啊，为什么不可以呢？我们再来看一下<? extends A>，我们的list可以持有任何A的子类对象，也就是A、B、C的实例都是可以的，那我们是不是可以把<? extend B>认为是<? extends A>的子类呢？<? entends C>呢？我们暂且认为是可以这样吧，那看下面的这个方法：

    void joke(List<? extends A> list) {
        A a = new B();
        A b = new C();
        C c = new C();
        
        list.add(a);
        list.add(b);
        list.add(c);
    }

当然上面的代码是无法通过编译的，我们分析一下为什么，记住<? extends A>是设定上界，所以，joke方法的参数是开放的，我们可以传进去一个<? extend A>的list，也可以是一个<? extends B>的list，还可以是一个<? extends C>的list。因为下面的代码是可以通过编译的：

    private static void jokeIn(List<?extends A> list) {
        //
    }
    
    static {
        List<? extends A> list = new ArrayList<>();
        List<? extends B> list1 = new ArrayList<>();
        List<? extends C> list2 = new ArrayList<>();
        
        jokeIn(list);
        jokeIn(list1);
        jokeIn(list2);
    }

好吧，问题来了，当我们传到joke方法中的参数是List<? extends A>的时候，方法内部的add都是可以接受的，但是当我们传进去的参数是List<? extends B>的时候，list.add(a)明显是无法成功的，因为我们的list将可以允许持有B的子类，但是A不在这个范围里面，所以是不合法的，当传进去的是List<? extends C>的时候呢？连list.add(B)也不允许了。所以这就是问题所在，所以不允许这样的代码通过编译是明智的，因为我们不能总是保证调用joke方法的用户会严格传进来一个List<? extends A>的参数。
那怎么使用上界呢？换句话说，如何来产生一个List<? extends A>的list呢？还记得一开始我们说的数组协变吗？下面的代码使用了java语言数组具有协变能力来产生一个具有上界的list：

     List<? extends A> list = Arrays.asList(a, b);

Arrays.asList(T ... data)使用了ArrayList的一个构造函数：

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

可以看到使用了数组的协变，使得我们可以在Arrays.asList里面传递进去所以A的子类对象。

2、下界通配符

上界定义了可以达到了最高点，超出就是违法的；而下界则是说明了底线，你只能比底线更高级，低于底线就是违法的。在java里面，可以使用<? super Type>来表达下界的意义，具体一点，<? super A>表达的和<? extends A>是两个相反的方向，前者是说所有基于A的基类，后者是说所有基于A的子类，我们再来看一下下面这个方法：

    void joke(List<? super A> list) {
        A a = new B();
        A b = new C();
        C c = new C();
        
        list.add(a);
        list.add(b);
        list.add(c);
    }

此时的joke方法的参数是List<? super A>，此时List<? super B>和List<? super C>都变成了List<? super A>的父类了，因为实际上List<? super B>和List<? super C>表达的能力比List<? super A>更强，也就是List<? super C>包含了List<? super B>和List<? super A>，而List<? super B>则包含了List<? super A>，好了，说明了这些之后，我们再来看一下对joke方法的调用会出现哪些情况：

    static {
        List<? super A> list = new ArrayList<>();
        List<? super B> list1 = new ArrayList<>();
        List<? super C> list2 = new ArrayList<>();
        
        jokeIn(list);
        jokeIn(list1); // error
        jokeIn(list2); //error
    }

好吧，问题出现了，我们可以将List<? super A> 的参数传递给joke，因为这正是我们需要的，而我们也知道List<? super A>的表达能力在List<? super B>和<? super C>中是最低的，所以，当我们将一个表达能力强于List<? super A>的参数传递给joke之后，编译器报错了。当然，这仅仅是为了说明所谓下界的界定。

有了下界，我们可以使用下面的代码来为我们工作了：

       List<? super A> lists = new ArrayList<>();
        lists.add(a);
        lists.add(b);
        lists.add(c);

解释一下，lists里面的元素类型是这样一种类型，这种类型是A的基类，我们只是界定了下界，只要高于这个下界，就可以被lists接收，而b、c的基类都是A，可以被lists接收，所以上面的代码是可以工作的。

3、无界通配符

有了上界和下界，还有无界，需要说明的一点是，不能同时使用上界和下界，因为有无界啊（开玩笑的）！！
我们在java中使用<?>来表达无界，对于<?>，目前来讲锁表达的意思是：

我是想要java的范型来编写这段代码，我在这里并不是想使用原生类
型，但是在当前这种情况下，泛型参数可以持有任何类型。

                     ----来自《java编程思想》15.10.3 无界通配符（686页）

使用无界通配符的一种场景是：如果向一个使用<?>的方法传递了一个原生类型，那么对编译器来说可能会推断出实际的参数类型，使得这个方法可以回转并且调用另外一个使用这个确切类型的方法。这叫做“类型捕获”，看下面的代码：

    static class Holder<T> {
        private T data;

        public Holder() {

        }

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

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }
    }


    static <T> void actual(Holder<T> holder) {
        System.out.println(holder.getData());
    }

    static void func(Holder<?> holder) {
        actual(holder);
    }

    static {

        Holder<?> holder = new Holder<>("hujian");

        func(holder);
        
    }

可以看到，actual的参数是具体的T，而func的参数是无界的<?>，这里发生了一件参数类型捕获的事情，在调用func的时候，类型被捕获，而可以在actual方法中使用我们从func中传递进来的无界参数。
可以使用无界通配符来接收多个类型的对象，然后根据不同的类型来交付给不同的方法来处理，可以回忆一下操作系统的中断处理程序的处理方法，通过安装一些中断类型和与之对应的handler，然后通过控制程序来将中断处理信号分发到不同的handler中处理，其实思想是一样的，可以看一下下面的代码来理解这个模型：

    static <T> void actual(Holder<T> holder) {
        T data = holder.getData();
        if (data instanceof String) {
            actual((String) data);
        } else if (data instanceof Integer) {
            actual((Integer) data);
        } else if (data instanceof Double) {
            actual((Double) data);
        }
    }

    static void actual(String holder) {
        System.out.print("string:" + holder);
    }

    static void actual(Integer holder) {
        System.out.println("Integer:" + holder);
    }

    static void actual(Double holder) {
        System.out.println("double:" + holder);
    }

    static void func(Holder<?> holder) {
        actual(holder);
    }