包装类（以Integer为例）

/*

• 1.java 中为8种基本数据类型又对应准备了8种包装类型，8种包装类型属于引用数据类型，父类是object
• 2.为什么要提供8种包装类？
  *因为8种基本数据类型不够用
  */

package javaCoreTest;

public class IntegerTest01 {

	public static void main(String [] args) {
		//有没有这种需求：调用doSome（）方法的时候需要传一个数字进去
		//但是数字属于基本数据类型，而doSome（）方法参数的类型是Object
		//可见doSome（）方法无法接受基本数据类型的数字，
		//那怎么办？可以传一个数字对应的包装类进去
		
		//把100这个数字经过构造方法包装成对象
		MyInt myInt = new MyInt(100);
		
		//doSome（）方法虽然不能直接传100，但是可以传一个100对应的包装类型
		doSome(myInt);
	}
	
	public static void doSome(Object obj) {
		System.out.println(obj);
	}
}


//包装类
class MyInt{
	int value;
	
	public MyInt() {
		
	}
	
	public MyInt(int value) {
		this.value = value;
	}
	
	public String toString() {
		return String.valueOf(value);
	}
}

package javaCoreTest;

/*
 * 1. 8种基本数据类型对应的包装类型是？
 *	 基本数据类型					包装类型
 * ------------------------------------
 * 		byte				java.lang.Byte(父类Number)
 * 		short				java.lang.Short(父类Number)
 * 		int					java.lang.Integer(父类Number)
 * 		long				java.lang.Long(父类Number)
 * 		float				java.lang.Float(父类Number)
 * 		double				java.lang.Double(父类Number)
 * 		boolean				java.lang.Boolean（父类Object)
 * 		char				java.lang.Character（父类Object)
 * 
 * 2.以上8种，以java.lang.Integer 为代表进行学习
 * 
 * 3.八种包装类中其中6个都是数字对应的包装类，他们的父类都是Number，
 * 		Number是一个抽象类，无法实例化对象
 * 		Number类中有一个这样的方法：
 * 			byte byteValue()
 * 			abstract double doubleValue()
 * 			abstract float floatValue()
 * 			abstract int intValue()
 * 			abstract long longValue()
 * 			short shortValue()
 * 这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的
 */
public class IntegerTest02 {
	
	public static void main(String [] args) {
		//123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用数据类型的转换
		//基本数据类型（转换为）引用数据类型（装箱）
		Integer i = new Integer(123);
		
		//将引用数据类型（转换为）基本数据类型（拆箱）
		float f = i.floatValue();
		System.out.println(f);//123.0
		
		int retValue = i.intValue();
		System.out.println(retValue);//123
	}

}

/*

• 关于Integer类的构造方法，有两个：
  • Integer(int)
  • Integer(String)
    */

package javaCoreTest;

public class IntegerTest03 {

	public static void main(String [] args) {
		//int --> Integer
		Integer x = new Integer(100);
		System.out.println(x);//100
		
		//String --> Integer
		Integer y = new Integer("123");
		System.out.println(y);//123
		
		//double --> Double
		Double d = new Double(10.2);
		System.out.println(d);//10.2
		
		//String --> Double
		Double dd = new Double("156");
		System.out.println(dd);//156.0

	}
}

package javaCoreTest;

public class IntegerTest04 {

	public static void main(String [] args) {
		//通过访问包装类的常量，来获取最大值和最小值
		System.out.println("int的最大值：" + Integer.MAX_VALUE);
		System.out.println("int的最小值：" + Integer.MIN_VALUE);
		System.out.println("Byte的最大值：" + Byte.MAX_VALUE);
		System.out.println("Byte的最大值：" + Byte.MIN_VALUE);
		
		/*
		 * 执行结果：
		 * int的最大值：2147483647
		   int的最小值：-2147483648
		   Byte的最大值：127
		   Byte的最大值：-128
		 */	
	}
}

