Java 封裝類

標籤：for   裝箱   parse   bsp   傳遞參數   種類型   通過   最小   階段   

先說說為什麼會出現封裝類呢？java是一門物件導向的程式設計語言，基本類型並不具有對象的性質，雖然java可以直接處理基本類型，但有時候需要將其作為對象來處理，這就需要將基本類型改為封裝類型。

Java中八種基礎資料型別 (Elementary Data Type)對應的封裝類型。

基礎資料型別 (Elementary Data Type)      封裝類型

byte                    java.lang.Byte

short                   java.lang.Short

int                       java.lang.Integer

long                    java.lang.Long

 

float                    java.lang.Float

double                java.lang.Double

 

boolean              java.lang.Boolean

 

char                   java.lang.Character

先來看看封裝類的繼承關係，如：

 

結合以下代碼來看為什麼Java中會出現封裝類型。

 

//需求：規定m1方法可以接受Java中的任何一種資料類型
public class IntegerTest01{
 public static void  m1(Object o){   
   System.out.println(o);
 }
 public static void main(String[] args){
   //基礎資料型別 (Elementary Data Type)
   byte b=10;
   //引用資料類型
   Byte b1=new Byte(b);
   m1(b1);   //10  Byte已經將Object中的toString方法重寫
 }
}

 

以上代碼定義了一個m1()方法，它的參數類型為Object類，是引用資料類型，m1方法如果想接受byte類型的資料，（byte類型的資料是基礎資料型別 (Elementary Data Type)），可以先將byte類型的資料封裝成java.lang.Byte,再傳遞參數。

 

下面以java.lang.Integer;類型為例，講解八種類型，也就是說這八種類型的方法是通用的。

 

public class IntegerTest02{
 public static void main(String[] args){
   //擷取int類型的最大值和最小值
   System.out.println("int類型的最大值是: "+Integer.MAX_VALUE);
   System.out.println("int類型的最大值是："+Integer.MIN_VALUE);
   //以int推byte
   System.out.println("byte類型的最大值是："+Byte.MAX_VALUE);
   System.out.println("byte類型的最大值是："+Byte.MIN_VALUE);
   //建立integer類型的對象
   Integer i1=new Integer(10);   //將int類型轉換為Integer類型
   Integer i2=new Integer("123");  //將字串類型轉換為Integer類型  （雖然可以將字串類型轉換為Integer類型，但該字串也必須是數字）
    Integer i3=new Integer("abc");    //編譯通過，運行時報異常：NumberFormatException
    System.out.println(i1);
   System.out.println(i2);
 }
}

 

再來看看Integer中常用的方法。

/*
Integer中常用的方法
*/
public class IntegerTest03{
 public static void main(String[] args){
   Integer i1=new Integer(10);  //int類型轉換為Integer類型  基礎資料型別 (Elementary Data Type)轉換為引用資料類型
    System.out.println(i1);     //10
   int i2=i1.intValue();        //Integer類型轉換為int類型
   System.out.println(i2);     //10
   
   //static int parseInt(String s)  String類型轉換為int類型
   int i3=Integer.parseInt("123");
   System.out.println(i3+1);    //124
   //int i4=Integer.parseInt("abc");   //報錯：java.lang.NumberFormatException，String類型轉換為字串，這個字串必須為數字字串
    //System.out.println(i4);
   //static double parseDouble(String s) 
       //String類型轉換為double類型    
   double i5=Double.parseDouble("2234.342");  
   System.out.println(i5+22.23);   //2256.572
   //將int類型的十進位轉換為二進位
   String s1=Integer.toBinaryString(10);   //1010
   System.out.println(s1);
   //將int類型的十進位轉換為八進位
   String s2=Integer.toOctalString(10);    //12
   System.out.println(s2);
   //將int類型的十進位轉換為十六進位
   String s3=Integer.toHexString(10);      //a
   System.out.println(s3);    
   //int--->Integer
   Integer s4=Integer.valueOf(10);
   System.out.println(s4);              //10
   //String--->Integer
   Integer s5=Integer.valueOf("10");
   System.out.println(s5);             //10
 }
}

 

