Java-泛型限定符、通配符

关键字：泛型、限定符、通配符

https://www.jianshu.com/p/897fba7bfe7b
这篇文章讲了什么是泛型、为什么会有泛型、泛型使用的注意事项。
下面讲点别的内容。

限定符

限定符，可以限定传入的类型，以达到某种相同操作的目的。
限定符是在定义类、接口或者方法的时候使用的，这有别于通配符。

以下例子，限定符定义在类上，T extends Number，限定了定义变量的类型，传入类型必须是Number的子类或者本身，

public class Test<T extends Number> {
    public T data; 
}

Test<Integer> integerTest=new Test<>();//实例化Test<Integer>，因为Integer是Number的子类，所以可以编译通过
Test<Double> doubleTest=new Test<>();//实例化Test<Double>，因为Double是Number的子类，所以可以编译通过
Test<Number> numberTest=new Test<>();//实例化Test<Number>，因为是Number本身，所以可以编译通过
Test<Activity> activityTest=new Test<>();//实例化Test<Activity>，因为Activity不是Number的子类，所以编译不通过

以下例子，限定符定义在方法上，限定了参数的类型，传入类型必须是Number的子类或者本身，

test(new Integer(10),new Integer(10));//调用test方法，因为Integer是Number的子类，所以可以编译通过
test(new Double(10),new Double(10));//调用test方法，因为Double是Number的子类，所以可以编译通过
test(new Object(),new Object());//调用test方法，因为Object不是Number的子类，所以编译不通过

public <T extends Number>  void test(T  i, T j) {
       Object data = i.data;
       Object data1 = j.data;
}

通配符

通配符跟限定符作用一样，限定传入的类型，以达到某种相同操作的目的。
只不过通配符是在定义方法的时候使用的，这有别于限定符。
（1）? extends Number，限定了参数的类型，传入的类型必须是Number的子类或者本身，限定了上限；

public class Test<T> {
    public T data; 
}

Test<Integer> integerTest=new Test<>();
Test<Number> numberTest=new Test<>();
Test<Double> doubleTest=new Test<>();
Test<Activity> activityTest=new Test<>();

test(integerTest, doubleTest);//调用test方法，因为Integer是Number的子类，所以可以编译通过，
test(numberTest, numberTest);//调用test方法，因为是Number本身，所以可以编译通过，
test(doubleTest, doubleTest);//调用test方法，因为Double是Number的子类，所以可以编译通过，

test(activityTest, activityTest);//调用test方法，因为Activity不是Number的子类，所以无法可以编译通过，

public void test(Test<? extends Number> i, Test<? extends Number> j) {
        Number data = i.data;//因为限定了上限是Number，所以定义Number在接收参数没有问题
        Number data1 = j.data;
}

（2）? super Number，限定了参数的类型，传入的类型必须是Number的父类或者本身，限定了下限；

public class Test<T> {
    public T data; 
} 

Test<Number> numberTest = new Test<>();
Test<Object> objectTest = new Test<>();
Test<Integer> integerTest = new Test<>();
        
test(numberTest, numberTest);//调用test方法，因为是Number本身，所以可以编译通过
test(objectTest, objectTest);//调用test方法，因为Object是Number的父类，所以可以编译通过
test(integerTest, integerTest);//调用test方法，因为Integer不是Number的父类，所以无法可以编译通过

 public void test(Test<? super Number>  i, Test<? super Number> j) {
        Object data = i.data;//因为限定了下限是Number，但是用Number类型接收参数显然有问题，所以Object接收
        Object data1 = j.data;
    }

总结：

限定符、通配符作用一样，只不过使用的场景不同，限定符是在定义类、接口或者方法的时候使用的，通配符是在定义方法的时候使用的。

以上分析有不对的地方，请指出，互相学习，谢谢哦！