泛型通配符？和类型参数T的区别

今天就泛型的？和T进行区分了解，这篇先暂不深入，后面会详细写一篇关于泛型、泛型擦除等知识点。
对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?> ），表示可以持有任何类型

目录:
上下界通配符
？和T的区别
Class 和 Class<?> 区别

上界通配符 < ? extends E>
上界：
用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。
在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类
1、如果传入的类型不是 E 或者 E 的子类，编译不成功
2、泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

public <K extends A, E extends B> E compare(K arg1, E arg2){
    E result = arg2;
    arg2.compareTo(arg1);
    //.....
    return result;
}

下界通配符 < ? super E>
下界:
用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object。
在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
比如以下例子 test方法中的? 必须是T或者T的父类,传入的是Animal

private <T> void test(List<? super T> dst, List<T> src){
    for (T t : src) {
        dst.add(t);
    }
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = new ArrayList<>();
    new Test3().test(animals,dogs);
}
// Dog 是 Animal 的子类
class Dog extends Animal {

}

dst 类型 “大于等于” src 的类型，这里的“大于等于”是指 dst 表示的范围比 src 要大，因此装得下 dst 的容器也就能装 src 。

？和T的区别

//指定集合元素只能是T类型
List<T> list = new ArraryList<T>();
//可以放任意类型，那就没意义了 所以？一般用在方法
List<?> list = new ArrayList<?>();

？和 T 都表示不确定的类型，区别在于我们可以对 T 进行操作，但是对 ？不行，比如如下这种 ：

//可以
T t = test();
//不可以
？Animal = test();

简单总结下：
T 是一个 确定的 类型，通常用于泛型类和泛型方法的定义，？是一个 不确定 的类型，通常用于泛型方法的调用代码和形参，不能用于定义类和泛型方法。
通过 T 来 确保 泛型参数的一致性
类型参数T可以多重限定而通配符?不行
通配符?可以使用超类限定而类型参数T不行

//T只有一种限定方式
T extends A
//?有两种方式
？ extends A
？ super A

Class 和 Class<?> 区别
这种方式在反射中最为常见

 /**
     * 返回的部分字段置空值
     * @param analysisRows
     * @throws IllegalAccessException
     */
    public void convertBlankField(AnalysisRows analysisRows) throws IllegalAccessException {
        Class<?> clazz = AnalysisRows.class;
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(BlankAno.class)) {
                field.setAccessible(true);
                field.set(analysisRows,"");
            }
        }
    }

Class 在实例化的时候，T 要替换成具体类。Class<?> 它是个通配泛型，? 可以代表任何类型，所以主要用于声明时的限制情况。所以当不知道定声明什么类型的 Class 的时候可以定义一 个Class<?>。

// 可以
public Class<?> clazz;
// 不可以，因为 T 需要指定类型
public Class<T> clazzT;

那如果也想 public Class clazzT; 这样的话，就必须让当前的类也指定 T ，

public class Test<T> { //这里指定T
    public Class<?> clazz;
    // 不会报错
    public Class<T> clazzT;