Java中的包装类和泛型详解

最新推荐文章于 2024-08-03 10:04:07 发布
最新推荐文章于 2024-08-03 10:04:07 发布
阅读量617 收藏
点赞数
分类专栏： Java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43185543/article/details/100990109
版权

1.包装类
1.1为什么要引入包装类？
Java中包含的8种基本数据类型不支持面向对象的编程机制。通过包装类可以将基本数据类型的值包装为引用数据类型的对象。
特殊：char对应的包装类为：Character；int对应的包装类为：Integer。
其它的基本数据类型所对应的包装类的名称与其基本数据类型一样，只不过首字母需要大写。
1.2基本概念
包装类和基本数据类型在进行转换时，引入了自动装箱和自动拆箱的概念。其中自动装箱是指将基本数据类型赋给对应的包装类变量；反之，拆箱就是将包装类对象类型直接赋给一个对应的基本数据类型变量。

public class Demo {
	public static void main(String[] args) {
		// 定义一个基本类型的变量a，并赋值为20
		int a = 20;
		// 自动装箱：将基本数据类型的变量a赋给Integer类型的变量b
		Integer b = a;
		System.out.println(b);
		// 自动拆箱：将Integer类型的变量b赋给基本类型的变量a
		int c = b;
		System.out.println(c);
	}
}

1.3实现基本数据类型、包装类以及字符串之间的相互转换。
1>通过引用数据类型字符串String类的valueOf()方法可以将8种基本数据类型转换为对应的字符串类型。
2>通过8种包装类的静态方法valueOf()既可以将对应的基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类(Character包装类除外)。
3>通过8种包装类的有参构造方法同样既可以将对应的基本数据类型转换为包装类，也可以将
变量内容匹配的字符串转换为对应的包装类(Character包装类除外)。
4>通过8种包装类的静态方法parseXxx()可以将变量内容匹配的字符串转换为对应的基本数据类型。
5>包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。

public class Demo {
	public static void main(String[] args) {
		int num = 123;
		// 1.通过String.valueOf()方法将基本类型转换为字符串
		String string = String.valueOf(num);
		System.out.println("将int变量转换为字符串的结果：" + string);
		// 2.通过包装类的将基本类型和字符串转换为包装类
		String str = "998";
		Integer integer = Integer.valueOf(num);
		Integer integer2 = Integer.valueOf(str);
		System.out.println("将int变量转换为包装类的结果：" + integer);
		System.out.println("将字符串变量转换为包装类的结果：" + integer2);
		// 3.通过包装类的有参构造方法将基本类型和字符串转换为包装类
		Integer integer3 = new Integer(num);
		Integer integer4 = new Integer(str);
		System.out.println("通过构造器将int变量转换为包装类的结果：" + integer3);
		System.out.println("通过构造器将字符串变量转换为包装类的结果：" + integer4);
		// 4.通过包装类的parseXxx()静态方法将字符串转换为基本类型
		int parseInt = Integer.parseInt(str);
		System.out.println("将字符串转换为基本类型的结果：" + parseInt);
		// 5.通过包装类的toString()方法将包装类转换为字符串
		String string2 = integer.toString();
		System.out.println("将包装类转换为字符串的结果：" + string2);
	}
}

运行结果：
在这里插入图片描述
注意：
1>除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。

Integer integer = Integer.valueOf("123");//合法
Integer integer = Integer.valueOf("12a");//不合法

2>除了Character外，包装类都有parseXxx(String s)的静态方法，将字符串转换为对应的基本类型的数据。参数s不能为null，而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。

int integer=Integer.parseInt("123");//合法
Integer in=Integer.parseInt("itcast");//不合法

2.泛型
集合可以存储任意类型的对象元素，但是当把一个对象存入集合后，集合会“忘记”这个对象的类型，将该对象从集合中取出时，这个对象的编译类型就统一变成了Object类型。换句话说，在程序中无法确定一个集合中的元素到底是什么类型，那么在取出元素时，如果进行强制类型转换就很容易出错，而且操作麻烦。
引入泛型后限定了集合元素的数据类型，使得限定的数据类型程序在编译期间就会出现报错提示，避免程序在运行期间发生错误。
泛型只能接受类，所有的基本数据类型必须使用包装类。
2.1泛型定义类
示例1：泛型类引入多个类型参数以及使用

class MyClass<T,E>{
	T value1;
	E value2;
}
public class Demo {
	public static void main(String[] args) {
		MyClass<String,Integer> myclass=new MyClass<String,Integer>();
	}
}

示例2：使用泛型定义Point类

