Javase | 包装类

目录:

    • 1.包装类
      • 1.1 包装类
      • 1.2 包装类的分类
    • 2.思考:为什么要提供8种包装类型?
    • 3.通过访问包装类的常量,获取“最大值”和最小值
    • 4.装箱 和 拆箱:
      • 4.1 装箱
      • 4.2 拆箱
    • 5.Number类:
      • 5.1 Number类的构造方法
      • 5.2 Number类中的方法
    • 6.Integer类
      • 6.1 Integer类构造方法
      • 6.2 Integer类常用方法
        • int intValue( )
        • int parseInt( String s )
        • String toBinaryString( int i )
        • String toHexString( int i )
        • String toOctalString( int i )
        • Integer valueOf( int i )
        • Integer valueOf( String s )
    • 7.Double类的构造方法
      • 7.1 Double类的构造方法
    • 8.自动装箱 和 自动拆箱:
      • 8.1 自动装箱
      • 8.2 自动拆箱
    • 9.String int Integer 类型互换

1.包装类

1.1 包装类

  • Java中为8种 基本数据类型又对应准备了8种包装类型
  • 包装类属于 引用数据类型
  • 包装类中有六个都是数字对应的包装类,他们父类都是 Number

1.2 包装类的分类

  1. byte类型对应的包装类Byte (父类是Number)

  2. short类型对应的包装类Short (父类是Number)

  3. int类型对应的包装类Integer (父类是Number)

  4. long类型对应的包装类Long (父类是Number)

  5. float类型对应的包装类Float (父类是Number)

  6. double类型对应的包装类Double (父类是Number)

  7. boolean类型对应的包装类Boolean (父类是Number)

  8. 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()方法
         @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 类型互换

Javase | 包装类_第1张图片

       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);

你可能感兴趣的:(Java知识点-整合,开发语言,Java,包装类,Integer,Double,Float,Long)