当前位置：首页 > news >正文

JAVA包装类

news 2025/5/10 7:15:53

一、基本数据类型

1.整型类型：

用于表示整数数值，不包含小数部分。

类型	位数	取值范围	默认值	示例
`byte`	8	-128 至 127	0	`byte num = 100;`
`short`	16	-32,768 至 32,767	0	`short num = 5000;`
`int`	32	-2,147,483,648 至 2,147,483,647	0	`int num = 100000;`
`long`	64	-2^63 至 2^63-1	0L	`long num = 10000000000L;`

2. 浮点类型

用于表示带小数的数值，分为单精度和双精度。

类型	位数	精度	默认值	示例
`float`	32	约 6-7 位小数	0.0F	`float pi = 3.14F;`
`double`	64	约 15 位小数	0.0	`double pi = 3.14159;`

3. 字符类型

用于表示单个 Unicode 字符，占 16 位。

类型	位数	取值范围	默认值	示例
`char`	16	0 至 65,535	`'\u0000'`	`char letter = 'A';`

4. 布尔类型

用于表示逻辑值，只有两个取值。

类型	位数	取值	默认值	示例
`boolean`	1	`true` 或 `false`	`false`	`boolean isReady = true;`

二、引用数据类型

引用数据类型（Reference Data Type）是指存储对象引用（内存地址）的类型，与基本数据类型相对。

1. 类（Class）类型

定义：使用 class 关键字创建的自定义类型，包含属性和方法。
示例：String、Integer、自定义类（如 Person、Car）。
特点：
- 所有类都继承自 Object。
- 可以实例化对象，通过 new 关键字创建。
- 支持封装、继承、多态等面向对象特性。

2. 接口（Interface）类型

定义：使用 interface 关键字声明的抽象类型，只包含方法签名（Java 8+ 支持默认方法和静态方法）。
示例：List、Runnable、Comparable。
特点：
- 不能实例化，必须由类实现（implements）。
- 支持多实现（一个类可实现多个接口）。
- 常用于定义行为规范或回调机制。

3. 数组（Array）类型

定义：存储相同类型元素的容器，长度固定。
示例：int[]、String[]、Object[]。
特点：
- 数组本身是对象，继承自 Object。
- 元素可以是基本类型或引用类型。
- 通过索引访问元素，下标从 0 开始。

三、包装类

包装类（Wrapper Class） 是 Java 为基本数据类型提供的引用类型，用于在需要对象的场景中使用基本类型。它们本质上是基本类型的对象化封装，提供了更多的功能和灵活性。

为什么需要包装类？

泛型限制：Java 泛型只接受引用类型，无法直接使用基本类型。

List<Integer> list = new ArrayList<>();  // 正确，使用包装类 Integer
// List<int> list = new ArrayList<>();  // 错误，不能使用基本类型 int

对象操作需求：基本类型不具备对象的特性（如方法调用、继承），包装类可以提供这些功能。

int num = 10;
// num.toString();  // 错误，基本类型没有方法Integer wrapperNum = 10;  // 自动装箱
String str = wrapperNum.toString();  // 正确，包装类有方法

Java 的 8 个包装类

每个基本类型对应一个包装类，均位于 java.lang 包中：

基本类型	包装类	父类
`byte`	`Byte`	`Number`
`short`	`Short`	`Number`
`int`	`Integer`	`Number`
`long`	`Long`	`Number`
`float`	`Float`	`Number`
`double`	`Double`	`Number`
`char`	`Character`	`Object`
`boolean`	`Boolean`	`Object`

自动装箱与拆箱

装箱：基本类型 → 包装类
拆箱：包装类 → 基本类型

// 自动装箱
Integer a = 10;  // 等价于 Integer a = Integer.valueOf(10);// 自动拆箱
int b = a;       // 等价于 int b = a.intValue();// 运算时的自动拆箱
int sum = a + 5;  // 等价于 a.intValue() + 5

问题：

1 对象是什么

对象（Object） 是类的实例，是程序运行时的基本实体。它将数据（属性）和操作数据的方法（行为）封装在一起

对象的本质

类的实例化：类是对象的模板，对象是类的具体实现。
数据与行为的封装：对象包含属性（状态）和方法（操作）。
内存中的实体：每个对象在堆内存中占据独立的存储空间。

对象的组成

1. 属性（Fields/Attributes）

对象的状态数据，也称为成员变量。
例如，Person 类的属性可能有 name、age。

2. 方法（Methods）

对象的行为操作，用于访问或修改属性。
例如，Person 类的方法可能有 getName()、setAge()。

2 例题1

public class Test {public static void main(String[] args) {Integer a = 100;Integer b = 100;Integer c = 200;Integer d = 200;System.out.println(a == b);    // 输出：trueSystem.out.println(c == d);    // 输出：false}
}

原因：`Integer` 的缓存机制

Java 为 -128 到 127 之间的 Integer 值提供了缓存（类似字符串常量池）。当使用自动装箱（如 Integer a = 100）时：

若值在缓存范围内（如 100），直接从缓存中获取同一对象，因此 a 和 b 引用相同。
若值超出缓存范围（如 200），每次都会创建新对象，因此 c 和 d 引用不同。

a == b 为 true：
- Integer a = 100 和 Integer b = 100 均从缓存获取对象，引用相同。
- == 比较的是引用地址，因此结果为 true。
c == d 为 false：
- Integer c = 200 和 Integer d = 200 分别创建新对象，引用不同。
- == 比较的是引用地址，因此结果为 false。

3 ==

基本类型：比较值是否相等。

int a = 10;
int b = 10;
System.out.println(a == b);  // true（值相等）

引用类型：比较内存地址是否相等。

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);  // false（地址不同）

1. 字符串常量池

String s1 = "hello";  // 常量池中的对象
String s2 = "hello";  // 复用常量池中的对象
System.out.println(s1 == s2);  // true（地址相同）String s3 = new String("hello");  // 堆中新对象
System.out.println(s1 == s3);  // false（地址不同）

2. 包装类的缓存机制

Integer、Byte、Short 等包装类缓存了部分值（默认 -128 到 127）：

Integer a = 100;  // 缓存对象
Integer b = 100;  // 复用缓存
System.out.println(a == b);  // true（地址相同）Integer c = 200;  // 新对象
Integer d = 200;  // 新对象
System.out.println(c == d);  // false（地址不同）

4 列题2

public class Test {public static void main(String[] args) {int a = 10;int b = 10;Integer a1 = 10;Integer b1 = 10;Integer a2 = new Integer(10);Integer b2 = new Integer(10);System.out.println(a == b);      // trueSystem.out.println(a1 == b1);    // trueSystem.out.println(a2 == b2);    // falseSystem.out.println(a1 == a);     // true（自动拆箱）System.out.println(a2 == a);     // true（自动拆箱）System.out.println(a1.equals(a));System.out.println(a1 == a2);}
}