JAVA 泛型-类型通配符？

1.什么是类型通配符

• 类型通配符就是一个问号 ？
• 类型通配符就是使用 ？ 代替具体的 类型实参
• 例如 List<?> ,它的元素类型可以匹配任何类型

1.1 类型通配符的声明类

import java.util.ArrayList;

/**
 * author : northcastle
 * createTime:2021/10/25
 * 通配符的定义，通配符就是个问号 ？
 * 表示可以匹配任意类型的泛型
 */
public class WildcardDefine {
    //定义一个使用类型通配符的方法
    public static void showList(ArrayList<?> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }
}

1.2 测试使用

import sun.reflect.generics.tree.Wildcard;
import java.util.ArrayList;

/**
 * author : northcastle
 * createTime:2021/10/25
 */
public class WildcardApplication {
    public static void main(String[] args) {
        //1.使用类型通配符
        //1.1 一个String 类型的list
        ArrayList<String> listString = new ArrayList<>();
        listString.add("aa");
        listString.add("bb");
        listString.add("cc");
        WildcardDefine.showList(listString);
        System.out.println("==================================");
        //1.2 一个Integer 类型的list
        ArrayList<Integer> listInteger = new ArrayList<>();
        listInteger.add(100);
        listInteger.add(200);
        listInteger.add(300);
        listInteger.add(400);
        WildcardDefine.showList(listInteger);

    }
}

1.3 运行结果

aa
bb
cc
==================================
100
200
300
400

2.类型通配符上限

语法 ： 类/接口/方法参数 <? extends 实参类型>
要求 ： 该泛型的类型只能是 实参类型 或 实参类型的字类型

3.类型通配符下限

语法 ： 类/接口/方法参数 <? super 实参类型>
要求 ： 该泛型的类型只能是 实参类型 或 实参类型的父类型

4.使用代码

4.1 准备三个有父子孙关系的类

最高级父类

/**
 * author : northcastle
 * createTime:2021/10/26
 * 动物类
 */
public class Animal {
}

中间子类

/**
 * author : northcastle
 * createTime:2021/10/26
 * 狗类 ： 继承自 动物类
 */
public class Dog extends Animal {
}

最低的孙子类

/**
 * author : northcastle
 * createTime:2021/10/26
 * 柯基狗 ： 继承自 狗类
 */
public class Keji extends Dog {
}

4.2 准备一个类包含通配符上下限的方法

import java.util.ArrayList;

/**
 * author : northcastle
 * createTime:2021/10/26
 * 通配符的上下限
 */
public class WildcardLimit {

    /**
     * 1.类型通配符的上限 extends
     * @param list
     */
    public static void showUpLimit(ArrayList<? extends Dog> list){
        //list.add(new Dog()); // 不可以放对象，因为 不知道具体的类型是什么
        for (Dog dog : list) {
            System.out.println(dog);
        }
    }

    /**
     * 2.类型通配符的下限 super
     * @param list
     */
    public static void showDownLimit(ArrayList<? super Dog> list){
        list.add(new Dog()); // 可以放入对象，因为 最高级的父类就是Object
        for (Object o : list) { // 这里用Object来接收对象
            System.out.println(o);
        }
    }

}

4.3 使用测试

package com.northcastle.genericwildcard;

import sun.reflect.generics.tree.Wildcard;

import java.util.ArrayList;

/**
 * author : northcastle
 * createTime:2021/10/25
 */
public class WildcardApplication {
    public static void main(String[] args) {

        // 2.类型通配符的上限使用
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Dog> dogs = new ArrayList<>();
        ArrayList<Keji> kejis = new ArrayList<>();

        WildcardLimit.showUpLimit(dogs); // Dog
        WildcardLimit.showUpLimit(kejis); // Dog的子类
        //WildcardLimit.showUpLimit(animals); // 不可以，因为此类是Dog的父类，而最高是Dog类

        //3.类型通配符下限的使用
        WildcardLimit.showDownLimit(dogs); // Dog
        WildcardLimit.showDownLimit(animals); // Dog的父类
        //WildcardLimit.showDownLimit(kejis); // 不可以，因为此类是Dog的子类，而最低是Dog类

    }

}

5.完成

Congratulations!
You are one step closer to success!