java_包装类

1.基本数据类型对于的包装类型如下：

2.Object类：

1.在 Java 中所有的类都有一个公共的父类 Object，一个类只要没有明显的继承一个类，则肯定是 Object 的子类。

2.Object类的作用：

　　1.一切的引用数据类型都可以使用Objec进行接收，因为 Object 类可以接收任意的引用数据类型，所以在很多的类库设计上都采用 Object 作为方法的参数，这样操作会比较方便。

　　2.Object 类是所有对象的父类，则所有的对象都可以向 Object 进行转换，在这其中也包含了数组和接口类型，即一切的引用数据类型都可以使用 Object 进行接收。

　　  虽然接口不能继承一个类，但是依然是 Object 类的子类，因为接口本身是引用数据类型，所以可以进行向上转型操作。

3.装箱：

1.将基本数据类型转化为引用数据类型的过程叫做装箱。

2.自动装箱：装箱就是自动将基本数据类型转换为包装器类型；

   Integer total = 99;

   通过反编译class文件，可以看到执行到这句语句时，系统执行了Integer total = Integer.valueOf(99);

4.拆箱：

1.把从引用数据类型转化为基本数据类型的过程叫做拆箱。

2.自动拆箱：拆箱就是自动将包装器类型转换为基本数据类型。

    int totalprim = total;   // int totalprim = total.intValue();

5.Integer源码：

1.Integer.valueOf()函数：

public static Integer valueOf(int i) {
    return  i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
}
// 它会首先判断i的大小：如果i小于-128或者大于等于128，就创建一个Integer对象，否则执行SMALL_VALUES[i + 128]。

private static final Integer[] SMALL_VALUES = new Integer[256]; 
// 它是一个静态的Integer数组对象，也就是说最终valueOf返回的都是一个Integer对象。                   

2.intValue()函数：

@Override
public int intValue(){
    return value;
}
// 这个很简单，直接返回value值即可。  

3.实例比较：

1.Integer之间：

public class Main {
    public static void main(String[] args) {
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i1==i2);  // true
        System.out.println(i3==i4);  // false
    }
}
// 1、i1和i2会进行自动装箱，执行了valueOf函数，它们的值在(-128,128]这个范围内，它们会拿到SMALL_VALUES数组里面的同一个对象SMALL_VALUES[228]，
// 它们引用到了同一个Integer对象， 所以它们肯定是相等的。

// 2、i3和i4也会进行自动装箱，执行了valueOf函数，它们的值大于128，所以会执行new Integer(200)，
// 也就是说它们会分别创建两个不同的对象，所以它们肯定不等。

2.Double之间：

public class Main {
    public static void main(String[] args) {
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
        System.out.println(i1==i2); // false
        System.out.println(i3==i4); // false
    }
}
    
// 这个很好理解，因为对于Integer，在(-128,128]之间只有固定的256个值，所以为了避免多次创建对象，我们事先就创建好一个大小为256的Integer数组SMALL_VALUES，
// 所以如果值在这个范围内，就可以直接返回我们事先创建好的对象就可以了。

// 但是对于Double类型来说，我们就不能这样做，因为它在这个范围内个数是无限的。 
// 总结一句就是：在某个范围内的整型数值的个数是有限的，而浮点数却不是。

// 所以在Double的ValueOf函数里面的做法很直接，就是直接创建一个对象，所以每次创建的对象都不一样。

 public static Double valueOf(double d) {
     return new Double(d);
 }

3.归纳：

Integer派别：Integer、Short、Byte、Character(<128)、Long这几个类的valueOf方法的实现是类似的（-128,128）

Double派别：Double、Float的valueOf方法的实现是类似的，每次都返回不同的对象。

4.Boolean之间

public class Main {
    public static void main(String[] args) {
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
        System.out.println(i1==i2);// true
        System.out.println(i3==i4);// true
    }
}

// 可以看到返回的都是true，也就是它们执行valueOf返回的都是相同的对象。

public static Boolean valueOf(boolean b) {
    return b ? Boolean.TRUE : Boolean.FALSE;
}
// 可以看到它并没有创建对象，因为在内部已经提前创建好两个对象，因为它只有两种情况，这样也是为了避免重复创建太多的对象。

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);