qidao123.com技术社区-IT企服评测·应用市场

标题: JAVA包装类 [打印本页]

---

作者: 悠扬随风    时间: 2025-5-10 12:21
标题: JAVA包装类
一、基本数据范例

1.整型范例：

用于表示整数数值，不包罗小数部分。
范例位数取值范围默认值示例byte8-128 至 1270byte num = 100;short16-32,768 至 32,7670short num = 5000;int32-2,147,483,648 至 2,147,483,6470int num = 100000;long64-2^63 至 2^63-10Llong num = 10000000000L; 2. 浮点范例

用于表示带小数的数值，分为单精度和双精度。
范例位数精度默认值示例float32约 6-7 位小数0.0Ffloat pi = 3.14F;double64约 15 位小数0.0double pi = 3.14159; 3. 字符范例

用于表示单个 Unicode 字符，占 16 位。
范例位数取值范围默认值示例char160 至 65,535'\u0000'char letter = 'A';  4. 布尔范例

用于表示逻辑值，只有两个取值。
范例位数取值默认值示例boolean1true 或 falsefalseboolean 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 泛型只接受引用范例，无法直接利用基本范例。

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

复制代码

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

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

复制代码

Java 的 8 个包装类

每个基本范例对应一个包装类，均位于 java.lang 包中：
基本范例包装类父类byteByteNumbershortShortNumberintIntegerNumberlongLongNumberfloatFloatNumberdoubleDoubleNumbercharCharacterObjectbooleanBooleanObject 自动装箱与拆箱 

• 装箱：基本范例 → 包装类
  
• 拆箱：包装类 → 基本范例
  

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

复制代码

问题：

1 对象是什么

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

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

对象的组成

1. 属性（Fields/Attributes）

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

2. 方法（Methods）

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

 2 例题1

1. public class Test {
2.     public static void main(String[] args) {
3.         Integer a = 100;
4.         Integer b = 100;
5.         Integer c = 200;
6.         Integer d = 200;
7.         System.out.println(a == b);    // 输出：true
8.         System.out.println(c == d);    // 输出：false
9.     }
10. }

复制代码

缘故原由：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 ==

基本范例：比力值是否相等。

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

复制代码

 引用范例：比力内存地点是否相等。

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

复制代码

 1. 字符串常量池

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

复制代码

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

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

复制代码

 4 列题2

 

1. public class Test {
2.     public static void main(String[] args) {
3.         int a = 10;
4.         int b = 10;
5.         Integer a1 = 10;
6.         Integer b1 = 10;
7.         Integer a2 = new Integer(10);
8.         Integer b2 = new Integer(10);
9.         
10.         System.out.println(a == b);      // true
11.         System.out.println(a1 == b1);    // true
12.         System.out.println(a2 == b2);    // false
13.         System.out.println(a1 == a);     // true（自动拆箱）
14.         System.out.println(a2 == a);     // true（自动拆箱）
15.         System.out.println(a1.equals(a));
16.         System.out.println(a1 == a2);
17.     }
18. }

复制代码

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。
  

5. equals() 比力值：无论包装类对象是通过缓存还是 new 创建的，只要值雷同，效果即为 true。

6. == 的本质：比力引用地点，而非对象内容。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/)

Powered by Discuz! X3.4