目录：
1.包装类
1.1 包装类
- Java中为8种 基本数据类型又对应准备了8种包装类型。
- 包装类属于 引用数据类型。
- 包装类中有六个都是数字对应的包装类，他们父类都是 Number。
1.2 包装类的分类
byte类型对应的包装类：Byte (父类是Number)
short类型对应的包装类：Short (父类是Number)
int类型对应的包装类：Integer (父类是Number)
long类型对应的包装类：Long (父类是Number)
float类型对应的包装类：Float (父类是Number)
double类型对应的包装类：Double (父类是Number)
boolean类型对应的包装类：Boolean (父类是Number)
char类型对应的包装类：Character (父类是Number)
（包装类为引用数据类型）
扫描二维码关注公众号，回复： 16723114 查看本文章
2.思考：为什么要提供8种包装类型？
因为8种基本数据类型不够用，所以要提供了8种包装类型 (为引用数据类型)，满足不同的开发需求。
现有以下需求：（使用包装类能满足以下开发需求）
方法中的参数类型为Object o (引用数据类型) ，但传入的参数的类型为100(基本数据类型)，怎么解决这个问题呢？
解： 将100封装为“包装类”即可符合参数传入要求，也一样能传入数据。例子如：
public class IntegetTest01 { public static void main(String[] args) { /* 现有以下需求: 调用doSome()方法时传入一个数字100(基本数据类型),但doSome()方法要求传入的参数类 型为: Object obj(引用数据类型), 怎么解决这个问题？ 解: 可以将数字100经过构造“构造方法”包装成“对象”,把这个"对象"作为参数传入到 doSome()方法中 */ //把数字100经过“构造方法”包装成“对象” MyInt myInt = new MyInt(100); //将“包装类对象”作为参数来传入到doSome()方法中 doSome(myInt); } public static void doSome(Object obj) { //方法参数为: 一个Object对象 /* 当没重写toString()方法时,底层默认使用的Object类的toString()方法 : 输出对象 的“内存地址”信息，返回值为String类型 如: System.out.println(obj); //com.ximo.nine_11.MyInt@7ef20235 建议重写toString()方法 */ //输出重写了toString()方法的对象 : 输出对象中的数据 System.out.println(obj); // 100 } } class MyInt { //自定义的包装类 int value; public MyInt() { //无参构造方法 } public MyInt(int value) { //有参构造方法 this.value = value; } /** * Object.toString()方法是Object类下有的方法，Object类是所有对象的父类， * 意味着其的子类也能调用toString()方法: * * Object.toString()方法 : 输出该对象的”内存地址“信息,返回值为String字符串类型 : * return getClass().getName() + "@" + Integer.toHexString(hashCode()); * * Object.toString()方法的作用: * 1.将“对象”转换为“字符串” * 2.返回一个对象的“内存地址”信息，返回值为String类型。 */ //重写toString()方法 @Override public String toString() { //返回对象中的数据,返回值类型为String类型 return String.valueOf(value); } }
3.通过访问包装类的常量，获取“最大值”和最小值
通过访问包装类的常量，获取基本数据类型的“最大值”和最小值
//通过访问“包装类的常量”，获取基本数据类型的“最大值”和“最小值” System.out.println("byte的最小值: "+Byte.MIN_VALUE); //-128 System.out.println("byte的最大值: "+Byte.MAX_VALUE); //127 System.out.println("short的最小值: "+Short.MIN_VALUE); //32768 System.out.println("short的最大值: "+Short.MAX_VALUE); //32767 System.out.println("int的最小值: "+Integer.MIN_VALUE); //-2147483648 System.out.println("int的最大值: "+Integer.MAX_VALUE); //2147483647 //-9223372036854775808 System.out.println("long的最小值: "+Long.MIN_VALUE); //9223372036854775807 System.out.println("long的最大值: "+Long.MAX_VALUE); System.out.println("float的最小值: "+Float.MIN_VALUE); //1.4E-45 System.out.println("float的最大值: "+Float.MAX_VALUE); //3.4028235E38 System.out.println("double的最小值: "+Double.MIN_VALUE); //4.9E-324 //1.7976931348623157E308 System.out.println("double的最大值: "+Double.MAX_VALUE); System.out.println(Boolean.FALSE); //false System.out.println(Boolean.TRUE); //true System.out.println(Character.MIN_VALUE); System.out.println(Character.MAX_VALUE);
4.装箱 和 拆箱：
4.1 装箱
装箱: 将“基本数据类型”类型转换为“引用数据类型”。
装箱：创建包装类，将对应的“基本数据类型”数据存储到“包装类”中。
例子如：
/** 将“基本数据类型”类型转换为 “引用数据类型” (装箱) 装箱: 创建包装类,将对应的“基本数据类型”数据存储到“包装类”中。 */ //基本数据类型 byte b =12; short s =12; int i =123; long l = 123L; float f = 123.0f; double d =123.0; boolean bl = true; char c = '中'; //将“基本数据类型”转换为 “引用数据类型” : 装箱 //将数字100转换为Byte包装类型 Byte B = new Byte(b); //创建 “byte类型” 对应的包装类: Byte Short S = new Short(s); //创建 “short类型” 对应的包装类: Short Integer I = new Integer(i); //创建 “int类型” 对应的包装类: Integer Long L = new Long(l); //创建 “long类型” 对应的包装类: Long Float F = new Float(f); //创建 “float类型” 对应的包装类: Float Double D = new Double(d); //创建 “double类型” 对应的包装类: Double Boolean BL = new Boolean(bl); //创建 “boolean类型” 对应的包装类: Boolean Character C = new Character(c); //创建 “char类型” 对应的包装类: Character //输出包装类(引用数据类型)对象 //包装类中重写了toString()方法,所以此处输出包装类中存储的"基本数据类型"数据 System.out.println(B.toString()); //12 System.out.println(S.toString()); //12 System.out.println(I.toString()); //123 System.out.println(L.toString()); //123 System.out.println(F.toString()); //123.0 System.out.println(D.toString()); //123.0 System.out.println(BL.toString()); //true System.out.println(C.toString()); //中
4.2 拆箱
拆箱: 将“引用数据类型”类型转换为“基本数据类型”。
拆箱：调用各自包装类中有的xxxValue()方法，输出存储在包装类中的基本数据类型的数据。
例子如：
//基本数据类型 byte b =12; short s =12; int i =123; long l = 123L; float f = 123.0f; double d =123.0; boolean bl = true; char c = '中'; //装箱 Byte B = new Byte(b); Short S = new Short(s); Integer I = new Integer(i); Long L = new Long(l); Float F = new Float(f); Double D = new Double(d); Boolean BL = new Boolean(bl); Character C = new Character(c); //拆箱 /* 拆箱 : 将"引用数据类型"转换为"基本数据类型"。 调用各自包装类中有的xxxValue()方法，输出存储在包装类中的基本数据类型的数据。 */ byte b_Unpack = B.byteValue(); Short S_Unpack = S.shortValue(); Integer I_Unpack = I.intValue(); Long L_Unpack = L.longValue(); Float F_Unpack = F.floatValue(); Double D_Unpack = D.doubleValue(); Boolean BL_Unpack = BL.booleanValue(); Character C_Unpack = C.charValue();
5.Number类：
5.1 Number类的构造方法
public Number()
5.2 Number类中的方法
byte byteValue( )：
以 byte 形式返回指定的数值。double doubleValue( ) ：
以 double 形式返回指定的数值。float floatValue( ) ：
以 float 形式返回指定的数值。int intValue( ) ：
以 int 形式返回指定的数值。long longValue( )：
以 long 形式返回指定的数值。short shortValue( ) ：
以 short 形式返回指定的数值。
6.Integer类
6.1 Integer类构造方法
Integer类的两大构造方法:
Integer( int value )
Integer( String s )
例子如：
//Integer的构造方法 //将数字转换为Integer包装类型(int ---> Integer) Integer x = new Integer(100); System.out.println(x); //100 //将String类型的数字，转换成Integer包装类型(String ---> Integer) Integer y = new Integer("123"); System.out.println(y); //123不是一个数字，不能包装成Integer类，运行时会出现异常。
//以下代码不会报错，是Integer类的构造方法的正确使用范畴 Integer x = new Integer ("1000"); Integer y = new Integer (1000); System.out.println(x); System.out.println(y); //这段代码会报错 //不是一个数字，不能包装成Integer类，运行时会出现异常。 Integer z = new Integer ("中国"); System.out.println(z);
6.2 Integer类常用方法
int intValue( )
int intValue( ) : 以 int 类型返回该 Integer 的值。（拆箱要用到该方法）。
//装箱 Integer I = new Integer(123); //intValue() : 将Integer类型数据以int类型返回 int i = I.intValue(); //String转换为int System.out.println(i); //123
int parseInt( String s )
int parseInt(String s)：静态方法，传入String类型参数，返回值为int类型。
//静态方法，传入String类型参数，返回值为int类型 /* 网页上文本框中输入的实际上是"100"字符串，后台数据库中要求存的是100数字， 此时java程序要将“100”转换为数字100 */ int i = Integer.parseInt("123"); //将“String类型”数据转换为“int类型”数据 System.out.println(i); //该方法不能将中文装换为数字，否则会报“数字格式化异常” int i2 = Integer.parseInt("中国"); //报错: NumberFormatException(数字格式化异常) //照葫芦画瓢 --- 其他的包装类也有类似的方法 //parseDouble、parseFloat ...
String toBinaryString( int i )
String toBinaryString( int i) ： 为静态方法，
将十进制转换为二进制，返回值为String类型。
//静态的：将十进制转换为二进制，返回值为String类型 String binaryString = Integer.toBinaryString(3); System.out.println(binaryString); // 11
String toHexString( int i )
String toHexString( int i) ： 为静态方法，
将十进制转换为十六进制，返回值为String类型。
//静态的：将十进制转换为十六进制，返回值为String类型 String hexString1 = Integer.toHexString(16); String hexString2 = Integer.toHexString(17); System.out.println(hexString1); //10 System.out.println(hexString2); //11
String toOctalString( int i )
- String toOctalString( int i ) ： 为静态方法，
- 将十进制转换为八进制，返回值为String类型。
//静态的：将十进制转换为八进制，返回值为String类型 String octalString = Integer.toOctalString(8); System.out.println(octalString); //10
Integer valueOf( int i )
Integer valueOf(int i) : 为静态方法，
将int类型转换为Integer类型
//静态的：将int类型转换为Integer类型 Integer i1 = Integer.valueOf(100);System.out.println(i1); //100
Integer valueOf( String s )
Integer valueOf( String s ) : 为静态方法，
将int类型转换为Integer类型
//静态的：将String类型转换为Integer类型 Integer i2 = Integer.valueOf("100"); System.out.println(i2); //100
7.Double类的构造方法
7.1 Double类的构造方法
Integer类的两大构造方法:
Double( double value)
Double(String s)
例子如：
//Double的构造方法 //将数字转换为Double包装类型 (double ---> Double) Double x = new Double(1.23); System.out.println(x); //1.23 //将String类型的数字，转换成Double包装类型 (String ---> Integer) Double y = new Double("3.14"); System.out.println(y); //3.14
8.自动装箱 和 自动拆箱：
8.1 自动装箱
在JDK1.5之后，支持“自动装箱”。
自动装箱：将基本数据类型数据自动转换为包装类类型 (引用数据类型)。
//自动装箱 //100基本数据类型 //int类型数据 - 自动转换为 -> Integer(包装类) Integer x = 100; //等于同于: Integer x =new Integer(100);
8.2 自动拆箱
在JDK1.5之后，支持“自动拆箱”。
自动拆箱：将包装类类型 (引用数据类型) 自动转换为基本数据类型数据。
当进行算术运算符、赋值运算符等操作时 ，会“自动拆箱”。
例子如：
//自动装箱 Integer x = 1000; Integer y = 1000; Object obj = new Object(); int a; /** 当进行“算术运算符、赋值运算符等”操作时，会”自动拆箱“ 算术运算符 : + - * / % ++ - - 赋值运算符等 : = += -= *= /= %= */ //自动拆箱 System.out.println(x + 1); System.out.println(x - 1); System.out.println(x * 1); System.out.println(x / 1); System.out.println(x % 1); System.out.println(x++); System.out.println(x--); System.out.println(a=x); System.out.println(a+=x); System.out.println(a-=x); System.out.println(a*=x); System.out.println(a/=x); System.out.println(a%=x); //会报错,因为“引用数据类型”无法赋值给“基本数据类型” (上面就不会报错，因为会“自动拆箱”) System.out.println(a=obj);当进行 “= =运算符” 等操作时 ，不会“自动拆箱”。（==运算符不会触发自动拆箱机制）
例子如：
//自动装箱 Integer x = 128; Integer y = 128; //进行 ==运算符 操作时，不会自动拆箱 /* 当比较基本数据类型时，==比较的是“值”。 当比较引用数据类型时，==比较的是“内存地址”。 */ //两个Integer对象都需要new，内存地址自然是不一样的 System.out.println(x==y); //false /** * * Java中为了提高程序的执行效率,将[-127到128]之间的所有“包装类对象”提前创建好， * 放到了一个“方法区”的“整数型常量池”中了，目的是只要用这个区间的数字不需要再去new * 对象了，直接从“整数型常量池中”取出来。 * * x变量中保存的对象的内存地址和y变量中的保存的对象的内存地址是一样的。 * 所以 x==y 为true */ Integer a =127; Integer b =127; System.out.println(a==b);//true (两个引用都指向同一个对象，内存地址相同)有了“自动拆箱”之后，Number中的方法(拆箱方法)就用不上了，因为不再需要手动拆箱。
9.String int Integer 类型互换
String s1 = "100"; // String 转换为 int int i1 = Integer.parseInt(s1); //100 System.out.println(i1 + 1); // 101 // int 转换为 String String s2 = i1 + ""; //"101"字符串 System.out.println(s2 + 1); //字符串拼接: "1011" // int 转换为 Integer //自动装箱 Integer x = 1000; // Integer 转换为 int //自动拆箱 int y = x; // String 转换为 Integer Integer k = Integer.valueOf("123"); // Integer 转换为 String String e = String.valueOf(k);