Java泛型extends及super区别实例解析

Java中的泛型可以指定一个类型参数，例如List，这表示这个List只能添加String类型的元素，否则编译器会报错。此外，泛型中还有一个重要的概念：泛型通配符。泛型通配符可以用来表示某个类的任意类型参数，例如List<?>，这表示这个List可以添加任意类型的元素。

当我们使用泛型通配符时，有时候需要限制可以添加的元素类型，这时可以使用extends或super关键字，本文就是要讲解extends及super的区别。

1. extends

extends关键字用于限制泛型的上界，表示只能添加该类型及其子类。例如：

public class Box<T extends Number> {
    private List<T> list = new ArrayList<>();

    public void add(T t) {
        list.add(t);
    }

    public T get(int index) {
        return list.get(index);
    }

    public static void main(String[] args) {
        Box<Integer> box = new Box<>();
        box.add(1);
        box.add(2);
        System.out.println(box.get(0) + box.get(1));
    }
}

上面这个例子中，Box限制了Box只能添加Number及其子类，这样在add方法中添加Integer类型的元素是没有问题的。

2. super

super关键字用于限制泛型的下界，表示只能添加该类型及其父类。例如：

public class Box<T> {
    private List<? super T> list = new ArrayList<>();

    public void add(T t) {
        list.add(t);
    }

    public Object get(int index) { // 注意这里返回类型为Object
        return list.get(index);
    }

    public static void main(String[] args) {
        Box<Integer> box = new Box<>();
        box.add(1);
        box.add(2);
        System.out.println(box.get(0) + (int)box.get(1));
    }
}

上面这个例子中，Box<? super T>限制了Box只能添加T及其父类，这样在add方法中添加Integer类型的元素是没有问题的。注意到get方法返回类型为Object，需要将第二个元素转换为int类型才能进行加法运算。

3. 示例

下面给出一个更加具体的例子，说明extends和super的区别。

假设有一个类Person和其子类Employee，代码如下：

public class Person {
    private String name;

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

    public String getName() {
        return name;
    }
}

public class Employee extends Person {
    private int salary;

    public Employee(String name, int salary) {
        super(name);
        this.salary = salary;
    }

    public int getSalary() {
        return salary;
    }
}

现在有一个类Company，表示一家公司，它有一个泛型属性staff，表示公司员工，代码如下：

public class Company<T> {
    private List<T> staff = new ArrayList<>();

    public void add(T person) {
        staff.add(person);
    }

    public T get(int index) {
        return staff.get(index);
    }

    public void printSalary() {
        for (T person : staff) {
            if (person instanceof Employee) {
                System.out.println(person.getName() + "的工资是" + ((Employee) person).getSalary());
            }
        }
    }
}

注意到在printSalary方法中，需要将person转换为Employee类型才能获取其工资。现在我们来测试一下这个类。

public static void main(String[] args) {
    Company<Person> company1 = new Company<>();
    company1.add(new Person("张三"));
    company1.add(new Person("李四"));
    company1.printSalary();

    Company<Employee> company2 = new Company<>();
    company2.add(new Employee("王五", 5000));
    company2.add(new Employee("赵六", 6000));
    company2.printSalary();

    Company<? extends Person> company3 = company2;
    company3.printSalary();

    Company<? super Employee> company4 = new Company<>();
    company4.add(new Employee("钱七", 7000));
    company4.add(new Person("吴八")); // 编译器报错
}

第一个公司company1没有任何员工的工资，输出为空。第二个公司company2有两个员工，输出他们的工资。第三个公司company3是company2的子类，因此也可以成功输出员工的工资。最后一个公司company4只能添加Employee类型的员工，而添加Person类型的员工会导致编译器报错。