一、课程简介

1.1 包装类的诞生

Java是面向对象的语言，但是Java中存在一些异类，它们不能像对象一样进行属性和方法的调用，以及相互之间的对象化处理。

而如何才能让这些异类，像对象一样进行交互呢？

包装类，应运而生。

1.2 课程内容

• 什么是包装类
• 包装类与基本数据类型之间的对应关系
• 包装类的常用方法

二、包装类介绍

2.1 包装类与基本数据类型

1.基本数据类型

Java的数据类型分两类：基本数据类型、引用数据类型。其中，基本数据类型只是存粹的数据，只包含数值本身，没有属性、方法，也无法对象化交互。

实际应用的问题：

就基本数据类型，在常规的数据处理时，非常方便。但是，当某个方法的形参只接受引用数据类型，而方法调用者只能提供基本数据类型的实参，此时基本数据类型就显得无能为力了。

包装类的出现，可以帮助解决这个短板，如下：

2.基本数据类型与包装类的对应关系

一般是，基本数据类型的单词首字母大写改变而成。其中，有两个比较特殊：整型、字符型。

2.2 包装类的常用方法

看一下API文档：

以包装类Integer为例：

（1) 没必要一开始就全部记住，把常用的重点熟悉，其他的会查会用即可。

（2）Java的包装类都是final关键字修饰，所以都是不允许被继承的，也没有子类。

三、 基本数据类型与包装类之间的转换：装箱、拆箱

1.转换图示

两者之间的转换，是通过装箱、拆箱两个动作来完成的。

每个动作都有自动、手动两个方式。

2.代码操作

public class WrapTestOne {
    public static void main(String[] args) {
                        //以下是装箱
        //1.自动装箱
        int t1=2;
        Integer t2=t1;                    //直接把赋值
        //2.手动装箱
        Integer t3=new Integer(t1);         //通过new关键字，在构造方法中，用t1的值构造t3对象
        
        //测试
        System.out.println("基本数据类型int类型变量t1="+t1);
        System.out.println("自动装箱后，包装类Integer类型对象t2="+t2);
        System.out.println("手动装箱后，包装类Integer类型对象t3="+t3);
        System.out.println("*****************************");
                            //以下是拆箱
        //1.自动拆箱
        int t4=t2;                    //直接赋值：会自动将包装类t2中的数值提取出来，赋值给整型变量t4
        //2.手动拆箱
        int t5=t2.intValue();         //通过调用包装类里的intValue()方法
        
        //测试
        System.out.println("包装类Integer类型对象t2="+t2);
        System.out.println("自动拆箱后，基本数据类型int类型变量t4="+t4);
        System.out.println("手动拆箱后，基本数据类型int类型变量t5="+t5);
    }
}

--->
基本数据类型int类型变量t1=2
自动装箱后，包装类Integer类型对象t2=2
手动装箱后，包装类Integer类型对象t3=2
*****************************
包装类Integer类型对象t2=2
自动拆箱后，基本数据类型int类型变量t4=2
手动拆箱后，基本数据类型int类型变量t5=2

3.对于特殊的浮点型：

public class WrapTestOne {
    public static void main(String[] args) {
        int t1=2;
        Integer t2=t1;//装箱
    
        double t6=t2.doubleValue();//拆箱
        System.out.println("拆箱后，基本数据类型double类型变量t6="+t6);
    }
}

--->
拆箱后，基本数据类型double类型变量t6=2.0

4.总结

（1）不管是装箱、拆箱，自动的底层，依然是手动的方式。只不过，Java通过一种相对简洁的方式，进行了封装（也称为语法糖/编译器级别特性）。

（2）手动操作

（3）自动操作

还是自动挡好用啊~

四、基本数据类型与包装类之间的比较

4.1 默认值的比较

4.2 特点、存储表现等的比较

五、基本数据类型和字符串之间的转换

在WrapTestTwo.java中：