//T表示参数，是一个占位的标记；如果有多个泛型就继续在后面追加
class Point<T> {
	private T x;
	private T y;

	public void setX(T x) {
		this.x = x;
	}

	public T getX() {
		return x;
	}

	public void setY(T y) {
		this.y = y;
	}

	public T getY() {
		return y;
	}
}

public class Demo {
	public static void main(String[] args) {
		// 设置数据
		Point<String> point = new Point<>();
		point.setX("东经80度");
		point.setY("北纬20度");
		// 取出数据
		String x = point.getX();// 避免了向下转型
		String y = point.getY();
		System.out.println("x=" + x + ",y=" + y);
	}
}

运行结果：
在这里插入图片描述
2.2泛型方法
示例1：泛型方法定义

class MyClass{
	public <T> void testMethod(T t) {
		System.out.println(t);
	}
}

示例2：使用类型参数做返回值的泛型方法

class MyClass{
	public <T> T testMethod(T t) {
		return t;
	}
}

示例3：泛型方法与泛型类共存

class MyClass<T>{
	public void testMethod1(T t) {
		System.out.println(t);
	}
	public <T> T testMethod2(T t) {
		return t;
	}
}

public class Demo {
	public static void main(String[] args) {
		MyClass<String> myclass=new MyClass<>();
		myclass.testMethod1("hello,泛型类");
		Integer i=myclass.testMethod2(100);
		System.out.println(i);
	}
}

运行结果：
在这里插入图片描述
解释：上述代码中，MyClass是泛型类，testMethod1是泛型类中的普通方法，而testMethod2是一个泛型方法。而泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的，泛型方法始终以自己定义的类型参数为准。
泛型类的实际类型参数是String，而传递给泛型方法的类型参数是Integer，两者互不相干。
但是，为了避免混淆，如果在泛型类中存在泛型方法，那么两者的类型参数最好不要同名。比如，MyClass代码可以更改为这样：

class MyClass<T>{
	public void testMethod1(T t) {
		System.out.println(t);
	}
	public <E> E testMethod2(E e) {
		return e;
	}
}

2.3通配符
在程序类中追加了泛型的定义后，避免了ClassCastException的问题，但是又会产生新的情况：参数的统一问题。
示例1：导入

class Message<T> {
	private T message;

	public void setMessage(T message) {
		this.message = message;
	}

	public T getMessage() {
		return message;
	}
}

public class Demo {
	public static void main(String[] args) {
		Message<String> message = new Message();
		message.setMessage("hello");//如果泛型里面的类型设置不是String，而是Integer
		fun(message);				//这里会出现错误，只能接收String
	}

	public static void fun(Message<String> temp) {
		System.out.println(temp.getMessage());
	}
}

运行结果：
在这里插入图片描述
针对上面的问题，可以有如下的解决方案：可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符“？”来处理。
示例2：使用通配符

public class Demo {
	public static void main(String[] args) {
		Message<String> message = new Message();
		message.setMessage(88);
		fun(message);				
	}

	public static void fun(Message<？> temp) {
		//temp.setMessage(100);//无法修改
		System.out.println(temp.getMessage());
	}

这样的话，在“？”的基础上又产生了两个子通配符：
？extend类：设置泛型上限：
例如：？extends Number，表示只能够设置Number或其子类，例如：Integer、Double。
？super类：设置泛型下限：
例如，？super String，表示只能够设置String及其父类Object。
示例3：设置泛型上限

class Message<T extends Number> {// 设置泛型上限
	private T message;

	public void setMessage(T message) {
		this.message = message;
	}

	public T getMessage() {
		return message;
	}
}

public class Demo {
	public static void main(String[] args) {
		Message<Integer> message = new Message();
		message.setMessage(55);
		fun(message);
	}

	// 此时使用通配符"？"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
	public static void fun(Message<? extends Number> temp) {
		// temp.setMessage(100);//仍然无法修改
		System.out.println(temp.getMessage());
	}
}

运行结果：
在这里插入图片描述
示例4：设置泛型下限

class Message<T extends Number> {// 设置泛型上限
	private T message;

	public void setMessage(T message) {
		this.message = message;
	}

	public T getMessage() {
		return message;
	}
}

public class Demo {
	public static void main(String[] args) {
		Message<Integer> message = new Message();
		message.setMessage(55);
		fun(message);
	}

