为什么需要通配符：

class Message<T> {
	private T message ;
	public T getMessage() {
	return message;
	}

	public void setMessage(T message) {
		this.message = message;
	}
}

public class TestDemo {
	public static void main(String[] args) {
	Message<String> message = new Message() ;
		essage.setMessage("haha");
	fun(message);
	}
	public static void fun(Message<String> temp){
		System.out.println(temp.getMessage());
	}
}

public class TestDemo {
	public static void main(String[] args) {
	Message<String> message = new Message() ;
	message.setMessage("123");
	fun(message);//会报错，只能接受String类型
}
	public static void fun(Message<String> temp){
		System.out.println(temp.getMessage());
	}
}

通配符的3种用法
1.<?>
由于传入类型无法确定，因此无法设置具体值到相应对象中。只能取得泛型对象中的值，无法通过类似setter方法设置值。

/*
？  通配符
 */
class MyClass<T>{
    private T t;
    public T getT(){
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class Test2 {
    public static void main(String[] args) {
        MyClass<Integer> myClass = new MyClass<>();
        myClass.setT(123);
        fun(myClass);
        MyClass<String> myClass1 = new MyClass<>();
        myClass1.setT("hello");
        fun(myClass1);
    }
    // fun可以接收Myclass的所有类型
    public static void fun(MyClass<?> myClass){//这个方法可以接收任意类型的MyClass
        //类型不定，所以只能取得,无法设置。
        System.out.println(myClass.getT());
    }
}

2.<？ extends 类> 表示泛型上限，类与方法均可使用
例：
class MyClass< T extends Number >
此时T必须是Number的子类，设定天花板
public void fun(MyClass<? extends Number> myClass)
？指代任意类型，但是此时必须传入Number及其子类MyClass对象，此时方法中依然不能设置值，只能取得值。因为现在只能确定是父类，由于子类不确定。此事发生向下转型存在不确定性因此无法设置具体值。

/*
？ extends 类
设置泛型上限
依然无法设置值，只能取得值
 */
class MyClass<T extends Number>{
    private T t;
    public T getT(){
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class Test3 {
    public static void main(String[] args) {
        MyClass<Integer> myClass = new MyClass<>();
        myClass.setT(123);
        fun(myClass);
//        MyClass<String> myClass1 = new MyClass<>();
//        myClass1.setT("hello");
//        fun(myClass1);
        //不能接收非Number子类的值
    }

    public static void fun(MyClass<? extends Number> myClass){
        System.out.println(myClass.getT());
    }
}

3.<？ super 类> 表示泛型下限，只能用在方法级别
class MyClass< T super Number >
此时？必须是Number的父类。
public void fun（MyClass<? super String>myClass）{}此时方法可以设置值，因为发生天然的向上转型。

/*
？ super 类
设置下限
 */
class MyClass<T>{
    private T t;
    public T getT(){
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class Test4 {
    public static void main(String[] args) {
        MyClass<String> myClass = new MyClass<>();
        myClass.setT("231121321321321322");
        fun(myClass);

    }

    //此时fun可以接受Myclass子类是String的任意类型，可以接收String及其父类
    //String是一个final class 没有子类，只有父类，父类为Object
    public static void fun(MyClass<? super String> myClass){
        myClass.setT("hello world");//相当于Object obj = new String("hello world")
        System.out.println(myClass.getT());
    }

}