Java 面向对象（五）
包装类
什么是包装类
在面向对象当中“一切皆对象”。基本数据类型变量不是对象，比如 int a = 10; 当中就没有对象，所以就很矛盾。此时我们就可以对基本数据类型进行包装，把基本数据类型包装一个对象。把基本数据类型变的更强大，以面向对象的思想来去使用这些类型。
对基本数据类型包装的好处
（1）使用包装对象后，功能变的更加强大。
比如：以前使用double来去表示一个人的分数。此时这个人的分数考了0分，可以表示0.0。如果这个人没有来考试，那就代表这个没有分数，使用包装类型后， 即可表示这两种状态一个是0.0，一个是null，基本数据类型就办不到。
（2）包装类当中给我们提供了很多方法，可以直接过来使用
比如：我们要将一个数据转成二进制，使用包装对象后， 就可以直接调用方法算出来，不需要我们再去手动去算。
基本数据类型对应的包装类
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
装箱操作
把基本数据类型变成包装类，我们称为装箱操作。可以使用以下两种方式进行装操作
（1）包装类的构造器
（2）包装类的静态方法 valueOf()
Integer num1 = new Integer(10);
Integer num2 = Integer.valueOf(20);
Integer.valueOf本质也是new Integer创建，只不过当中多了一个缓存判断
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public static void main(String[] args) {
int a = 10;
// 把基本数据类型变成 包装类 ，装箱操作
Integer num = Integer.valueOf(a);
// Integer 内部覆盖了toString
System.out.println(num); // 10
// 知道是有什么基本数据类型包装过来的
System.out.println(num.TYPE); // int
System.out.println(num.MAX_VALUE); // 2147483647
System.out.println(num.MIN_VALUE); // -2147483648
}
拆箱操作
把包装类对象转成对应的基本数据类型，我们称为拆箱操作。
包装类的 xxxValue() 方法，xxx为对应的基本数据类型。
// Integer a;
int num = a.intValue();
自动装箱
自动装箱：可以直接把一个基本数据类型的值赋值给包装类对象。
// 自动装箱
Integer i = 10;
自动拆箱
自动拆箱：可以直接把一个包装类对象赋值给基本数据类型的变量。
// 自动拆箱
int n = i;
自动装箱和自动拆箱的本质
自动装箱和自动拆箱是一种语法糖，可以通过反编译查看他们的本质。
public static void main(String[] args) {
// 自动装箱
Integer i = 10;
// 自动拆箱
int n = i;
}
反编译后：
public static void main(String args[])
{
Integer i = Integer.valueOf(10);
int n = i.intValue();
}
字符串与其他类型的转换
基本数据类型转字符串
（1）包装类的toString()方法
（2）String的valeOf()方法
（3）加上一个空字符串
int i = 10;
String str1 = Integer.toString(i);
String str2 = String.valueOf(i);
String str3 = i + "";
System.out.println(str1 + ", " + str2 + ", " + str3); // 10, 10, 10
字符串转基本数据类型
（1）包装类的parseXxx()方法，Xxx为对应的基本数据类型。
（2）包装类的valueOf()方法转为基本数据类型的包装类，会自动拆箱。
String s = "10";
int i1 = Integer.parseInt(s);
int i2 = Integer.valueOf(s);
字符串转包装类
（1）包装类的构造器
（2）包装类的静态方法 valueOf()
Integer i1 = new Integer("13");
Integer i2 = Integer.valueOf("13");
其实是由字符串转为基本数据类型，再由基本数据类型转成包装类
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
特殊的，字符串转Boolean
字符串为true才为true，其它都是false
Boolean b1 = new Boolean("true");
Boolean b2 = Boolean.valueOf("tru");
System.out.println(b1); // true
System.out.println(b2); // false
包装类转字符串
包装类的toString()方法
Integer num = Integer.valueOf(10);
String str = num.toString();
基本数据类型和包装类的区别
（1）默认值
int： 0
Intege：null
（2）包装类当中提供了很多方法直接给我们使用
比如：Integer.toBinaryString(5)
（3）集合框架当中不能存放基本数据类型。只能存对象。
什么时候使用基本数据类型？什么时候使用包装类？
在类当中，成员变量一般都使用包装类。
在方法当中，我们一般都使用基本数据类型。
方法中，基本数据类型存储在栈当中，包装类型存放在堆当中。
包装类valueOf的缓存设计
当使用valueof创建一个包装类，它内部的实现会先从缓存当中查看是否已经有该存在匹配条件 的值 ，如果就就直接返回，不会再去创建新的地址。如果没有，就去创建新的地址。
valueOf：
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
例子：
// 比较是地址 每new 都会创建一个新的地址
Integer i1 = new Integer(100);
Integer i2 = new Integer(100);
System.out.println(i1 == i2); // false
// 包装类当中缓存设计 在 -128-127之间
Integer i3 = Integer.valueOf(123);
Integer i4 = Integer.valueOf(123);
System.out.println(i3 == i4); // true
// range -128 to 127
// 缓存的范围只有-128 到 127 超过这个范围 就不会使用缓存 ，直接创建新的地址
Integer i5 = Integer.valueOf(300);
Integer i6 = Integer.valueOf(300);
System.out.println(i5 == i6); // false