	// 此时使用通配符"？"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
	public static void fun(Message<? super Integer> temp) {
	    temp.setMessage(100);//此时可以修改
		System.out.println(temp.getMessage());
	}
}

运行结果：
在这里插入图片描述
总结：上限可以用在声明，不能修改；而下限只能用在方法参数，可以修改内容。
2.4泛型接口
泛型除了可以定义在类中，也可以定义在接口里面，这种情况我们称之为泛型接口。
示例1：定义一个泛型接口

interface TMessage<T>{//在接口上定义了泛型
	public void print(T t);
}

示例2：在子类定义时继续使用泛型

interface IMessage<T> {// 在接口上定义了泛型
	public void print(T t);
}

class MessageImp1<T> implements IMessage<T> {
	public void print(T t) {
		System.out.println(t);
	}
}

public class Demo {
	public static void main(String[] args) {
		IMessage<Integer> message = new MessageImp1();
		message.print(88);
	}
}

运行结果：
在这里插入图片描述
示例3：在子类实现接口的时候明确给出具体类型

interface IMessage<T> {// 在接口上定义了泛型
	public void print(T t);
}

class MessageImp1 implements IMessage<Integer> {
	public void print(Integer t) {
		System.out.println(t);
	}
}

public class Demo {
	public static void main(String[] args) {
		IMessage<Integer> message = new MessageImp1();
		message.print(88);
	}
}

运行结果：
在这里插入图片描述
2.5类型擦除
泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。
通俗地讲，泛型类和普通类在Java虚拟机内是没有什么特别的地方。
示例1：

class MyClass<T> {
	private T message;

	public void setMessage(T message) {
		this.message = message;
	}

	public T getMessage() {
		return message;
	}
}

public class Demo {
	public static void main(String[] args) {
		MyClass<String> myClass1 = new MyClass<>();
		MyClass<Integer> myClass2 = new MyClass<>();
		System.out.println(myClass1.getClass() == myClass2.getClass());
	}
}

运行结果：
在这里插入图片描述
解释：打印结果为true是因为MyClass和MyClass在JVM中的Class都是myClass.class。
实例2:观察类型擦除

import java.lang.reflect.Field;

class MyClass<T, E> {
	private T message;
	private E text;

	public void setMessage(T message) {
		this.message = message;
	}

	public T getMessage() {
		return message;
	}

	public void setText(E text) {
		this.text = text;
	}

	public E getText() {
		return text;
	}
}

public class Demo {
	public static void main(String[] args) {
		MyClass<String, Integer> myClass1 = new MyClass<>();
		Class cls = myClass1.getClass();
		Field[] fields = cls.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field.getType());
		}
	}
}

运行结果：
在这里插入图片描述
**添加：**在泛型类被类型擦除的时候，之前的泛型类中的类型参数部分如果没有指定上限，如则会被转译成普通的Object类型，如果指定了上限如，则参数类型就会被替换成类型上限。

