泛型(泛型入门、通配符、泛型的其它应用)

最新推荐文章于 2022-04-15 23:03:12 发布
最新推荐文章于 2022-04-15 23:03:12 发布
阅读量1.8k 收藏 6
点赞数
分类专栏： j2se 文章标签： string class fun interface integer object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cz1029648683/article/details/6659381
版权
 

泛型

泛型可以解决数据类型的安全性问题，它主要的原理是：是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这样在声明类或实例化的时候只要指定好需要的类型即可。

泛型的定义格式：

[访问权限] class 类名称<泛型类型1,泛型类型2,….,泛型类型3>{
      [访问权限] 泛型类型标识 变量名称;
      [访问权限] 泛型类型标识 方法名称(){};
      [访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称){};
}

泛型对象定义：

类名称<具体类> 对象名称 =new 类名称<具体类>();

简单泛型代码如下： 

class Point<T>{	//设置泛型
	private T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
}
public class gennericDemo01
{
	public static void main(String args[]){
		Point<String> p=new Point<String>();	//实例化泛型对象
		p.setVar("今天过的很好");	//设置值
		System.out.println(p.getVar());
	}
}

泛型中的构造方法

构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定,而又希望通过构造设置属性内容的时候，那么构造方法中的定义与之前并无不同，不需要像声明类那样指定泛型。其格式如下：

[访问权限] 构造方法(<泛型类型> 参数名称){};

代码示例：

class Point<T>{	//设置泛型
	private T var;	//定义泛型变量
	public Point(T var){
		this.var=var;
	}
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
}
public class gennericDemo02
{
	public static void main(String args[]){
		Point<String> p=new Point<String>("今天你好么");	//通过构造方法指定泛型类型并且初始化属性值
		System.out.println(p.getVar());
	}
}

设置多个泛型

在泛型中也可以指定多个泛型的类型：

class Notepad<K,V>	//为泛型指定两个类型 类型自定义
{
	private K key;
	private V value;
	public K getKey(){
		return this.key;
	}
	public V getValue(){
		return this.value;
	}
	public Notepad(K key,V value){	//通过构造方法为两个类型的属性初始化
		this.key=key;
		this.value=value;
	}
}
public class gennericDemo03
{
	public static void main(String args[]){
		Notepad<Integer,String> notepad=new Notepad<Integer,String>(30,"魔乐");	//实例化对象
		System.out.println(notepad.getKey());
		System.out.println(notepad.getValue());
	}
}

通配符

匹配任意类型的通配符

观察一下的代码：

class Info<T>{	//设置泛型
	private T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
}
public class gennericDemo04
{
	public static void main(String args[]){
		Info<String> info=new Info<String>();	//指定String为泛型类型
		info.setVar("MLDN");
		fun(info);	//错误，无法传递
	}
	public static void fun(Info<Object> temp){	//可以接收
		System.out.println("编译通过了");
	}
}

注意：泛型对象进行引用传递的时候，泛型类型必须是一致的。

如果现在非要进行传递，则可以将方法中Info参数的类型取消掉，但是取消掉毕竟不是最好的处理方式，毕竟之前已经指定了泛型了。那么可以采用使用？的形式。

class Info<T>{	//设置泛型
	private T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
}
public class gennericDemo05
{
	public static void main(String args[]){
		Info<String> info=new Info<String>();	//指定String为泛型类型
		info.setVar("MLDN");
		fun(info);	//错误，无法传递
		System.out.println(info.getVar());
	}
	public static void fun(Info<?> temp){	//可以接收
		System.out.println("编译通过了");
	}
}

如果使用的是？ 意味着可以接收任意的内容，但是？并不代表着具体的类型，所以此内容却无法直接使用<?>修饰的泛型对象进行修改。代码解释如下：

class Info<T>{	//设置泛型
	private T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
}
public class gennericDemo06
{
	public static void main(String args[]){
		Info<?> info=new Info<String>();	//指定String为泛型类型
		info.setVar("MLDN");	//错误 无法将Info<?>类型应用于Info<String>
		System.out.println(info.getVar());
	}
}

注意：在使用<?>只能够接收，但是不能修改

受限泛型

在引用传递中，泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是有所指定的类型，或者是此类型的子类，而范围下限使用super关键字进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类。

设置上限：

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