• 自动装箱：基本数据类型自动转换成包装类
• 自动拆箱：包装类自动转换成基本数据类型

package javaCoreTest;

/*
 * 自动装箱：基本数据类型自动转换成包装类
 * 自动拆箱：包装类自动转换成基本数据类型
 * 
 * 有了自动拆箱之后，Number类中的方法就用不着了。
 * 
 * 自动装箱和自动拆箱的好处？
 * 方便编程
 */

public class IntegerTest05 {

	public static void main(String [] args) {
		//900是基本数据类型
		//x是包装类型
		//基本数据类型（自动转换为）包装类型：自动装箱
		Integer x = 900;
		System.out.println(x);
		
		//y是基本数据类型
		//x是包装类型
		//包装类型（自动转换为）基本数据类型：自动拆箱
		int y = x;
		System.out.println(y);
		
		Integer z = 1000;
		//为什么下面的代码没有报错？
		//因为z会进行自动拆箱。将z转换成基本数据类型
		System.out.println(z + 1);
		
		Integer a = 1000;//Integer a = new Integer(1000);a是一个引用，保存内存地址指向对象
		Integer b = 1000;//Integer b = new Integer(1000);b是一个引用，保存内存地址指向对象
		
		//==比较的是对象的内存地址，a和b两个引用中保存的对象内存地址不同
		System.out.println(a == b);//false

	}
}

/*

• 整数常量池
  */

package javaCoreTest;

public class IntegerTest06 {

	public static void main(String [] args) {
		Integer a = 128;
		Integer b = 128;
		System.out.println(a == b);//false
		
		/*
		 *java中为了提高程序的执行效率，将【-128-127】之间所有的包装对象提前创建好，
		 *放到了一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据不需要再new了，
		 *直接从整数型常量池当中取出来。
		 *
		 * 原理：x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。
		 */
		
		Integer c = 127;
		Integer d = 127;
		System.out.println(c == d);//true
	}
}

package javaCoreTest;

/*
 * 总结之前所学经典异常：
 * 数组越界异常：ArrayIndexOutOfBoundsException
 * 空指针异常:NullPointerException
 * 数字格式化异常:NumberFormatException
 * 类型转换异常：ClassCastException
 * 
 * Integer类当中有哪些常用的方法？
 */

public class IntegerTest07 {

	public static void main(String [] args) {
		//手动装箱
		Integer x = new Integer(100);
		
		//手动拆箱
		int y = x.intValue();
		System.out.println(y);
		
		Integer a = new Integer("123");
		
		//不是一个“数字”可以包装成Integer吗？
		//不能，编译的时候没问题，运行的时候出翔异常：
		//数字格式化异常：java.lang.NumberFormatException
		//Integer a = new Integer("中文");
		
		//重点方法
		//static int parseInt(String a)
		//静态方法，传参String， 返回int
		int retValue = Integer.parseInt("123");
		System.out.println(retValue + 100);
		
		//int retValue = Integer.parseInt("中文”）;NumberFormatException
		
		//---------------------以下内容作为了解------------------------------------
		//static String toBinaryString(int i)
		//静态的：将十进制转换成二进制字符串
		String binaryString = Integer.toBinaryString(3);
		System.out.println(binaryString);//"11"二进制字符串
		
		//static String toHexString(int i)
		//静态的：将十进制转换成十六进制字符串
		String hexString = Integer.toHexString(16);
		System.out.println(hexString);//"10"
		
		//static String toOctalString(int i)
		//静态的：将十进制转换成八进制字符串
		String octalString = Integer.toOctalString(8);
		System.out.println(octalString);//"10"
		
		//static Integer valueOf(int i)
		//静态的：int --> Integer
		Integer i1 = Integer.valueOf(100);
		System.out.println(i1);//100

		//static Integer valueOf(String s)
		//静态的：String --> Integer
		Integer i2 = Integer.valueOf("100");
		System.out.println(i2);//100
	}
	
}