类型通配符

1.什么是类型通配符

• 类型通配符一般是使用"?"代替具体的类型实参。

• 所以，类型通配符是类型实参，而不是类型形参。

小案例：

package com.genericity.demo2;

/**
 * 创建泛型类
 * @param <T>
 */
public class Box<T> {
    private T first;

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }
}

package com.genericity.demo2;

public class MainClass {
    public static void main(String[] args) {
        //进行测试
        Box<Number> box1 = new Box<>();
        box1.setFirst(100);
        showBox(box1);//运行结果：100

//        Box<Integer> box2 = new Box<>();
//        box2.setFirst(200);
//        showBox(box2);//我们都知道Integer继承至Number，但是我的定义的方法是public static void showBox(Box<Number> box){ 他是不支持的，即使这样public static void showBox(Box<Integer> box){ 也是不行的。
        //我们可以使用类型通配符的方式  public static void showBox(Box<?> box){

        Box<Integer> box2 = new Box<>();
        box2.setFirst(200);
        showBox(box2);//运行结果:200


    }
//    public static void showBox(Box<Number> box){
//        Number first = box.getFirst();
//        System.out.println(first);
//    }

    /**
     * 使用类型通配符的方式
     *
     * @param box
     */
    public static void showBox(Box<?> box) {
        Object first = box.getFirst();
        System.out.println(first);
    }

    /**
     * 这样也是不行的
     * @param box
     */
//    public static void showBox(Box<Integer> box){
//        Integer first = box.getFirst();
//        System.out.println(first);
//    }
}

2.类型通配符的上限（接上文）

• 语法：类/接口

• 要求该泛型的类型，只能是实参类型，或实参类型的子类类型。

  上面的代码我们看着是不是十分的不爽，既然是？通配符了，但是返回的还是Object类型的。

/**
     * 使用类型通配符的方式
     *
     * @param box
     */
    public static void showBox(Box<?> box) {
        Object first = box.getFirst();
        System.out.println(first);
    }

对上面的代码使用类型通配符的上限的方式进行改造

package com.genericity.demo3;

public class MainClass {
    public static void main(String[] args) {
        //进行测试
        Box<Number> box1 = new Box<>();
        box1.setFirst(100);
        showBox(box1);//运行结果：100

        Box<Integer> box2 = new Box<>();
        box2.setFirst(200);
        showBox(box2);

    }

    /**
     * 使用类型通配符的方式
     * 使用类型通配符的上限，这样我们在传值的时候，就可以传Number类型或者是Number类型的子类
     * @param box
     */
    public static void showBox(Box<? extends Number> box) {
        Number first = box.getFirst();
        System.out.println(first);
    }

}

小案例：

package com.genericity.demo3;

public class Animal {
}

package com.genericity.demo3;

public class Cat extends Animal {
}

package com.genericity.demo3;

public class MiniCat extends Cat {
}

package com.genericity.demo3;

import java.util.ArrayList;

/**
 * 类型通配符上限方式
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<Animal> animals= new ArrayList<>();
        ArrayList<Cat> cats= new ArrayList<>();
        ArrayList<MiniCat> miniCats= new ArrayList<>();

//        showAnimal(animals); Animal类不是Cat类型或者Cat类型的子类
        showAnimal(cats);
        showAnimal(miniCats);

        /**
         * 源码：
         * public boolean addAll(Collection<? extends E> c) {
         *         Object[] a = c.toArray();
         *         int numNew = a.length;
         *         ensureCapacityInternal(size + numNew);  // Increments modCount
         *         System.arraycopy(a, 0, elementData, size, numNew);
         *         size += numNew;
         *         return numNew != 0;
         *     }
         */

        cats.addAll(miniCats);//输入的时候提示：addAll(Collection<? extends Cat>
    }

    /**
     * 泛型上限通配符，传递的集合类型，只能是Cat或者Cat的子类类型
     * @param list
     */
    public static void showAnimal(ArrayList<? extends Cat> list){
        //注意：使用类型通配符上限的这种方式是不能添加元素的，因为你不能确定？号代表的是什类型，是Cat类还是MiniCat类，如果是MiniCat类的话，就会报错，所以是不行的。
//        list.add(new Animal());
//        list.add(new Cat());
//        list.add(new MiniCat());
        for (int i = 0; i < list.size(); i++) {
            Cat cat = list.get(i);
            System.out.println(cat);
        }
    }
}

