结论
List<? extends T>：
- 编译器无法确定List所持有的类型
- 一般用于返回值（对于返回值，我们需要让参数“宽松”，所以用派生类）
- 查询多的时候用。
List<? super T>：
- 编译器可以确定List所持有的类型
- 一般用于入参（对于入参，我们需要让参数“严格”，所以用基类。）
- 插入多的时候用。
1. 基本概念
? 通配符类型
<? extends T> 表示类型的上界，表示参数化类型的可能是T 或是 T的子类
<? super T> 表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object
2. 插入用super, 查询用extend
image.png
List<? extends Father> 表示 “具有任何从Father继承类型的列表”
编译器无法确定List所持有的类型，所以无法安全的向其中添加对象。
可以添加null,因为null 可以表示任何类型。
所以List 的add 方法不能添加任何有意义的元素，
但是可以接受现有的子类型List 赋值。
下面是网上找的示例：
原文链接：https://blog.csdn.net/qq_16605855/article/details/85278267
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
import net.bytebuddy.asm.Advice;
import org.aspectj.weaver.ast.Var;
import org.springframework.data.annotation.AccessType;
import javax.persistence.Access;
import java.util.List;
import java.util.Vector;
import java.util.function.Function;
import java.util.stream.Stream;
/**
* @author: qiaozhy
* @Description:
* @Date: 2019/5/4 4:50 PM
*/
class Test {
public static void main(String[] args) {
(new Test()).act();
}
public void act() {
Vector<First> vs = new Vector<First>();
// vs.add(new Base());//错误，First容器只能装First及其子类，不能装First的超类，
vs.add(new Second());
List<? super Second> vSuper = new Vector<First>();//可以容纳本类及子类，但无法容纳超类
// vSuper.add(new Base());错误vSuper只是Vector<First>的引用，First的容器只能装First及其子类，不能装它的超类
// vSuper.add(new First()); 错误
vSuper.add(new Second()); //正确
vSuper.add(new Third()); //正确
checkSuper(new Vector<First>());//可以传递超类、本类参数，但无法传递子类参数
checkSuper(new Vector<Second>());
// checkSuper(new Vector<Third>());//错误
List<? extends Second> vExtends = new Vector<Second>();//不能容纳任何子类、本类、超类
// vExtends.add(new First());错误
// vExtends.add(new Second());//错误
// vExtends.add(new Third());//错误
vExtends.add(null);//正确，但是没用
// checkExtends(new Vector<First>());//错误，无法传递超类参数
checkExtends(new Vector<Second>());//能够传递本类及子类参数
checkExtends(new Vector<Third>());
//List<? super T> 当容器用时，能容纳T本身及T的子类，但无法容纳T的超类。用来向函数传递参数时，只能传递T及T的超类
//List<? extends T> 当容器用时，只能容纳null，没什么用处。用来向函数传递参数时，只能传递T及T的子类，不能传递T的超类
Second second = new Second();
second.setName("qiao");
second.setId("11");
second.setKind("11");
final Function<Second, First> firstBaseFunction = t -> {
return (First) t;
};
final Function<First, Base> firstBaseFunction1 = t -> {
return (Base) t;
};
final Base apply1 = firstBaseFunction1.compose(firstBaseFunction).apply(second);
System.out.println(apply1);
//second extends first
final Function<Second, Second> firstBaseFunction2 = t -> {
return t;
};
final Base apply2 = firstBaseFunction1.compose(firstBaseFunction2).apply(second);
System.out.println(apply2);
//second extends first
final Function<Base, First> firstBaseFunction3 = t -> {
return (First) t;
};
final Base apply3 = firstBaseFunction1.compose(firstBaseFunction3).apply(second);
System.out.println(apply3);
}
public void checkSuper(List<? super Second> a) {
}
public void checkExtends(List<? extends Second> a) {
}
@Data
@ToString
public class Base{
@Override
public String toString() {
return "Base{" +
"id='" + id + '\'' +
'}';
}
String id;
}
@Data
public class First extends Base{
String name;
@Override
public String toString() {
return "First{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
'}';
}
}
@Data
public class Second extends First {
@Override
public String toString() {
return "Second{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", kind='" + kind + '\'' +
'}';
}
String kind;
}
@Data
public class Third extends Second {
String color;
@Override
public String toString() {
return "Third{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", kind='" + kind + '\'' +
", color='" + color + '\'' +
'}';
}
}
}
