泛型-通配符-------（2）

已于 2022-12-06 10:43:06 修改
阅读量494 收藏 1
点赞数
分类专栏： java问题 文章标签： 泛型 泛型的通配符 受限泛型 泛型上限 泛型下限
于 2017-07-15 14:16:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jakezhang1990/article/details/75158531
版权

这里写目录标题

1，匹配任意类型的通配符

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

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("MLDN") ;							// 设置内容
		fun(i) ;
	}
	public static void fun(Info<Object> temp){		// 接收Object泛型类型的Info对象
		System.out.println("内容：" + temp) ;
	}
};

运行结果：
这里写图片描述
发现报错了，编译报错提示，object类型的泛型不能接收string类型的泛型。Info<String> Info<Object>

泛型对象进行引用传递的时候，类型必须一致，否则无法传递，因为泛型本身就是一个标识符，具体的类型是从外面确定外面传入的，
编译器只判断是不是相同的标识符，不是相同的标识符就编译报错了

问题：

对于上面的问题，泛型类型不一致所以无法传递引用数据类型，但是如果现在我坚持，非要这么传递呢？该怎么办呢？

解决

其实，也简单，可以将fun方法中Info参数的泛型取消掉。

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("MLDN") ;							// 设置内容
		fun(i) ;
	}
	public static void fun(Info temp){		// 接收Object泛型类型的Info对象
		System.out.println("内容：" + temp) ;
	}
};

这里写图片描述

解决的不彻底，引入了新问题

发现，执行没有任何问题，取消掉参数的泛型以后，可以正常执行，但是这样似乎不太妥当，因为毕竟Info在声明的时候是指定了泛型的，

那么，如何解决这个不太妥当的问题呢？

整理一下现状：
在这个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 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) ;
	}
};

这里写图片描述
在程序的fun（）方法中使用Info<?>的代码形式，表示可以使用任意泛型类型对象，这样做的话，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 GenericsDemo15{
	public static void main(String args[]){
		Info<?> i = new Info<String>() ;		// 使用 ？接收String泛型类型
		i.setVar("MLDN") ;							// 设置内容
	}
};

这里写图片描述
发现编译时报错了，在使用“？”的时候，只能接收，不能修改。
？并不表示某个具体的泛型类型，问号表示并不知道内部是什么泛型，只是黑盒接收该泛型过来而已，并不能修改。
使用？只能接收，不能修改；

2，受限泛型

之前设置泛型的时候，实际上都是可以任意设置的，只要是类就可以设置，比如String，Float，Integer。。。。。。但是在Java的泛型中可以指定一个泛型的 上限和下限。即表示，泛型最大到哪个父类，最小到哪个子类；

在应用传递中，泛型的曹组可以设置一个泛型对象的范围上限和范围下限。
范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类；而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至object类。
这里写图片描述

设置上限，使用extends：

上限及表示，最大是本类及本类的子类。

class Info<T extends Number>{

<T extends Number>表示上限：最高就是Number的类型，或者是Number的子类的数据类型。不能高于Number，比如Number之上的Object就是不可以的

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 + "、") ;
	}
};

这里写图片描述

错误用法：

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 + "、") ;
	}
};

这里写图片描述

在类上使用泛型上限：最大是Number或者是Number的子类。String并不是Number的子类，所以fun()方法并不能接收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 GenericsDemo19{
	public static void main(String args[]){
		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
		// 错误，无法声明String的泛型对象，Info在定义的
		Info<String> i1 = new 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[]){
		// 错误，无法声明String的泛型对象，Info在定义的时候已经声明，只能接收Number及其子类的泛型类型
		Info<String> i1 = new Info<String>() ;		
	}
};

在这里插入图片描述
Info在定义的时候已经声明，只能接收Number及其子类的泛型类型，最高不能超过Number。传入String类型，编译时候肯定会报错，因为String并不是Number的子类，。

设置下限，使用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 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 + "、") ;
	}
};

运行结果，看到没有任何问题。
这里写图片描述

Info<? super String>泛型的上限是String或者String的父类，也就是Object。如果使用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 + "、") ;
	}
};

运行结果看到了，fun（Info<? super String>）方法中泛型最低的下限到String，现在传入的是Integer，并不符合条件，所以无法设置。
这里写图片描述

泛型的上限，下限就是extends与super关键字。

3，泛型与子类继承的限制

