Java泛型中的通配符

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中，可以使用

        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的子类啊，为什么不可以呢？我们再来看一下

    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);
    }

当然上面的代码是无法通过编译的，我们分析一下为什么，记住

    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

     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里面，可以使用

    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

    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

       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的参数是无界的

    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);
    }