3.类型通配符的下限

语法：

类/接口

要求该泛型的类型，只能是实参类型，或实参类型的父类类型。

小案例：

package com.genericity.demo3;

import java.util.ArrayList;

/**
 * 类型通配符下限方式
 */
public class TestDown {
    public static void main(String[] args) {
        ArrayList<Animal> animals= new ArrayList<>();
        ArrayList<Cat> cats= new ArrayList<>();
        ArrayList<MiniCat> miniCats= new ArrayList<>();

        showAnimal(animals);
        showAnimal(cats);
//        showAnimal(miniCats) miniCats类不是Cat类型或者Cat类型的父类

    }

    /**
     * 泛型下限通配符，传递的集合类型，只能是Cat或者Cat的子类类型
     * @param list
     */
    public static void showAnimal(ArrayList<? super Cat> list){
        //注意：使用类型通配符下限的这种方式是能添加元素的
//        list.add(new Animal()); Cat的父类元素是不能添加的，是能添加子类对象的
        list.add(new Cat());
        list.add(new MiniCat());
        /**
         * 注意：使用类型通配符下限的这种方式，返回值类型是Object类型，因为所有类的父类都是Object
         */
        for (int i = 0; i < list.size(); i++) {
            Object object = list.get(i);
            System.out.println(object);
        }
    }
}

小案例：通过对TreeSet的讲解，进一步加深对类型通配符上下限的理解

package com.genericity.demo4;

public class Animal {
    public String name;

    public Animal(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                '}';
    }
}

package com.genericity.demo4;

public class Cat extends Animal {
    public int age;

    public Cat(String name, int age) {
        super(name);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

package com.genericity.demo4;

public class MiniCat extends Cat {
    public int level;

    public MiniCat(String name, int age, int level) {
        super(name, age);
        this.level = level;
    }

    @Override
    public String toString() {
        return "MiniCat{" +
                "level=" + level +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

package com.genericity.demo4;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * 讲解TreeSet 类型上下限通配符的使用
 */
public class Test {
    public static void main(String[] args) {
        /**
         * 分别传入自己定义的不同的比较器Comparator1 Comparator2 Comparator3
         */
        TreeSet<Cat> treeSet=new TreeSet<>(new Comparator1());
        treeSet.add(new Cat("jerry",20));
        treeSet.add(new Cat("amy",22));
        treeSet.add(new Cat("frank",35));
        treeSet.add(new Cat("jim",15));
        for (Cat cat : treeSet) {
            System.out.println(cat);
        }
    }
}

class Comparator1 implements Comparator<Animal>{

    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.name.compareTo(o2.name);
    }
}
class Comparator2 implements Comparator<Cat>{

    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.age-o2.age;
    }
}
class Comparator3 implements Comparator<MiniCat>{

    @Override
    public int compare(MiniCat o1, MiniCat o2) {
        return o1.level-o2.level;
    }
}

使用Comparator1 运行结果：

Cat{age=22, name='amy'}
Cat{age=35, name='frank'}
Cat{age=20, name='jerry'}
Cat{age=15, name='jim'}   

由此可以看出是按照  a   f   je  ji 排列的

使用Comparator2 运行结果：

Cat{age=15, name='jim'}
Cat{age=20, name='jerry'}
Cat{age=22, name='amy'}
Cat{age=35, name='frank'}

由此可以看出是按照 10  20  22  35由小到大 排列的

使用Comparator3 会出现编译错误：

原因：（使用源码分析）
public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
}
由此可以看出：这里要传入的比较器必须得是Cat或者Cat的父类才行，而MiNiCat不是Cat的父类。