Java中的包装类

1.java中为8中基本数据类型又对应准备了8种包装类型。8种包装类型属于引用数据类型，父类是Object

 2.思考：为什么要再提供8种包装类呢？

   因为8种基本数据类型不够用，所以SUN公司又提供对应的8种包装类型

 public class IntegerTest01{

    //入口

   public static void main(String[] args){

      //有没有这种需求：调用doSome()方法的时候需要传一个数字进去

     //但是数字属于基本数据类型，而doSome()方法参数的类型是Object

     //可见doSome()方法无法接收基本数据类型的数字。那怎么办？可以传一个数字对应的包装类进去

    doSome();

  

    //把100这个数字经过构造方法包装成对象

   MyInt myInt = new MyInt(100);

   //doSome()方法虽然不能直接传100，但是可以传一个100对应的包装类型

   doSome(myInt);

   }

   public static void doSome(Object obj){

     //System.out.println(obj);

     System.out.println(obj.toString());

   }

 }

 //这种包装类是自已写的，实际开发中不需要自已写

 //8种基本数据类型对应的8种包装类，SUN公司以及写好了，我们直接用

public class MyInt{

   int value;

   public MyInt(){

   }

   public MyInt(int value){

     this.value=value;

   }

   public String toString(){

     return String.valueOf(value);

    }

}

 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.8中包装类中其中6个都是数字对应的包装类，他们的父类都是Number,可以先研究一下Number中公共的方法

  Number是一个抽象类，无法实例化对象

Number中有这样的方法：

 byte byteValue() 以byte形式返回指点的数值

 abstract double doubleValue()以double形式返回指定的数值

 abstract float floatValue()以float形式返回指定的数值

 abstract int intValue()以int形式返回指定的数值

 abstract long LongValue()以Long形式返回指定的数值

 short shortValue()以short形式返回指定的数值

这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的。

 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

    }

 }

在Java5之后，引入了一种新特性，自动装箱和自动拆箱

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

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

有了自动拆箱之后，Number类中的方法就用不着了

自动装箱和自动拆箱的好处？

  方便编程

 public class IntegerTest05{

  public static void main(String[] args){

     //900是基本数据类型

    //x是包装类型

   //基本数据类型  自动转换   包装类型  ：自动装箱

  Integer x = 900;

  System.out.println(x);

  //x是包装类型

  //y是基本数据类型

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

  int y=x;

  System.out.println(y);

 //z是一个引用，z是一个变量，z还是保存了一个对象的内存地址

 Integer z = 1000; //等同于：Integer z = new Integer(1000)

  //分析为什么没有报错呢？

 //+两边要求是基本数据类型的数字，z是包装类，不属于基本数据类型，这里会进行自动拆箱，将z转换成基本数据类型

 //在Java5之前这样写编译器会报错

 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

 }

}

经典异常

  空指针异常：NullPointerException

  类型转换异常：ClassCastException

  数组下标越界异常：ArrayIndexOutOfBoundsException

  数字格式化异常：NumberFormatException

Integer类当中有哪些常用的方法呢？

 public class IntegerTest07{

   public static void main(String[] args){

    //手动装箱

   Integer x = new Integer(1000);

  //手动拆箱

 int y=x.intValue();

 System.out.println(y);

   Integer a = new Integer("123");

  //编译的时候没有问题，一切符合java语法，运行时会不会出问题呢？

  //不是一个“数字”可以包装成Integer吗？不能，运行时，会出现异常

  //java.lang.NumberFormatException

 // Integer a = new Integer("中文");

 //重点方法

//static int parseInt(String s)

//静态方法，传参String，返回int

//网页上文本框中输入的100实际上是”100“字符串。后台数据库中要求存储100数字，此时java程序需要将”100“转换成100数字

    int retValue = Integer.parseInt("123"); //String 转换成 int

  //int retValue = integer.parseInt("中文"); //NumberFormatException

    System.out.println(retValue+100);

 

  //类比

  double retValue2 = Double.parseDouble("3.14");

  System.out.println(retValue2+1); // 4.14000000001(精度问题）

  float retValue3 = Float.parseFloat("1.0");

  System.out.println(retValue3+1); //2.0

 }

} 

//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"

//十六进制：1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a

hexString = Integer.toHexString(17);

System.out.println(hexString); "11"

//static String toOctaLString(int i)

//静态的：将十进制转换成八进制字符串

 String octalString = Integer.toOctaLString(8);

 System.out.println(octalString); //"10"

//value方法作为了解

//static Integer valueOf(int i)

//静态的：int-->Integer

Integer i1 = Integer.valueOf(100);

System.out.println(i1);

//static Integer valueOf(String s)

//静态的：String-->Integer

Integer i2 = Integer.valueOf("100");

System.out.println(i2);

String int Integer之间的互相转换

  public class IntegerTest08{

    public static void main(String[] args){

      //String-->int

      int i1 = Integer.parseInt("100");  //i1是100数字

      System.out.println(i1+1);//101

     

     //int -->String

    String s2 = i1 +"";  //"100"字符串

    System.out.println(s2+1); //"1001"

  

   //int-->Integer

   //自动装箱

  Integer x = 1000;

 //Integer -->int

 //自动装箱

 int y=x;

 //String --> Integer

 Integer k = Integer.valueOf("123");

 //Integer --> String

 String e = String.valueof(k);

 }

}