java进阶-第六讲 包装类与自动装拆箱

第六讲 包装类与自动装拆箱

1 应用场景及解决办法

public class BoxingTest01 {

    public static void main(String[] args) {
        Box box = new Box(1);
        m1(box);
        printTest(box);
    }

    private static void printTest(Box obj) {
        System.out.println(obj);
    }

    // 传入的参数是一个整数的数据，怎么办？
    public static void m1(Box box) {
        System.out.println(box);
    }
}

我们希望传入一个整型的数据，同时能够得到一个整型的数据
但是，方法要求的是一个对象，我们没有直接将基础数据类型传入
解决的办法只有一个：将整型的数据包装成相应的对象，然后传入。
    
    
在java中，我们看到的都是对象：那么问题来了？
    基础数据类型有没有对应的对象呢？
    当然有：
 基本数据类型						对应的类(包装类)        继承关系
    byte						  Byte				Number--->Object
    short						  Short				Number--->Object
    int							  Integer			Number--->Object
    long						  Long				Number--->Object
    float						  Float				Number--->Object
    double						  Double			Number--->Object
    boolean						  Boolean			Object
    char						  Character			Object 

2 包装类的由来

 Object obj = 1; // ?为什么能这么做？ int和Integer也是两码事
        // int是基础数据类型，Integer是类，引用类型。是两码事。
        // 1这是后是对象。是的，肯定是对象，如果不是对象，Object obj = 1;特定不成立。
        // 我们始终没有讲过，基础数据类型有父类。基础数据类型就是基础数据类型。它不是类，不是引用。

        int i = 1;// 基础数据类型
        // 如果，基础数据类型也有父类是Object，是不是说明i 可以调用Object所有的public方法
       // System.out.println(i.hashCode());编译报错，不能调用Object中的方法
        // int 是没有任何方法的，他就是基础数据类型，它不是引用类型
        // 也说明，基础数据类型没有什么父类。

        // 问题来了：字面量1怎么变成了一个对象呢？
        // 可以断定的 Object obj = 1;中的1一定是个对象
        // 既然它是对象，我们就应该知道，什么对象？类产生对象，类中有成员属性、成员方法、构造方法
        // 这里的1这个对象就是由某个类创造出来的。
        System.out.println("obj----->" + obj);
        Object intV = 1;// 这句话我们解释不通，但是可以用下面的话来代替。
        System.out.println(intV);
        // 下面的语句才是按照我们已知的java语法进行的。这是我们能够理解的方式。
        IntNumber intNumber = new IntNumber(1);
        Object intObject = intNumber;
        System.out.println(intObject);

        // 其实，并不需要我们自己写一个这样的类用来包装整型数据。SUN公司的人给我们提供了这样的类。
        Integer integer = new Integer(2);
        intObject = integer;
        System.out.println(intObject);

2 了解包装类Integer

首先，Integer类我们通过API帮助文档知道了，它直接继承自Number类:
Number类是一个抽象类，有以下方法：
public abstract int intValue();
public abstract long longValue();
public abstract float floatValue();
public abstract double doubleValue();
public byte byteValue() {
   return (byte)intValue();
}
public short shortValue() {
   return (short)intValue();
}

Integer extends Number 说明Integer需要实现Number中所有的抽象方法
同时，Integer应该能够使用Number中所有公开的成员方法。

看Integer源码：
成员属性为 private final int value;
构造方法：
public Integer(int value) {
  this.value = value;
}// 传入一个int value

public Integer(String s) throws NumberFormatException {
  this.value = parseInt(s, 10);
}

"0123456789"组合而成的就能转
否则不能转
"123abc"
"abc123"

成员方法的基本用法
Integer integer = new Integer(2);
float v = integer.floatValue();
double v1 = integer.doubleValue();
System.out.println(v1);
System.out.println(v);
intObject = integer;
System.out.println(intObject);
// Integer st1 = new Integer("123");
//System.out.println(st1);
//Integer st2 = new Integer("123a");
//NumberFormatException: For input string: "123a"
//System.out.println(st2);
//Integer st3 = new Integer("123.123");
//NumberFormatException: For input string: "123.123"
//System.out.println(st3);
// 了解Integer类
// 首先，Integer类我们通过API帮助文档知道了，它直接继承自Number类
System.out.println(Integer.MAX_VALUE);// 2147483647
System.out.println(Integer.MIN_VALUE);//-2147483648
System.out.println(Long.MAX_VALUE);//9223372036854775807

3 什么是装箱与拆箱

Integer integer = new Integer(1000);
这就叫做装箱，这就好比将一个个基本的货物装入包装袋中一样。这样就成为了一个包裹
就是一个产品。在java中我们叫它对象。Integer就是整型的包装机，把整数放进来
就成了一个对象。这叫装箱
从此以后，8个基本数据类型，都可以通过装箱成为对象。

装箱就通过构造方法，将基本数据类型构造成它所对应的包装类的对象。
白酒的酒水---基本的类型
酒水----酒鬼酒的包装盒中，就成为一瓶酒鬼酒，这一瓶酒鬼酒就是一个对象。
酒水放到茅台的包装盒中，就成为一瓶茅台酒，这一瓶茅台酒就是一个对象。

拆箱：
就是将包装类对象中的成员变量值给拿回来，变回它对应的基础数据类型。
int i = integer.intValue();
这就是拆箱。
把茅台、酒鬼酒的包装拆了，把酒倒出来，本质上讲没什么区别。

4 自动装箱和自动拆箱

在java中，SUN公司提供一套机制，不需要像我们上面介绍的那样做。
装箱的时候，不需要new对象，
拆箱的时候，也不需要调用对应的xxxValue()方法。
这种机制叫做自动装箱、自动拆箱机制
自动装箱：
	基础数据类型可以直接转换为它所对应的包装类的对象，这叫做自动装箱
	包装类的对象，可以自动转换为它所对应的基础数据类型，这叫做自动拆箱

Integer i1 = 10000;// 这就是自动装箱
// 它等价于：
// i1 = new Integer(10000);
int i2 = i1;
// 它等价于：
// int i2 = i1.intValue();
System.out.println(i1);// 这里的i1是不是就是一个对象，调用的println(Object obj)
System.out.println(i2);// 这里的i2是不是就是一个整型，调用的println(int x)

自动装箱与自动拆箱有什么用？方便编程。写起来简单。

5 关于Integer的一些注意点(面试常问)

Integer integer1 = 100;
Integer integer2 = 100;
System.out.println(integer1 == integer2);//true
以上，是两个Integer对象的引用
    Integer integer1 = new Integer(100);
    Integer integer2 = new Integer(100);
这看上去是两个对象，
    
源码分析：(Integer类中的静态内部类)
private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
        static {
            int h = 127;
            high = h;
            cache = new Integer[(high - low) + 1];// 256
            int j = low;// -128
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);// -128~127
        }
    }

// static final Integer cache[];//这是一个整数型常量池。
// 这个常量池是不是在方法区内存中
// 方法区内存中还有一个整数型的常量池。
// 存放数据的范围为-128~127 一共256个整数。


解析上面的问题：
    "==" 号只是判断当前引用代表的内存空间存放的地址值。