定义类：[访问权限] 类名称<泛型标识 extends 类>{};

设置下限：

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

定义类：[访问权限] 类名称<泛型标识 extends 类>{};

设置上限

class Info<T>{	//设置泛型
	public T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
	public String toString(){	//覆写toString方法，方便打印对象
		return this.var.toString();
	}
}
public class gennericDemo07
{
	public static void main(String args[]){
		Info<Integer> i1=new Info<Integer>();	//指定Integer为泛型类型
		Info<Float> i2=new Info<Float>();	//指定Float为泛型类型
		i1.setVar(10);
		i2.setVar(10.3f);
		fun(i1);
		fun(i2);
	}
	//接收Info对象，返回上限设置为Number,所以只能接收数字类型
	public static void fun(Info<? extends Number> temp){	
		System.out.println(temp+"、");	
		
	}
}

上限设置在类中的应用：

class Info<T extends Number>{	//设置泛型并设置上限 最高为Number
	public T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
	public String toString(){	//覆写toString方法，方便打印对象
		return this.var.toString();
	}
}
public class gennericDemo08
{
	public static void main(String args[]){
		Info<Integer> i1=new Info<Integer>();	//指定Integer为泛型类型
		Info<Float> i2=new Info<Float>();	//指定Float为泛型类型
		Info<String> i3=new Info<String>();	//会出现类型参数 java.lang.String 不在其限制范围之内的错误
		i1.setVar(10);
		i2.setVar(10.3f);
		System.out.println(i1.getVar());
		System.out.println(i2.getVar());
	}
}

设置下限

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

class Info<T>{	//设置泛型并设置上限 最高为Number
	public T var;	//定义泛型变量
	public void setVar(T var){	
		this.var=var;
	}
	public T getVar(){
		return var;
	}
	public String toString(){	//覆写toString方法，方便打印对象
		return this.var.toString();
	}
}
public class gennericDemo09
{
	public static void main(String args[]){
		Info<String> i1=new Info<String>();		//声明String的泛型对象
		Info<Object> i2=new Info<Object>();		//声明Object的泛型对象
		i1.setVar("MLDN");
		i2.setVar(new Object());
		fun(i1);
		fun(i2);
	}
	public static void fun(Info<? super String> temp){	//只能接收String或Object类型的泛型
		System.out.println(temp);
	}
}

注意：一个类的子类可以通过对象多态性，为其父类进行实例化，但是在泛型操作中，子类的泛型类型是无法使用父类的泛型类型接收的，例如：Info<Stirng>不能使用Info<Object>接收，只能是类型完全一致或者是采用Info<?>的格式进行接收，但是也要注意，使用Info<?>的形式是不能为对象设置值的，只能用来接收。

泛型的其它应用

泛型接口基本概念

在JDK1.5之后，不仅仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法相似，也是在接口名称后面加上<T>，如以下的格式：

[访问权限] interface 接口名称<泛型标识>{};
interface Info<T>    //在接口上定义泛型
  private T var;
  public T getVar
}

如以下的代码：

interface Info<T>
{
	public T getVar();
}
class InfoImpl<T> implements Info<T>
{
	public T getVar(){
		return null;
	}
}

泛型接口实现的两种方式

定义子类：在子类的定义上也声明泛型类型。

interface Info<T>	//在接口上定义泛型
{
	public T getVar();	//定义抽象方法，抽象方法的返回值类型就是泛型类型
}
class InfoImpl<T> implements Info<T>	//定义泛型接口的子类
{
	private T var;	//定义属性
	public InfoImpl(T var){		//通过构造方法设置属性内容
		this.var=var;
	}
	public void setVar(T var){
		this.var=var;
	}
	public T getVar(){
		return this.var;
	}
}
public class gennericDemo02
{
	public static void main(String args[]){
		Info<String> info=null;		//声明接口对象
		info=new InfoImpl<String>("MLDN");	//通过子类实例化对象
		System.out.println(info.getVar());
	}
}

如果现在实现接口的子类不想使用泛型类型声明，则在实现接口的时候可以指定好具体的泛型类型。

