包装类及一些常用类介绍

1、什么是包装类？

以前定义变量，经常使用基本数据类型。

对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，将基本数据类型对应进行了一个封装，产生了一个新的类，称之为包装类。

如：

int，byte 等 ——  基本数据类型

    包装类      ——  引用数据类型    

2、对应关系

基本数据类型          对应的包装类                继承关系

byte                             Byte                      ---》Number---》Object

short                           Short                     ---》Number---》Object

int                              Integer                 ---》Number---》Object

long                            Long                      ---》Number---》Object

float                             Float                       ---》Number---》Object

double                       Double                    ---》Number---》Object

char                          Character                      Object

boolean                      Boolean                       Object

3、已经有基本数据类型了，为什么要封装为包装类？

（1）java语言 面向对象的语言，最擅长的操作各种各样的类。

（2）以前学习装数据的 —— 数组，int[] 、 String[] 、 double[]   、Student[]；

         以后学习装数据的 —— 集合，有一个特点，只能装引用数据类型的数据。

4、是不是有了包装类以后就不用基本数据类型了？

不是。

5、引入 —— 以Integer为例

【1】直接使用，无需导包

 

 【2】类的继承关系：

 【3】实现接口：

 【4】这个类被final修饰，那么这个类不能有子类，不能被继承： 

【5】包装类是对基本数据类型的封装： 对int类型封装产生了Integer

 

 【6】类的历史：

        从JDK1.0版本开始。

 【7】属性：

MAX_VALUE、MIN_VALUE ....

【8】构造器（发现没有空参构造器）

（1）int类型作为构造器的参数；

 

（2）String类型作为构造器的参数。

【9】包装类特有的机制：自动装箱  自动拆箱

（1）自动装箱  自动拆箱 是从JDK1.5以后新出的特性；

（2）自动装箱  自动拆箱 ：将基本数据类型和包装类进行快速的类型转换。

（底层也是通过方法（valueOf()方法、intValue()方法）实现的）

可以自定打断点测试是否走入valueOf方法中：

【10】Integer 代码示例：

package test1_Integer;

public class Test1 {
    public static void main(String[] args) {
        //属性
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //“物极必反”原理
        System.out.println(Integer.MAX_VALUE +1);
        System.out.println(Integer.MIN_VALUE -1);

        //构造器
        //参数为int类型
        Integer i1 = new Integer(12);
        //Integer类没有空参构造器
        //System.out.println(i1);//同下
        System.out.println(i1.toString());
        //结果为12

        //参数为String类型的
        Integer i2 = new Integer(12);
        //abc转换不了int类型，所以会报错
        //Integer i3 = new Integer("abc");
        System.out.println(i2);
        //System.out.println(i3);
    }
}

6、常用方法

valueOf方法的底层：

 

 代码示例：

package test2_Method;

public class Test {
    public static void main(String[] args) {
        //1、compareTo:
        Integer i1 = new Integer(7);
        Integer i2 = new Integer(12);

        System.out.println(i1.compareTo(i2));
        //底层逻辑“
        //(x < y) ? -1 : ((x == y) ? 0 : 1)
        /*即只返回3个值：
        x < y —— -1
        x = y —— 0
        x > y —— 1
        */

        //2、equals:
        //Integer对Object中的equals方法进行了重写，
        // 比较的是从底层封装的那个value的值。

        // Integer对象是通过new关键字创建的对象
        Integer i3 = new Integer(12);
        Integer i4 = new Integer(12);

        //因为 == 比较的是两个对象的地址,所以肯定不相等
        System.out.println("new关键字创建的对象，进行==比较，必然是："+ (i3 == i4));//false
        boolean flag = i3.equals(i4);//equals()方法重写了
        System.out.println(flag);

        //Integer对象通过自动装箱来完成（创建）
        Integer i5 = 10;
        Integer i6 = 10;
        System.out.println(i5.equals(i6));//true
        System.out.println("自动装箱创建的对象，进行==比较："+(i5 == i6));
        //这里，将i5、i6的值都改变为130后，进行比较就变成false了。(???)
        //原因很复杂：看调用的valueOf方法的底层
        //结论，记：
        /*
         如果自动装箱值在-128~127之间，那么比较的就是具体的数值，
         否则，比较的就是对象的地址（地址肯定不一样的）。
        */

        //3、intValue()   —— 以int类型返回该Integer的值
                          //即：将Integer —> int
        Integer i7 = 130;
        int i = i7.intValue();
        System.out.println(i);

        //4、parseInt(String s)： String —> int
        int i8 = Integer.parseInt("6666");
        //int i8 = Integer.parseInt("a");//不能是字母，必须是数字
        System.out.println(i8);

        //5、toString(int i) : Integer —> String
        //返回一个 String指定整数的 String对象
        Integer i9 = 777;
        System.out.println(i9.toString());
    }
}