Wildcard (Wildcard), using a question mark to represent type parameters, is a Methodrepresenting the [type constraint] of[unknown type].
Generics define the data type as a parameter, and we can specify the specific type when used. But if the specific type cannot be determined when it is used, you need to rely on wildcards to solve it.
Abstractly speaking, because generics do not support covariance, wildcards are introduced to make generic types covariant.
Let’s explore the role of wildcards through two examples.
ArrayList
Observe the code and find that:
The elements stored in the ArrayList are supported Upcast from String -> Object, because String is a subclass of Object.
A compilation error occurred when the parameter type of ArrayList was converted from String -> Object, because generics do not support covariance.
ArrayListlist_str = new ArrayList (); list_str.add("hello"); ArrayList list_int = new ArrayList (); list_int.add(100); ArrayList list = null; list = list_str; System.out.println(list.get(0)); // hellolist = list_int; System.out.println(list.get(0)); // 100//编译错误list.add("hello"); list.add(100);
to observe the code and find:
in After using wildcards, it allows it to accept any type of transformation, which just solves the limitation that generics do not support covariance.
But at the same time, it also loses the right to add any type of object to it.
There are three forms of wildcards, namely:
//1、无限定通配符 Demo//2、上边界限定通配符 Demo< ? extends Number> //3、下边界限定通配符 Demo< ? super Number>
Observe the following example: three classes with inheritance relationships are defined, namely Person -> Man -> Worker.
class Person{ void print(){ } } class Man extends Person{ void paly(){ } } class Worker extends Man{ void say(){ } }public class Test { public static void main(String[] args) { // 创建了三个 ArrayList 数组 ArrayList personList = new ArrayList(); ArrayList manList= new ArrayList(); ArrayList workerList = new ArrayList(); // 限定了上界， ？ 代表 Man 以及继承 Man 的类 ArrayList list = null; list = manList; list = workerList; // 编译错误，因为 Person 是 Man 的父类 list = personList; // 编译错误，因为使用了通配符就不能添加对象 list.add(new Man()); list.add(new Worker()); for(Man man : list){ man.print(); man.paly(); } for(Person per : list){ per.print(); } // 编译错误，因为 ？ 也可以代表 Man // 从继承我们可以知道 Worker 肯定是 Man，但 Man 不一定是 Worker。 // for(Worker worker : list); } }
// 省略相同代码...public class Test { public static void main(String[] args) { ArrayList personList = new ArrayList(); ArrayList manList= new ArrayList(); ArrayList workList = new ArrayList(); // 限定了下届， ？ 代表 Man 以及 Man 的父类 ArrayList list = null; list = personList; list = manList; // 编译错误，因为 Worker 是 Man 的子类 list = workList; // 编译错误，无法确定其父类对象 // Person 继承子 Cell 类，那么用 Person 遍历就是错误的 // for(Man man : list); // for(Person per : list); // 因为 Object 是所有类的根类,所以可以用Object来遍历 // for(Object obj : list); } }
// 省略相同代码...public class Test { public static void main(String[] args) { ArrayList personList = new ArrayList(); ArrayList manList= new ArrayList(); ArrayList workList = new ArrayList(); //无边界通配符 ArrayList list = null; //可以代表一切类型 list = personList; list = manList; list = workList; //为了避免类型混淆，只允许使用 Object 遍历 for(Object obj : list); } }
The above is the content of 12.Java Basics - Wildcards. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!