interface Info<T>	//在接口上定义泛型
{
	public T getVar();	//定义抽象方法，抽象方法的返回值类型就是泛型类型
}
class InfoImpl implements Info<String>	//定义直接使用String类型的泛型类型
{
	private String var;	//定义属性
	public InfoImpl(String var){		//通过构造方法设置属性内容
		this.var=var;
	}
	public void setVar(String var){
		this.var=var;
	}
	public String getVar(){
		return this.var;
	}
}
public class gennericDemo03
{
	public static void main(String args[]){
		Info<String> info=null;		//声明接口对象
		info=new InfoImpl("MLDN");	//通过子类实例化对象
		System.out.println(info.getVar());
	}
}

定义泛型方法

泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型，使用如下的格式定义泛型方法：

[访问权限] <泛型标识> 泛型标识 方法名称(泛型标识 参数名称)

如以下的代码：

class Demo{
	public <T> T fun(T t){	//可以接收任意类型的参数
		return t;	//直接把参数值返回
	}
}
public class gennericDemo04
{
	public static void main(String args[]){
		Demo demo=new Demo();	//示例化Demo类
		String str=demo.fun("你好");	//传递字符串
		int i=demo.fun(12);	//传递整型
		System.out.println(str);	
		System.out.println(i);
	}
}

通过泛型方法返回泛型类的实例

代码如下：

class Info<T extends Number>{	//指定上限，只能是数字类型
	private T var;	//此类型由外部决定
	public T getVar(){
		return var;
	}
	public void setVar(T var){
		this.var=var;
	}
	public String toString(){	//覆写toString方法，方便打印对象
		return this.var.toString();
	}
}
public class gennericDemo05
{
	public static void main(String args[]){
		Info<Integer> info=fun(30);
		System.out.println(info.getVar());
	}
    public static <T extends Number> Info<T> fun(T temp){
		Info<T> info=new Info<T>();	//根据传入的数据类型实例化Info
		info.setVar(temp);	//将传递的内容设置到Info对象的var属性之中
		return info;	//返回实例化对象
	}
}

泛型数组

使用泛型方法的时候，也可以传递或返回一个泛型数组。

