Java泛型中通配符的使用

旧城等待， 2022-09-21 13:00 154阅读 0赞

## 学习目标 ##

掌握通配符“?” 的使用

掌握受限泛型的设置

掌握泛型与子类继承的限制

## 匹配任意类型的通配符 ##

在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行传递的时候泛型类型必须匹配才可以传递。否则是无法传递的。

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo12{
    	public static void main(String args[]){
    		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
    		i.setVar("lx") ;							// 设置内容
    		fun(i) ;
    	}
    	public static void fun(Info<Object> temp){		// 接收Object泛型类型的Info对象
    		System.out.println("内容：" + temp) ;
    	}
    };

编译时就出现错误：

![Center][]

泛型对象进行引用传递的时候，类型必须一致。如果现在非要传递，则可以将fun方法中的泛型取消掉。如下所示：

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo13{
    	public static void main(String args[]){
    		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
    		i.setVar("WWWW") ;							// 设置内容
    		fun(i) ;
    	}
    	public static void fun(Info temp){		// 接收Object泛型类型的Info对象
    		System.out.println("内容：" + temp) ;
    	}
    };

发现有警告提示：

![Center 1][]  
但不会影响程序的运行：

![Center 2][]

以上确实完成了改进的功能，但是，代码似乎有些不是很妥当，毕竟之前已经指定过泛型了。

如果使用？呢？如下所示：

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo14{
    	public static void main(String args[]){
    		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
    		i.setVar("MLDN") ;							// 设置内容
    		fun(i) ;
    	}
    	public static void fun(Info<?> temp){		// 可以接收任意的泛型对象
    		System.out.println("内容：" + temp) ;
    	}
    };

能照常运行，而且不会有警告。

注意：如果使用？意味着可以接收任意的内容，但是此内容却无法直接使用<?> 修饰的泛型对象进行修改。如下所示：

发现有错误，警告和运行结果分别如下所示：

![Center 3][]

![Center 4][]

也就是说，在使用户<?> 只能接收。但是不能修改。

## 受限泛型 ##

之前设置泛型类型的时候，实际上都是可以任意设置的，只要是类就可以设置。但是在Java的泛型中可以指定一个泛型的上限和下限。范围的上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类。

设置上限：

声明对象：类名称<? extends 类>  对象名称

定义类: \[访问权限\] 类名称<泛型标示 extends 类>\{\}

设置下限：

声明对象：类名称<? super 类> 对象名称

定义类：\[访问权限\] 类名称<泛型标示 super 类>\{\}

## 设置上限 ##

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo17{
    	public static void main(String args[]){
    		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
    		Info<Float> i2 = new Info<Float>() ;			// 声明Float的泛型对象
    		i1.setVar(30) ;									// 设置整数，自动装箱
    		i2.setVar(30.1f) ;								// 设置小数，自动装箱
    		fun(i1) ;
    		fun(i2) ;
    	}
    	public static void fun(Info<? extends Number> temp){	// 只能接收Number及其Number的子类
    		System.out.print(temp + "、") ;
    	}
    };

![Center 5][]

如果在方法中传递的不是泛型标示不是Number及其子类，则会报错，如下所示：

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo18{
    	public static void main(String args[]){
    		Info<String> i1 = new Info<String>() ;		// 声明String的泛型对象
    		i1.setVar("hello") ;
    		fun(i1) ;
    	}
    	public static void fun(Info<? extends Number> temp){	// 只能接收Number及其Number的子类
    		System.out.print(temp + "、") ;
    	}
    };

在类中也可以使用泛型，如下所示：

class Info<T extends Number>{	// 此处泛型只能是数字类型
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo19{
    	public static void main(String args[]){
    		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
    	}
    };

如果现在在使用Info的时候设置成了String类型，则在编译的时候就会出现错误。

class Info<T extends Number>{	// 此处泛型只能是数字类型
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo20{
    	public static void main(String args[]){
    		Info<String> i1 = new Info<String>() ;		// 声明Integer的泛型对象
    	}
    };

## 设置下限 ##

当使用的泛型只能在本类以及父类类型应用的时候，就必须使用泛型的范围下限配置

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo21{
    	public static void main(String args[]){
    		Info<String> i1 = new Info<String>() ;		// 声明String的泛型对象
    		Info<Object> i2 = new Info<Object>() ;		// 声明Object的泛型对象
    		i1.setVar("hello") ;
    		i2.setVar(new Object()) ;
    		fun(i1) ;
    		fun(i2) ;
    	}
    	public static void fun(Info<? super String> temp){	// 只能接收String或Object类型的泛型
    		System.out.print(temp + "、") ;
    	}
    };

![Center 6][]

如果现在使用了Integer作为泛型的类型，则不满足泛型的下限。如下所示：

class Info<T>{
    	private T var ;		// 定义泛型变量
    	public void setVar(T var){
    		this.var = var ;
    	}
    	public T getVar(){
    		return this.var ;
    	}
    	public String toString(){	// 直接打印
    		return this.var.toString() ;
    	}
    };
    public class GenericsDemo22{
    	public static void main(String args[]){
    		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
    		i1.setVar(30) ;
    		fun(i1) ;
    	}
    	public static void fun(Info<? super String> temp){	// 只能接收String或Object类型的泛型
    		System.out.print(temp + "、") ;
    	}
    };

解释：泛型与子类继承的限制

一个类的子类可以通过对象多态性，为其父类实例化，但是在泛型操作中，子类的泛型类型是无法使用父类的泛型类型接收的，例如：Info<String> 不能使用Info<Object>接收。

![Center 7][]

实例如下：

![Center 8][]  
发现有错误提示。

总结：

1、使用?可以接收任意的泛型类型。

2、泛型的上限：? extends 类型。

3、泛型的下限用的不是太多。

4、了解为什么泛型子类之间的继承无法直接转换的原因。

[Center]: /images/20220721/30af4d36b88a4c24ab7cca742c532be3.png
[Center 1]: /images/20220721/04cc3c5d70254181b695147d0b058843.png
[Center 2]: /images/20220721/de397fec4abd4df19f13e15b3f10e2b9.png
[Center 3]: /images/20220721/408a4a6a9e8d4aba81f7a3ecf5e07dfb.png
[Center 4]: /images/20220721/fbb6e1bb0d26492c98c3d8f1d84a98ec.png
[Center 5]: /images/20220721/eeee4e44993744339dc8288e6109ecdd.png
[Center 6]: /images/20220721/f205964d0b92466abba312d94e6b7516.png
[Center 7]: /images/20220721/fed24eab356f4dec84aa9636ab7efe88.png
[Center 8]: /images/20220721/4d9dd34a59224424af945f84ac284a55.png