public class WrapTestTwo {
    public static void main(String[] args) {
        // 基本数据类型-->字符串
        // 包装类的toString方法
        int t1=2;
        String t2=Integer.toString(t1);            //调用包装类Integer的toString方法，将整型t1转换为字符串类性的t2
        //测试
        System.out.println("int类型转换为String类型对象t2="+t2);
        System.out.println("************************************");
        
        //字符串-->基本数据类型
        //1.包装类的parse方法
        int t3=Integer.parseInt(t2);
        System.out.println("String类型转换为int类型变量t3="+t3);
        //2.包装类的valueOf方法
        int t4=Integer.valueOf(t2);//将字符串类t2装箱，变成包装类，再拆箱为整型t4
        System.out.println("String类型转换为int类型变量t4="+t4);
    }
}

--->
int类型转换为String类型对象t2=2
************************************
String类型转换为int类型变量t3=2
String类型转换为int类型变量t4=2

六、注意

6.1 包装类对象的初始值

1.基本数据类型的初始值：

2.包装类对象的初始值：

都是null.

6.2 包装类对象之间的比较

1.思考题：这段代码的结果是？

（1）我的答案：

因为对象名不同，内存空间就不一样，所以任何两个不同对象，都不能相同。

至于包装类对象与基本数据类型对比，这咋比？

（2）正确答案:

（3）代码演示

对象之间的比较，比较的是引用。对象不同，指向的内存空间就不同。

public class WrapperTest {
    public static void main(String[] args) {
        Integer one=new Integer(100);//构造了两个Integer类型的对象
        Integer two=new Integer(100);
        System.out.println("one==two的结果是："+(one==two));//1.

        Integer three=100;//自动装箱            //底层：Integer four=Integer.valueOf(100);已经隐式的调用了valueOf方法
        System.out.println("three==100的结果是："+(three==100));//2.当对象与基本数据类型比较时，就会自动拆箱        //本质：100==100？
        
        Integer four=100;                    //底层：Integer four=Integer.valueOf(100);
        System.out.println("three==four的结果是："+(three==four));//3.因为被暂住缓存区，两个变量指向的是同一个对象
        
        Integer five=200;
        System.out.println("five==200的结果是："+(five==200));//4.本质：200==200？

        Integer six=200;
        System.out.println("five==six的结果是："+(five==six));//5.因为200比127大，所以直接new了一个新的不同的对象
    }
}


--->
one==two的结果是：false
three==100的结果是：true
three==four的结果是：true
five==200的结果是：true
five==six的结果是：false

2.原理解释：缓存区（对象常量池）

Java在几种包装类中提供了缓存设计，会对一定范围内的数据做缓存。如果数据在范围内，会优先从缓存中获取数据，超出范围才会创建新对象。

这个缓存区，就是对象常量池。

其中：

• Byte、Short、Integer、Long：缓存区间[-128,127]
• Character：缓存区间[0,127]
• Boolean：缓存两个：true、false

注意：

（1）“在内存中，开辟一块空间啥意思？”：

在CPU给JVM分配的空间中，细化分配一块空间。

C盘D盘。不是内存，是硬盘。特点是数据的存储是持久化的，即永久存储。

内存是在CPU中，内存的数据存储是临时性的。例如：系统工具计算器中用户输入的数据。

JVM在运行时，会在CPU中获取一块内存空间，即JVM的内存。

（2）八种基本数据类型中，除了浮点型的float、double数据，都可以应用对象常量池的概念。

public class WrapperTest {
    public static void main(String[] args) {    
        Double d1=Double.valueOf(100);
        System.out.println("d1==100的结果是："+(d1==100));//本质：100==100？
    
        Double d2=Double.valueOf(100);
        System.out.println("d1==d2的结果是："+(d1==d2));//因为浮点型数据类型，都没有对象常量池。所以都是new一个新的对象和内存空间的
    }
}

--->
d1==100的结果是：true
d1==d2的结果是：false

（3）判断相等性的，除了上述的逻辑运算符==，还可以是调用equals()方法。

• 类型相同，且数值相同，返回true;
• 反之，返回false

当比较的对方为基本数据类型时，会先自动装箱，后进行比较：