泛型的上下边界 ： ? extends E 与 ? super T

*   ? extends E 是 泛型 的上边界 ，  ? super T 是 泛型的下边界 。 

一、首先：创建Student 和 BaseStudent 两个类。 

Student.java:

package com.demo.main;

public class Student {
	public String name ;
	public int age ;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	} 
}

BaseStudent.java:

package com.demo.main;

public class BaseStudent extends Student{

	public BaseStudent() {
		super();
		// TODO Auto-generated constructor stub
	}

	public BaseStudent(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public String toString() {
		return "BaseStudent []";
	}
	
}

1、 ? extends E  

举个例子：

（1）? extends E  的意思是： E 代表 父类 ， ？代表 子类 ， 所有父类E 可以 使用到的功能 E的所有的子类 都可以使用，如：addAll（? extends E）, addAll可以向集合中添加E类的对象元素，同时也可以向集合中添加 E类 所有子类的对象元素 。 

例子：BaseStudent extends Student  。

代码如下:

package com.demo.main;

import java.util.ArrayList;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) {

		ArrayList<Student> list1 = new ArrayList<>() ;
		list1.add(new Student("1",1));
		ArrayList<Student> list2 = new ArrayList<>(); 
		list2.add(new Student("2",2));
		list1.addAll(list2);
		System.out.println(list1);//[Student [name=1, age=1], Student [name=2, age=2]]
		ArrayList<BaseStudent> list3 = new ArrayList<>() ;
		list1.add(new Student("3",3));
		list1.addAll(list3);
		System.out.println(list1);//[Student [name=1, age=1], Student [name=2, age=2], Student [name=3, age=3]]
	}

}

list3<BaseStudent> 和 list2<Student> 的 对象元素 都添加到了 list1<Student>中了。

2、？super T

意思是这样，但是不能这么想，这么想的话，下面的例子就讲不通了。

代码如下：

package com.demo.main;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class Main {

	public static void main(String[] args) {

		TreeSet<Student> set1 = new TreeSet<>(new getComparator()) ; 
		set1.add(new Student("李四",14));
		set1.add(new Student("王五",15));
		set1.add(new Student("张三",13));
		System.out.println(set1);
		
		TreeSet<BaseStudent> set2 = new TreeSet<>(new getComparator()) ;
		set2.add(new BaseStudent("陈七",13));
		set2.add(new BaseStudent("张三",13));
		set2.add(new BaseStudent("赵六",13));

		System.out.println(set2);
	}

}
class getComparator implements Comparator<Student>{

	@Override
	public int compare(Student o1, Student o2) {
		int lenght = o1.getName().length() - o2.getName().length() ; 
		int number = lenght == 0 ? o1.getName().compareTo(o2.getName()) : lenght ; 
		return number == 0 ? o1.getAge() - o2.getAge() : number ;
	}
	
}

思路：

？extends T 是往里 拿  ， ? super E 是往外 拿。 

往里：类似于 ：往存储父类类型对象的集合里面拿。addAll 。  从子类类型集合 -> 父类类型集合 。

往外：类似于：往用来比较父类类型对象的比较器中拿。comparator 。从子类类型集合 -> 外部用来处理父类的方法 。

不管是 往里  还是  往外  都是用到了  父类引用调用子类对象  ：父类  p = new 子类（）； 

知识点推荐博客： https://blog.csdn.net/Justin_zhao/article/details/77750440