Javase | 包装类

- 1.包装类
- - 1.1 包装类
  - 1.2 包装类的分类
- 2.思考：为什么要提供8种包装类型？
- 3.通过访问包装类的常量，获取“最大值”和最小值
- 4.装箱和拆箱：
- - 4.1 装箱
  - 4.2 拆箱
- 5.Number类：
- - 5.1 Number类的构造方法
  - 5.2 Number类中的方法
- 6.Integer类、 Double类的构造方法
- - 6.1 Integer构造方法
  - 6.2 Double类的构造方法
- 7.自动装箱和自动拆箱：
- - 7.1 自动装箱
  - 7.2 自动拆箱

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)

（包装类为引用数据类型）

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()方法@Overridepublic String toString() {//返回对象中的数据,返回值类型为String类型return String.valueOf(value);}}

3.通过访问包装类的常量，获取“最大值”和最小值

通过访问包装类的常量，获取基本数据类型的“最大值”和最小值

   //通过访问“包装类的常量”，获取基本数据类型的“最大值”和“最小值”System.out.println("byte的最小值: "+Byte.MIN_VALUE); //-128System.out.println("byte的最大值: "+Byte.MAX_VALUE); //127System.out.println("short的最小值: "+Short.MIN_VALUE); //32768System.out.println("short的最大值: "+Short.MAX_VALUE); //32767System.out.println("int的最小值: "+Integer.MIN_VALUE); //-2147483648System.out.println("int的最大值: "+Integer.MAX_VALUE); //2147483647//-9223372036854775808System.out.println("long的最小值: "+Long.MIN_VALUE);//9223372036854775807System.out.println("long的最大值: "+Long.MAX_VALUE);System.out.println("float的最小值: "+Float.MIN_VALUE); //1.4E-45System.out.println("float的最大值: "+Float.MAX_VALUE); //3.4028235E38System.out.println("double的最小值: "+Double.MIN_VALUE); //4.9E-324//1.7976931348623157E308System.out.println("double的最大值: "+Double.MAX_VALUE);System.out.println(Boolean.FALSE); //falseSystem.out.println(Boolean.TRUE); //trueSystem.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类型” 对应的包装类:    ByteShort S = new Short(s);           //创建 “short类型” 对应的包装类:   ShortInteger I = new Integer(i);       //创建 “int类型” 对应的包装类:     IntegerLong L = new Long(l);             //创建 “long类型” 对应的包装类:    LongFloat F = new Float(f);           //创建 “float类型” 对应的包装类:   FloatDouble D = new Double(d);         //创建 “double类型” 对应的包装类:  DoubleBoolean BL = new Boolean(bl);     //创建 “boolean类型” 对应的包装类: BooleanCharacter C = new Character(c);   //创建 “char类型” 对应的包装类:    Character//输出包装类(引用数据类型)对象//包装类中重写了toString()方法,所以此处输出包装类中存储的"基本数据类型"数据System.out.println(B.toString()); //12System.out.println(S.toString()); //12System.out.println(I.toString()); //123System.out.println(L.toString()); //123System.out.println(F.toString()); //123.0System.out.println(D.toString()); //123.0System.out.println(BL.toString()); //trueSystem.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类、 Double类的构造方法

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

6.2 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

7.自动装箱和自动拆箱：

7.1 自动装箱

在JDK1.5之后，支持“自动装箱”。
自动装箱：将基本数据类型数据自动转换为包装类类型 (引用数据类型)。
   //自动装箱//100基本数据类型//int类型数据 - 自动转换为 -> Integer(包装类)Integer x = 100; //等于同于: Integer x =new Integer(100);

7.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 = 1000;Integer y = 1000;//进行 == 操作时，不会自动拆箱/*当比较基本数据类型时，==比较的是“值”。当比较引用数据类型时，==比较的是“内存地址”。此处打印输出false,表明其比较是“内存地址”,x和y内存地址不相同*/System.out.println(x==y); //false// 此时的 == 比较的是值，所以此处打印输出trueSystem.out.println(1000==1000); //true