Java中使用通配符的限制与使用案例解析

UML类图如下

Person类

Student类

Teacher类

Grade类

package com.itheima.demo;

import java.util.ArrayList;
import java.util.Collections;


public class Grade {
	private ArrayList<Teacher> teacherList = new ArrayList<>();
	private ArrayList<Student> studentList = new ArrayList<>();

	```

	public void sortPerson(ArrayList<? extends Person>  list) {
		if(!list.isEmpty()) {
			return;
		}

		 Person p = list.get(0);

		if(p instanceof Student) {
			for (int i = 0; i < list.size(); i++) {
				for (int j = 0; j < list.size() - i - 1; j++) {
					Student s1 = (Student) list.get(j);
					Student s2 = (Student) list.get(j + 1);
					if (s1.getScore() < s2.getScore()) {
						Student temp = s1;
						list.set(j, list.get(j + 1));
						list.set(j + 1, temp);
					}

				}
			}
		}

		if(p instanceof Teacher) {
			for (int i = 0; i < list.size(); i++) {
				for (int j = 0; j < list.size()-i-1; j++) {
					Teacher t1 = (Teacher) list.get(j);
					Teacher t2 = (Teacher) list.get(j+1);
					if(t1.getSalary()<t2.getSalary()) {
						Teacher temp = t1;
						list.set(j,list.get(j+1));
						list.set(j+1,temp);
					}

				}
			}

		}
	}
}

在Java中，通配符（Wildcard）是一种在泛型（Generics）中使用的特殊类型参数，表示可以匹配任意类型。通配符主要有两种形式：? extends T和? super T。它们分别表示上界通配符和下界通配符。

上界通配符 ? extends T

使用? extends T声明的通配符表示该类型是T或T的子类型。这种通配符主要用于读取数据，不能向其中添加新的元素（除了null）。

例子：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<? extends Number> list = new ArrayList<Integer>();
        
        // 不能添加元素
        // list.add(10); // 编译错误
        // list.add(10.5); // 编译错误

        // 可以读取元素
        Number num = list.get(0); // 编译通过
        
        // 可以添加 null
        list.add(null); // 编译通过
    }
}

在这个例子中，List<? extends Number>可以持有任何Number的子类类型的列表。你可以从这个列表中读取Number类型的元素，但不能向其中添加具体的元素，因为编译器无法确定列表实际持有的具体类型。

下界通配符 ? super T

使用? super T声明的通配符表示该类型是T或T的父类型。这种通配符主要用于写入数据。

例子：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<? super Integer> list = new ArrayList<Number>();

        // 可以添加 Integer 及其子类的元素
        list.add(10); // 编译通过
        list.add(20); // 编译通过
        
        // 不能读取具体类型的元素（只能读取为Object）
        // Integer num = list.get(0); // 编译错误
        Object obj = list.get(0); // 编译通过
    }
}

在这个例子中，List<? super Integer>可以持有任何Integer的父类类型的列表。你可以向这个列表中添加Integer类型的元素，但从中读取时只能作为Object类型，因为编译器无法确定列表实际持有的具体类型。

结论

使用通配符声明的泛型类型在以下方面具有限制：

• ? extends T：允许读取T或T的子类型的元素，不允许添加具体元素（除了null）。
• ? super T：允许添加T或T的子类型的元素，但读取时只能作为Object类型。

这些限制是为了确保类型安全性，避免在运行时出现类型转换异常。