Java 泛型（三）：泛型在继承方面体现与通配符使用

一、泛型在继承上的体现

　　1、先看两段代码有何不同

　　　　片段1：

　　public void printCollection(Collection c) {
        Iterator i = c.iterator();
        for (int k = 0; k < c.size(); k++) {
            System.out.println(i.next());
        }
    }

　　　　　　片段2：

　　public void printCollection(Collection<Object> c) {
        for (Object e : c) {
            System.out.println(e);
        }
    }

　　2、泛型在继承上的体现

　　　　如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口， G<B>并不是G<A>的子类型！

　　　　比如： String是Object的子类，但是List<String >并不是List<Object>的子类。

　　　　

 　　　　但是：如果类 A 是类 B的父类，A<G> 是 B<G> 的父类。

　　3、代码体验

　　　　实验一：

    @Test
    public void test(){

        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;


        //编译不通过
        //Date date = new Date();
        //str = date;


        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
        //list1 = list2;
        
    }

　　　　实验二：

　　public void testGenericAndSubClass() {
        Person[] persons = null;
        Man[] mans = null;
        // 而 Person[] 是 Man[] 的父类.
        persons = mans;
        
        Person p = mans[0];
        
        
        // 在泛型的集合上
        List<Person> personList = null;
        List<Man> manList = null;
        // personList = manList;(报错)
    }

　　　　实验三：

    public void test(){

        AbstractList<String> list1 = null;
        List<String> list2 = null;
        ArrayList<String> list3 = null;

        list1 = list3;
        list2 = list3;

        List<String> list4 = new ArrayList<>();

    }

二、通配符的使用

　　1、通配符

　　　　（1）使用类型 通配符：？
　　　　　　比如： List<?> ， Map<?,?>
　　　　　　List<?>是List<String>、 List<Object>等各种泛型List的父类。
　　　　（2）读取 List<?> 的对象 list 中的元素时，永远是安全的，因为不管 list 的真实类型是什么，它包含的都是Object。
　　　　（3）写入 List中的元素时，不行。因为我们不知道 c 的元素类型，我们不能向其中添加对象。
　　　　　　  注意：唯一的例外是可以写入null，它是所有类型的成员。

　　2、案例一

    @Test
    public void test() {
        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;

        //编译通过
        //print(list1);
        //print(list2);

        
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

　　　　List<?> 作为 List<String> 和List<Object> 的父类。

　　3、通配符的使用——读取操作

　　　　（1）将任意元素加入到其中不是类型安全的：

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时错误

　　　　　　因为我们不知道c的元素类型，我们不能向其中添加对象。 add方法有类型参数E作为集合的元素类型。

　　　　　　我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型，所以我们无法传任何东西进去。

　　　　（2）唯一的例外的是null，它是所有类型的成员。
　　　　（3）另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。

　　4、案例

    public static void main(String[] args) {
        List<?> list = null;
        list = new ArrayList<String>();
        list = new ArrayList<Double>();
        // list.add(3);//编译不通过
        list.add(null);
        
        
        List<String> l1 = new ArrayList<String>();
        List<Integer> l2 = new ArrayList<Integer>();
        l1.add("Hello World");
        l2.add(15);
        read(l1);
        read(l2);
    }
    public static void read(List<?> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }

　　　　添加(写入)：对于List<?>就不能向其内部添加数据。除了添加null之外。

　　　　获取(读取)：允许读取数据，读取的数据类型为Object。

　　5、通配符的使用：注意点

　　　　（1）编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?

public static <?> void test(ArrayList<?> list){}

　　　　

　　　　（2）编译错误：不能用在泛型类的声明上

class GenericTypeClass<?>{}

　　　　

　　　　（3）编译错误：不能用在创建对象上，右边属于创建集合对象

ArrayList<?> list2 = new ArrayList<?>();

　　

三、有限制的通配符

　　1、有限制的通配符

<?>  允许所有泛型的引用调用

通配符指定上限
上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=

通配符指定下限
下限super：使用时指定的类型不能小于操作的类，即>=

　　

　　　　举例：

<? extends Number> (无穷小 , Number]
只允许泛型为Number及Number子类的引用调用


<? super Number> [Number , 无穷大)
只允许泛型为Number及Number父类的引用调用

　

　　2、说明

? extends A：G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

? super A：G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类

　

　　3、案例

　　　　案例1：

    public static void printCollection3(Collection<? extends Person> coll) {
        //Iterator只能用Iterator<?>或Iterator<? extends Person>.why?
        Iterator<?> iterator = coll.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

　　　　案例2：

    public static void printCollection3(Collection<? extends Person> coll) {
        //Iterator只能用Iterator<?>或Iterator<? extends Person>.why?
        Iterator<?> iterator = coll.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

　　　　案例3：

    public void test(){

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
　　　　　//list1 = list5;

　　　　　//list2 = list3;
        list2 = list4; 
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);
        //编译不通过
        //Student s = list1.get(0);

        list2 = list4;
        Object obj = list2.get(0);
        ////编译不通过
　　　　  //Person obj = list2.get(0);

        //写入数据：
        //编译不通过
　　　　　//list1.add(new Student());

        //编译通过
        list2.add(new Person());
        list2.add(new Student());

    }

　　4、

 

四、泛型应用

　　1、泛型嵌套

　　public static void main(String[] args) {
        HashMap<String, ArrayList<Citizen>> map = new HashMap<String, ArrayList<Citizen>>();
        ArrayList<Citizen> list = new ArrayList<Citizen>();
        list.add(new Citizen("Java"));
        list.add(new Citizen("PHP"));
        list.add(new Citizen("C++"));
        map.put("Java", list);
        Set<Entry<String, ArrayList<Citizen>>> entrySet = map.entrySet();
        Iterator<Entry<String, ArrayList<Citizen>>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Entry<String, ArrayList<Citizen>> entry = iterator.next();
            String key = entry.getKey();
            ArrayList<Citizen> value = entry.getValue();
            System.out.println("Boss： " + key);
            System.out.println("语言成员： " + value);
        }
    }

　　2、