JAVA包装类
一、基本数据类型
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);}
}1. 基本类型比较（a == b）
==直接比较值，a和b均为10，结果为true。
2. 自动装箱与缓存（a1 == b1）
Integer a1 = 10和Integer b1 = 10触发自动装箱，调用Integer.valueOf(10)。- 缓存机制：
Integer缓存-128到127的值，因此a1和b1引用同一对象，结果为true。
3. 显式创建对象（a2 == b2）
new Integer(10)强制创建新对象，无论值是否在缓存范围内。a2和b2是不同对象的引用，结果为false。
4. 包装类与基本类型比较（a1 == a 和 a2 == a）
- 自动拆箱：
a1和a2被拆箱为int值（通过intValue()）。 - 最终比较的是
10 == 10，结果为true。