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