Integer，int，String三種類型相互轉換。

/*
Integer
int 
String
三種類型相互轉換
*/
public class IntegerTest04{
 public static void main(String[] args){
   //int-->Integer
   Integer i1=Integer.valueOf(10);    
   System.out.println(i1);               //10
   //Integer-->int
   int i2=i1.intValue();
   System.out.println(i2);              //10
   //String-->Integer
   Integer i3=Integer.valueOf("21131");
   System.out.println(i3);                //21131
   //Integer-->String
   String i6=Integer.toString(i3);   
   System.out.println(i6);                 //211131
   String i4=i3.toString();
   System.out.println(i4);                //21131
   //String-->int
   int i8=Integer.parseInt("23");
   System.out.println(i8);             //23
   //int-->String
   String i7=10+"";
 }
}

 

有了上面內容的基礎，我們就可以來瞭解一下什麼叫自動拆箱和自動裝箱了。

1.自動裝箱和自動拆箱是程式編譯階段的一個概念，和程式運行無關

2.自動裝箱和自動拆箱的主要目的是方便程式員的調用

 

public class IntegerTest05{
 public static void main(String[] args){
   //JDK5.0之前的版本
   Integer i1=new Integer(10);    //int-->Integer
   int i2=i1.intValue();      //Integer-->int
   //自動裝箱
   Integer i3=10;
   //自動拆箱
   int i4=i3;
   m1(10);       //自動裝箱
 }
 public static void m1(Object o){
   System.out.println(o);
 }
 
}

 

結合以下代碼深入講解一下自動拆箱和自動裝箱。

 

public class IntegerTest06{
 public static void main(String[] args){
   Integer i1=new Integer(10);
   Integer i2=new Integer(10);
   //這裡不會有自動拆箱
   System.out.println(i1==i2);    //false
   //比較兩個Integer類型的資料是否相等，不能用==
   //Integer已經重寫了Object中的toString方法
   System.out.println(i1.equals(i2));   //true
   //注意以下程式
   //如果資料在[-128~127]之間，Java中引入了一個“整型常量池”，在方法區中。
   //該整型常量池只儲存-128~127之間的資料。
   Integer i3=128;
   Integer i4=128;
   //上面的等同於
   //Integer i3=new Integer(128);
   //Integer i4=new Integer(128);
   System.out.println(i3==i4);    //false
   String s1="abc";
   String s2="abc";
   System.out.println(s1==s2);    //true
         Integer i5=127;      //這個程式不會在堆中建立對象，會直接在整型常量池中拿
                Integer i6=127;
               System.out.println(i5==i6);    //true
   Integer i7=-128;
   Integer i8=-128;
   System.out.println(i7==i8);     //true
   Integer i9=-129;
   Integer i10=-129;
   System.out.println(i9==i10);     //false
   }
}

 

Integer i1=new Integer(10);

Integer i2=new Integer(10);

System.out.println(i1==i2);

這裡要注意i1和i2為Integer類型，沒有自動拆箱，因此比較兩個Integer類型的資料是否相等，不能用== ，跟之前講String類型的比較方法是一致的，需要用equals()方法。接下來敲黑板了，如果資料在[-128~127]之間，Java中引入了一個“整型常量池”，在方法區中，該整型常量池只儲存-128~127之間的資料。這就是為什麼Integer i5=127;Integer i6=127;（這兩句等同於Integer i5=new Integer(127);Integer i6=new Integer(127);）System.out.println(i5==i6); 結果為true，而Integer i3=128;Integer i4=128; System.out.println(i3==i4); 結果為false了。相當於前者用“==”比較的是字串，而後者比較的是記憶體位址。

 

Java 封裝類