hi168
关注
专栏目录
Java 泛型实例详解
09-01
此外，Java泛型与自动封装（Autoboxing）和自动拆箱（Autounboxing）相结合，使得基本类型和对应的包装类之间可以无缝切换。例如，在`List<Integer>`中，可以直接添加整数值： ```java List<Integer> ints = new ...
2024内部类，泛型枚举包装类
04-02
### 2024年内部类与泛型枚举包装类详解 #### 一、内部类概述 **内部类**是Java中一种特殊类的定义方式，它允许在一个类的内部定义另一个类。这种特性增加了类的设计灵活性，使得类与类之间能够更好地封装和组织。 ...
Java包装类与泛型
a18792721831的博客
04-03 684
Java包装类与泛型1.什么是包装类2.为什么需要包装类 1.什么是包装类 首先应该知道Java有基本类型与非基本类型 基本类型包含四类八种： 整型： int long short byte 浮点型： double float 布尔型： boolean 字符型： char 基本类型在Java语言中的地位很高，是关键字差不多一级的。 每一个基本类型都有自己的包装类： Integer Long Sho...
包装类、泛型
qq_48080082的博客
03-26 126
包装类 Java中基本数据类型是不面对对象的，剧本类型没有对象这个特性，但是每种数据类型都有对应的类，就是包装类，他们是可以有对象的。------基本就是基本数据类型的名称的全拼且首字母大写，eg;int–Integer,char–Character 包装类都是final类型，没有子类，且不可变 装箱和拆箱 装箱：就是把基本数据类型变成包装类对象 拆箱
包装类与泛型
最新发布
m0_73107796的博客
08-03 1228
理解并掌握包装类与泛型的使用
Java中泛型和包装类
weixin_44915811的博客
02-04 438
目录 1. 泛型 1.1 泛型类的引用 1.2 泛型的定义 1.3 泛型背后作用时期和背后的简单原理 1.4 泛型类的使用 1.5 泛型的陷阱 1.6 泛型的意义 2. 包装类 2.1 基本数据类型和包装类直接的对应关系 2.2 包装类的使用，装箱(boxing)和拆箱(unboxing) 1. 泛型 1.1 泛型类的引用 问题：简单的顺序便只能够存放 int 数据，如果...
包装类&认识泛型
weixin_70564024的博客
02-14 529
方法限定符返回类型 方法名称 (形参列表){...
包装类和泛型
m0_61608447的博客
05-12 238
包装类和泛型的基础讲解和认识
Java 泛型有哪些好处详解
08-31
- **类型参数只能是类类型**：你不能使用基本类型如`int`、`double`作为泛型的类型参数，但可以使用它们的包装类，如`Integer`、`Double`。 - **泛型的多态性**：同一种泛型可以有多个版本，每个版本对应不同的类型...
Java包装类详解.pptx.pptx
12-19
Java包装类是Java语言设计中的一个重要特性，它们是为了解决基本数据类型（如int、char、boolean等）无法直接参与面向对象编程的问题而引入的。包装类将基本数据类型转换为对象，使得我们可以在需要对象操作的场景下...
java泛型类和函数
03-17
### Java泛型类和函数详解 #### 泛型概述 在Java中，泛型是一种允许开发者在类、接口和方法中使用类型参数的功能。通过使用泛型，可以在编写代码时指定一个或多个类型参数，从而使得编写的代码更加灵活且重用性更高...
Java基础之浅话泛型与包装类
m0_63372226的博客
10-05 601
相较之前每改变一个数组元素类型，就得重新定一个交换方法来说，使用泛型方法可以编写一个交换方法，实现各种元素类型的交换，类似于。一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。为自定义的泛型数组类，可以根据需要往数组填入整型（Integer）、浮点型(Float)、字符串型(String)等各种引用类型。在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。2.泛型Object[]，Object是所有类（包含接口）的祖先类，上层引用可以指向下层类型。
Java 之 泛型 与 包装类
qq_45605759的博客
11-12 206
Java 之 泛型 与 包装类 泛型 泛型是作用在编译期间的一种机制，即运行期间没有泛型的概念。 定义泛型类时，"<>"内一般给 T 或者 E 泛型代码示例： class MyArrayList{ public Object[] elem; public int useSize; public MyArrayList() { this.elem...
【JAVA数据结构】JAVA数据结构必备知识：泛型与包装类
爱打酱油的新一的博客
09-15 685
JAVA数据结构预备知识💕
简单介绍java的泛型和包装类
RwTo的博客
07-25 178
泛型 泛型概述 泛型：可以在类或方法中预支地使用未知的类型。 tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。 使用泛型的好处 上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？ 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。 避免了类型强转的麻烦。 通过我们如下代码体验一下： public class GenericDemo2 { public static void main(String[] a
java 泛型和包装类的使用
丸啊~
12-04 460
一、泛型 1.泛型的引入 我们知道一个顺序表中可以存放int型的对象，那么如果要存入指向 Person 类型对象的引用的顺序表，请问应该如何解决？ 首先我们可以想到基类的引用可以指向子类的对象，因为Object是所有类的祖先类，所以我们将顺序表的元素类型定义成 Object 类型，这样我们的 Object 类型的引用可以指向 Person 类型的对象 看这样一段代码： public class M...
java中泛型和包装类的简单介绍
ryy1999的博客
12-09 144
java中List接口以及泛型的简单介绍 一、泛型的简单介绍 class MyArrayList 代表当前这个类是一个泛型类，此时的这个T就是一个占位符而已 class MyArrayList <T>{ public T[] elem; public int uesdSize; public void add(T val) { this.elem[uesdSize] = val; uesdSize++; } publ
Java的泛型和包装类
Lb_CsdnJava的博客
12-07 455
Java的泛型和包装类泛型泛型的分类泛型类的使用泛型的意义包装类包装类的引入基本数据类型和包装类的对应关系包装类的使用 泛型 泛型的分类 1.泛型类. 基本语法：class 类名{ } // 尖括号 <> 是泛型的标志 // E 是类型变量(Type Variable)，变量名一般要大写 // E 在定义时是形参，代表的意思是该类最终传入的类型，但现在还不知道 2. 泛型方法 泛型类的...
Java内部类与包装类详解
在Java编程语言中，包装类（Wrapper）和内部类（Nested Class）是两个重要的概念。包装类是为了让基本数据类型（如int, char, boolean等）拥有对象的特性，Java为每一个基本数据类型提供了一个对应的包装类，比如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值