参考blog：https://blog.csdn.net/s10461/article/details/53941091
泛型中 ？的含义
Generic.java
public class Generic<T> {
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey() {
return key;
}
}
main(测试方法)
//Stu继承了Person
public class main {
@Test
public void generic_class() {
showKeyValue(new Generic<>(new Person("huang")));
Generic<Stu> stu = new Generic<>(new Stu("huang", "24"));
showKeyValue(stu);//这里会报错
showKeyValue(new Generic<>(new Stu("huang", "24")));
//这里不会报错 ，因为这里相当于new Generic<Person>(new Stu("huang", "24"))
}
public void showKeyValue(Generic<Person> gPerson) {
System.out.println("key:"+gPerson.getKey());
}
}
上面的例子说明了Generic<Person>类型的参数，并不能接收Generic<Stu>。
public void showKeyValue(Generic<?> gPerson) {
System.out.println("key:"+gPerson.getKey());
}
这种方式可以解决这个问题，这种写法表示可以接收任何类型的参数，缺点就是只能使用Object类中的方法。
所以经常使用的是<? extends Person>等有边界的方式接收
public void showKeyValue(Generic<? extends Person> gPerson) {
System.out.println("key:"+gPerson.getKey());
}
泛型方法
由一个仿照java.util.Optional的MyOptional来说明。
public class MyOptional<T> {
private T value;
private static final MyOptional EMPTY = new MyOptional();
private MyOptional() {
this.value = null;
}
public MyOptional(T value) {
this.value = Objects.requireNonNull(value);
}
//这是一个泛型方法，用<T> 标注，表示这里的T可以和类上标注的T可以是不同类型
public static <T> MyOptional<T> ofNullable(T value) {
return value == null ? null : new MyOptional<>(value);
}
public T get() {
return this.value;
}
}
测试方法
@Test
public void myOptional_test() {
MyOptional<Person> optional = new MyOptional<>(new Person("huang"));
MyOptional<String> innerOption = optional.ofNullable("chang");//这里optional泛型Person，ofNullable()方法传入的是String类型。
}
注意 ：在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下
public <T extends Number> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