一个类的子类可以通过对象的多态性，为其父类实例化，也就是父类可以接收子类对象，
但是在泛型的操作中，子类的泛型类型是无法使用父类的泛型类型接收的，泛型类型必须完全一致才可以接收。但是可以使用通配符进行接收，这样的话当然接得接收收后不能修改的限制。。
比如：Info<String> 不能使用Info<Object>接收。但是可以使用通配符进行接收。

这里写图片描述

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 GenericsDemo23{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 泛型类型为String
		Info<Object> i2 = null ;
		Info<?> i3=null;
		i2 = i1 ;//这是错误的
		i3=i1;//这就没问题了，正确
	}
};

这是无法执行的，只能使用通配符来接收。

这里写图片描述

总结:

1,使用“？”可以接收任意的泛型对象。
2，泛型的上限：Info<? extends Number> 泛型数据类型是Number或者Number的子类。
3，泛型的下限：Info<? super String> 泛型的数据类型是String以及String的父类都是可以的
4，为什么泛型子类之间的继承无法直接转换的原因。子类的泛型类型是无法使用父类的泛型类型接收的，泛型类型必须完全一致才可以接收。但是可以使用通配符进行接收，这样的话当然接得接收收后不能修改的限制。

费城之鹰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
八、Dart中泛型/泛型定义与使用
girl23zhouzhou的博客
01-27 993
1. Dart 泛型 1.1 泛型的理解 在 API 文档中你会发现基础数组类型List的实际类型是List<E>。 <…> 符号将 List 标记为泛型(或参数化) 类型。 这种类型具有形式化的参数。 通常情况下，使用一个字母来代表类型参数， 例如 E, T, S, K, 和 V 等。 泛型:通俗的理解: 就是解决类的接口, 方法, 复用性, 以及对不特定数据类型的支持(类型校验), 在通俗一点,就是对于类型的约束. 1.2 泛型的定义 使用&l...
泛型通配符
Leon_Jinhai_Sun的博客
03-07 246
泛型通配符 当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。 通配符基本使用 泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。 此时只能接受数据,不能往该集合中存储数据。 举个例子大家理解使用即可： public st...
Java泛型的初步认识与使用
她的坏机器人
08-05 234
什么是泛型 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致 特点 编译时即可检查，而非运行时抛出异常 访问时，不必类型转换 不同泛型之间引用不能相互赋值，泛型不存在多态 不能包含仅使用泛型作为参数的重载方法 泛型的好处： 提高代码的重用性 防止类型转换异常，提高代码的安全性 泛型类 就比如ArrayList类，可以传入任何类型的数据，但是为了规范，我们需要指明数据的类型ArrayList< String>，这样ArrayList就只能存入String类型的数据了 我们可以
java 泛型学习记录
weixin_43157199的博客
10-08 300
意义： 由外部指定具体的操作类型，保证数据的安全性。 class A { private i; public fun( value) } 格式参照如下： 在实例化对象时，不指定泛型的类型，则会将所有的泛型标识符替换成object类型。 通配符 ？ 使用通配符可以接受任意的泛型对象，但是只能接收和使用，不能修改对象的内容。 受限泛型 通过设置上线来限制能够传递的引用只能是上限和上限的子类 ...
泛型通配符“?“的使用详解
最新发布
m0_72397750的博客
08-16 603
Java在使用泛型时，C 与 C 是并列的两个类，没有子父类关系，也就不能相互赋值。如 ArrayList 与 ArrayList 没有关系，这使得在给方法传参时，通用性很差。使用通配符C能使得代码的兼容性更好。但是通配符？在读取和写入数据及有限制条件的情况下的使用有特别的规定，本文主要讲解了这方面的内容。
29-API-集合框架-泛型-使用_java_
09-29
2. **通配符** - `?` 通配符：表示任何类型，但通常限制了方法的某些操作，例如只能读取集合元素，不能添加。 - 上界通配符：如`<? extends Number>`，限制了传入的类型必须是Number或其子类。 - 下界通配符：如`...
全面总结Java泛型--实例
01-09
`是一个通配符，表示`Info`可以是任意类型的实例。这种方法增加了方法的灵活性，使其能够处理不同类型的`Info`对象。 #### 示例四：带有限制的泛型方法 ```java public static void fun(Info<? extends Number> ...
java高级--泛型--注解
qq_55682798的博客
07-14 519
例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。 如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。 3. 如何使用泛型? 4. 通配符 5. 受限泛型 6. 泛型接口 如何实现泛型接口: 7. 泛型方法 9. java高级--注解 9.1 预定义注解---了解 预定义注解就是JDK自带的一些注解，该注解被JVM而解析。 9.3 元注解 10.自定义注解---高级...
java基础-泛型通配符
03-12
java基础-泛型通配符
java泛型笔记2--上界通配符
weixin_43712228的博客
04-15 574
在前面我们了解到上下界通配符可以让容器类之间存在诸如对象之间的继承关系.本次将详细解释这一点. 擦除特性 当我们声明两个List类型,同时声明其元素泛型为两个不同的包装类时,java并不能分辨它们.换句话说,如果仅仅是两个泛型不同的同类型集合对象,它们的类型其实是一样的.不仅仅是包装类是如此,任何类型的对象都是如此. public class GenericTest3 { public static void main(String[] args) { Class c1 = new
JAVA泛型
code609的博客
03-09 158
链接：http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html Java中的泛型方法        泛型是什么意思在这就不多说了，而Java中泛型类的定义也比较简单，例如：public class Test{}。这样就定义了一个泛型类Test，在实例化该类时，必须指明泛型T的具体类型，例如：Test
第六章 集合类 题库
qq_74940664的博客
05-29 4386
解析：HashSet存储的元素是不可重复的，添加元素时，需要先后调用hashCode()方法和equals()方法比较元素是否相同，但是如果没有重写，程序就会根据Object类中的hashCode()和equals()方式比较，而根据它的比较方式，两个Tom:10是不相等的。如果想要存入顺序和迭代的顺序一致可以使用使用Java中提供的LinkedHashMap类，它是HashMap的子类，和LinkedList一样也使用双向链表来维护内部元素的关系，使Map元素迭代的顺序与存入的顺序一致。
Java 泛型中的通配符详解
swadian2008的博客
01-09 7155
可以使用上界通配符来放宽对变量的限制。例如，你想编写一个方法，该方法适用于List， List 和 List；就可以通过使用上界通配符来实现这一点。声明一个上界通配符，需要使用通配符 ('?')，跟上 extends 关键字，然后再跟它的上界。比如，编写用于 Number 列表和 Number 子类型（如 Integer、Double 和 Float）的方法，可以指定 List
【JAVA】-- 期末考试试题含答案（选择、判断、填空、简答）（二）
张修宇的博客
06-13 1614
单选题（共计27分）A、封装将变化隔离B、封装提高重用性C、封装提高安全性D、只有被private修饰才叫做封装public class Test{static int i;public int aMethod( ){i++;return i;}public static void main(String [] args){Test test = new Test( );test.aMethod( );System.out.println(test.aMethod( ));}}程序编译运行后，输出结果是（）
Java泛型程序设计之定义简单泛型类、泛型方法、以及类型变量的限定
热门推荐
贝贝的博客
05-17 1万+
1
java泛型程序示例详解
weixin_30585437的博客
09-21 169
普通泛型 1 class Point<T>{ // 此处可以随便写标识符号，T是type的简称 2 private T var ; // var的类型由T指定，即：由外部指定 3 public T getVar(){ // 返回值的类型由外部决定 4 return var ; 5 } 6 ...
第八章 泛型程序设计
weixin_30245867的博客
07-16 131
1.带有【超类型限定 super】的通配符可以向泛型对象写入，带有【子类型限定 extends】的通配符可以从泛型对象读取，反之则不然。 转载于:https://www.cnblogs.com/baokang/p/7441122.html...
java泛型程序设计——通配符类型+通配符的超类型限定
PacosonSWJTU的博客
12-08 3595
【0】README0.1） 本文描述+源代码均 转自 core java volume 1， 旨在理解 java泛型程序设计 的 通配符类型+通配符的超类型限定 的知识；【1】通配符类型相关1.1）通配符类型： Pair < ? extends Employee> 表示任何泛型Pair 类型， 它的类型参数是 Employee的子类 ， 如 Pair ， 但不是 Pair 1.2）问题+解决方法：
泛型机制在Apla-Java系统中的实现与效率提升研究
3. 泛型通配符：使用`?`通配符可以表示任意类型，这在处理不确定类型的参数或返回值时非常有用。 4. 类型推断：编译器能够根据上下文自动推断类型参数，简化代码编写，例如在Java 7及更高版本中的钻石操作符`<>`。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值