public class gennericDemo06
{
	public static void main(String args[]){
		Integer i[]=fun1(1,2,3,4);	//返回泛型数组
		fun2(i);
	}
    public static <T> T[] fun1(T...arg){	//接收可变参数
		return arg;		//返回泛型数组
	}	
	public static <T> void fun2(T param[]){		//输出泛型数组
		System.out.println("泛型数组：");
		for(T t:param){	
			System.out.print(t+"、");
		}
	}
}
cz1029648683
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习笔记 --- 自定义泛型
乌云的博客
11-11 723
自定义泛型
泛型标记符-备忘录
haowu8888的博客
12-26 262
跳转到总目录 文章目录泛型标记符具体代码1.Order类2.SubOrder类3.GenericTest类 泛型标记符 定义了泛型不使用,默认为Object. 标记符 extends(限制上限)/super(限制下限) Xxx类 E-Element: 在集合中使用,因为集合中存放元素. T-Type: Java类. K-key: 键, V-value 值, N-Nunber: 数值类型. R-return: 返回值 ?-表示不确定的Java类型(通配符)是标记符的父类. public static &l
泛型标记有哪些，怎么选择使用
绅士jiejie的博客
01-29 320
经常看到源码里有使用泛型，有时用T标记，有时用E标记等等，为什么要这样用不同的字母标记泛型呢，这是因为每个字母标记都有不同的含义。 泛型标记 说明 E-Element 在集合里使用，表示在集合中存放的元素 T-Type 表示Java类 K-Key 表示键 V-Value 表示值 N-Number 表示数值类型 ？ 表示不确定的Java类型 ...
泛型属性遍历
xbfengyu的专栏
12-01 1065
转载：https://www.cnblogs.com/sword85/p/4490975.html /// &lt;summary&gt; /// 去除model属性为null 的情况，把null改成""。。该方法仅用在属性均为string类型的情况，主要用于手机APP。 chj 2015-5-7 17:39:21 /// &lt;/summary&gt; /// &lt;typepara...
java 泛型属性_Java泛型
weixin_42681774的博客
02-16 2561
一、定义泛型可以用来指代任意对象类型。二、泛型和多态1.引入多态定义一个C1类：里面有个Integer属性，给出它的构造方法、打印其类型和get\set方法。1 packagecom.swu.generics;23 public classC1 {4 privateInteger a;56 publicC1(Integer a) {7 super();8 ...
Java泛型之上界下界通配符详解
08-25
上界和下界通配符是Java泛型中的关键概念，它们帮助我们在处理不同类型的集合和参数时保持灵活性和类型约束。 **上界通配符 (Upper Bounded Wildcard)** 上界通配符表示一个类型参数的最大限制，通常用"? extends...
详谈Java泛型中T和问号(通配符)的区别
08-28
此外，Java泛型还有其他重要的概念，如有界类型、通配符类型等。有界类型是指使用extends语句来限制泛型类型参数的范围，例如public class Gen<T extends Number> { … }。通配符类型是指使用问号(通配符)来表示未知...
java泛型常用通配符实例解析
08-25
java泛型常用通配符实例解析 Java泛型是Java 5中引入的一项新特性，可以用来编写泛型代码，使得代码更加灵活和可重用。其中，通配符是泛型中的一种重要概念，本文将详细介绍Java泛型常用通配符实例解析。 1. 限定...
Java 泛型总结（三）：通配符的使用
08-31
Java 泛型总结（三）：通配符的使用 通配符是 Java 泛型中一个重要的概念，它允许我们在泛型中实现向上转型，解决了泛型不支持协变的问题。本文将详细介绍通配符的使用和原理。 在 Java 中，数组是协变的，这意味...
Java中泛型通配符的使用方法示例
08-25
Java中泛型通配符的使用方法示例 Java 中泛型通配符的使用方法示例主要介绍了 Java 中泛型通配符的使用方法，结合实例形式分析了 Java 中泛型通配符的功能、语法及在泛型类创建泛型对象中的使用方法。以下是 Java ...
java 泛型属性_Java-泛型
weixin_42514890的博客
02-16 2666
一、泛型的概念●所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如，继承或实现这个接口，用这个类型声明变量、创建对象时)确定(即传入实际的类型参数，也称为类型实参)。●从JDK1.5以后，Java引入 了“参数化类型( Parameterized type) ”的概念，允许我们在创建集合时再指定集合元素的类型，正如: ...
JAVA中泛型标记
wang_chaochen的博客
12-13 273
Java泛型中的标记符含义： 使用泛型可以避免Object接收参数所带来的ClassCastException问题。 - Element (在集合中使用，因为集合中存放的是元素) - Type（Java 类） - Key（键） - Value（值） - Number（数值类型） <?> - 表示不确定的java类型，可以用来接收数据 一般使用来声明类型持有者名称，自定义泛...
java泛型属性_java 泛型详解
weixin_36070797的博客
02-12 515
1.定义泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式(可以称之为类型形参)，然后在使用/调用时传入具体的类型(类型实参)。泛型的本质是为了参数化类型(在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型)。也就是...
Java泛型
Adeluoo的博客
02-11 524
一、什么是泛型 1.背景： JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道存储每个元素的数据类型，否则很容易引发ClassCastException异常。 2.概念： Java泛型（generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。 3.好处： 类型安全 消除了强制
泛型详解及使用及通配符(一)
qq_23095607的博客
04-15 685
参考资料 参考视频https://www.bilibili.com/video/BV1xJ411n77R?p=6&spm_id_from=pageDriver 视频涉及资料 个人总结demo 参考文章1https://www.cnblogs.com/coprince/p/8603492.html 参考文章2https://blog.csdn.net/Beyondczn/article/details/107093693 一、泛型类 首先泛型类的基本语法 public class 类名.
Java泛型详解
小小默：进无止境
09-10 877
【1】概述在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型就可以在细分成更多的类型。例如原先的类型List，现在在细分成List&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;Object&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;, List&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;String&am
Java中泛型的标记符的含义
青色橙子
07-06 1432
Java中泛型的标记符的含义：E-Element（在集合中使用，因为集合中存放的是元素）T-Type（Java类）K-Key（键）N-Number（数值类型）V-Value(值)？-表示不确定的java类型...
泛型
superfloat的博客
01-09 235
泛型:是一种把类型明确的工作推迟到创建对象，或者调用方法的时候才去明确的特殊的类型。 好处：(1): 把运行时期的问题提前到了编译期间            (2): 避免了强制类型转换           (3):优化了程序设计，解决了黄色警告线           注意：泛型只在编译期有效  但在运行期就擦除了。 把泛型定义在类上： 定义格式：public class 类名 &lt;泛型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值