【Java基础|第十八篇】面向对象（八）——包装类
（四）面向对象
（10）包装类：
（10.1）为什么要有包装类？
Java是面向对象的语言，通过对象调用方法和属性来解决问题
而我们的基本数据类型只是一些简单的数字和字母，不是对象，不能调用方法和属性，功能有限。
（10.2）概念
基于基本数据类型，把这八种基本类型的数据，包装成对应的类类型，这时候就变成对象了，就可以调用方法了或者访问属性了。
（10.3）各类型对应的包装类： 
（10.4）Integer中的一些常用方法：
Integer 类提供了多个 toString () 方法，用于将整数转换为字符串表
public static String toString(int i)
作用：将 int 类型的整数转换为对应的字符串
返回值：表示该整数的 String 对象
调用者：静态方法，通过 Integer 类直接调用
示例：
Integer.toString(123) → "123"
public static String toString(int i, int radix)
作用：将 int 类型的整数按指定基数（进制）转换为字符串
返回值：表示该整数在指定进制下的 String 对象
调用者：静态方法，通过 Integer 类直接调用
示例：
Integer.toString(10, 2) → "1010"（十进制 10 转二进制）
public String toString()
作用：将当前 Integer 对象的值转换为字符串
返回值：表示该对象值的 String 对象
调用者：Integer 类的实例对象
示例：
new Integer(456).toString() → "456"
sum 方法
方法定义：
public static int sum(int a, int b)作用：计算两个 int 类型整数的和
返回值：两个参数相加的结果（int 类型）
调用者：静态方法，通过 Integer 类直接调用
示例：
Integer.sum(3, 5) → 8
max 方法
方法定义：
public static int max(int a, int b)作用：比较两个 int 类型整数，返回较大的值
返回值：两个参数中较大的那个 int 值
调用者：静态方法，通过 Integer 类直接调用
示例：
Integer.max(3, 5) → 5
parseInt 方法（重点掌握）
方法定义 1：
public static int parseInt(String s)
作用：将字符串参数解析为十进制的 int 值
返回值：解析后的 int 类型数值
调用者：静态方法，通过 Integer 类直接调用
示例：
Integer.parseInt("123") → 123方法定义 2：
public static int parseInt(String s, int radix)
作用：将指定基数（进制）的字符串参数解析为 int 值
返回值：解析后的 int 类型数值
调用者：静态方法，通过 Integer 类直接调用
示例：
Integer.parseInt("1010", 2) → 10（二进制 "1010" 转十进制）
equals 方法
方法定义：
public boolean equals(Object obj)作用：比较当前 Integer 对象与指定对象是否相等（值相等）
返回值：如果两个对象的值相等则返回 true，否则返回 false
调用者：Integer 类的实例对象
示例：
Integer a = new Integer(10); Integer b = new Integer(10); a.equals(b) → true注意：equals () 方法比较的是对象的值，而
==比较的是对象的引用（对于基本类型则比较值）
基础案例：
public class Test042_Integer {public static void main(String[] args) {int i = 1;//编译报错，因为i不是对象//i.toString();//1.int --> Integer//Integer o = new Integer(i);Integer o = Integer.valueOf(1);//2.Integer --> intint j = o.intValue();System.out.println(o.toString());//3.包装类静态成员访问System.out.println(Integer.MIN_VALUE);System.out.println(Integer.MAX_VALUE);//4.包装类静态方法调用//把100分别转为十进制、二进制、八进制、十六进制的字符串形式System.out.println(Integer.toString(100));System.out.println(Integer.toString(100,2));System.out.println(Integer.toString(100,8));System.out.println(Integer.toString(100,16));//把100转为二进制形式System.out.println(Integer.toBinaryString(100));//把字符串"100"转为int类型的100int num = Integer.parseInt("100");System.out.println(num);}
}（10.5）各包装类常用方法总结：
所有包装类共有的方法，所有包装类都继承自Object，并实现了Comparable接口，因此拥有以下通用方法：
toString()：将包装类对象转换为字符串（如Integer.toString(123)返回"123"）。
equals(Object obj)：比较两个包装类对象的值是否相等（注意与==的区别，==比较地址，equals比较值）。
compareTo(T o)：比较两个对象的大小（实现Comparable接口的方法，返回负数、0、正数表示小于、等于、大于）。
hashCode()：返回对象的哈希码（通常与值相关）。
valueOf(基本类型)：将基本类型转换为包装类对象（推荐使用，可能复用缓存对象）。
数值型包装类，数值型包装类（Byte、Short、Integer、Long、Float、Double）提供了大量与数值处理相关的方法：
（1）类型转换
parseXxx(String s)：将字符串转换为对应的基本类型（如Integer.parseInt("123")返回int类型的 123；Double.parseDouble("3.14")返回double的 3.14）。
注意：若字符串格式不正确，会抛出NumberFormatException。
valueOf(String s)：将字符串转换为包装类对象（如Integer.valueOf("123")返回Integer对象）。（2）常量
MIN_VALUE/MAX_VALUE：表示对应基本类型的最小值和最大值（如Integer.MIN_VALUE是-2^31，Double.MAX_VALUE是最大的双精度值）。
TYPE：表示对应的基本类型的Class对象（如Integer.TYPE等价于int.class）。（3）进制转换
toBinaryString(int i)：将整数转换为二进制字符串（Integer和Long特有）。
toOctalString(int i)：转换为八进制字符串。
toHexString(int i)：转换为十六进制字符串（字母小写）。
toString(int i, int radix)：将整数转换为指定进制（radix，2~36）的字符串。（4）其他常用方法
intValue()/longValue()/doubleValue()等：将包装类对象转换为对应的基本类型（拆箱操作）。
compare(int x, int y)：静态方法，比较两个基本类型值的大小（如Integer.compare(3, 5)返回-1）。
sum(int a, int b)（Integer特有）：返回两数之和（Java 8+）。
Character（字符包装类）
Character用于封装char类型，提供字符判断和转换的方法：
isLetter(char c)：判断是否为字母（a-z 或 A-Z）。
isDigit(char c)：判断是否为数字（0-9）。
isWhitespace(char c)：判断是否为空白字符（空格、制表符\t、换行符\n等）。
isUpperCase(char c)/isLowerCase(char c)：判断是否为大写 / 小写字母。
toUpperCase(char c)/toLowerCase(char c)：将字符转换为大写 / 小写。
valueOf(char c)：将char转换为Character对象。
Boolean（布尔包装类）
Boolean封装boolean类型，方法较少但常用：
parseBoolean(String s)：将字符串转换为boolean（忽略大小写，仅当字符串为"true"时返回true，其他均为false）。
valueOf(String s)/valueOf(boolean b)：返回Boolean对象（true或false）。常量：
TRUE（表示true的对象）、FALSE（表示false的对象）、TYPE（boolean.class）。
这些方法了解一下即可，最常用的是Integer中的那些，以及各基本数据类型与包装类型的转换。
（10.6）装箱与拆箱
概念;
JDK1.5或以上，可以支持基本类型和包装类型之间的自动装箱、自动拆箱，这简化了基本类型和包装类型之间的转换。
自动装箱：基本数据类型值 自动转化为 包装类对象
自动拆箱：包装类对象 自动转化为 基本数据类型值
//手动装箱
Integer o = new Integer(1);
//自动装箱
Integer o = 1;//手动拆箱
int i = o.intValue();
//自动拆箱
int i = o;注意：
使用基本类型和包装类时，要考虑隐式类型转换。（不支持小转大）
不同类型的基本数据类型和包装类，是不可以自动装箱拆箱的，例如int和Long。
基础案例：
public class Test043_Test {public void test1(int i) {}public void test2(Integer i) {}public void test3(long i) {}public void test4(Long i) {}public static void main(String[] args) {Test043_Test t=new Test043_Test();t.test1(1);// 编译通过 int i = 1; 正常赋值t.test2(1);// 编译通过 Integer i = 1; 自动装箱t.test3(1);// 编译通过 long i = 1; 隐式类型转换// 编译报错// 错误的代码：Long i = 1;// int和Long 之间没有任何关系//t.test4(1);t.test4(1L);// 编译通过 Long i = 1L; 自动装箱}
}特殊情况: Integer缓冲区
运行时常量池（Runtime Constant Pool）：用于存储编译期间生成的各种字面量和符号引用，Integer常量池就存在运行时常量池里面。
Integer常量池是一个特殊的缓存机制，用于存储在范围 [-128, 127] 之间的Integer常量对象。这个范围是Java中的一个固定范围，超出这个范围的整型常量不会被缓存。
作用：通过复用对象可以节省内存空间和提高性能。
触发的条件：采用自动装箱，将整数值给一个Integer对象
整数值在[-128,127]之间
结果：常量池为该数值已经分配了固定的地址，此时会将常量池中的地址作为他的引用地址，不会创建新的对象
基础案例：
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
//获取这两个对象的地址
System.out.println("i1: " + System.identityHashCode(i1));
System.out.println("i2: " + System.identityHashCode(i2));
System.out.println("i1 == i2: "+ (i1 == i2));//false
System.out.println("--------------");Integer i3 = 127;
Integer i4 = 127;
System.out.println("i3: " + System.identityHashCode(i3));
System.out.println("i4: " + System.identityHashCode(i4));
System.out.println("i1 == i3: "+ (i1 == i3));//false
System.out.println("i3 == i4: "+ (i3 == i4)); //true //放在了常量池里
System.out.println("--------------");Integer i5 = 128;
Integer i6 = 128;
System.out.println("i5: " + System.identityHashCode(i5));
System.out.println("i6: " + System.identityHashCode(i6));
System.out.println("i5 == i6: "+ (i5 == i6));//false //超出范围