Java學習第十天

1：包裝類：
　　byte 　　　　 Byte
　　short 　　　　Short
　　int 　　　　　 nteger
　　long 　　　　  Long
　　char 　　　　  Character
　　boolean 　　　Boolean
　　double 　　　  Double
　　float 　　　　  Float

2.基本類型轉成字元串類型
　　String.valueOf()
　　String ss =Integer.toString(7)
　　String str=Double.toString(6.6)

3字元串類型轉成基本類型：常用
　　int a = Integer.parseInt("88");
　　double d=Double.parseDouble("99.99");

4.十進位轉成其它進位

　　String num = Integer.toHexString(60);
　　String n =Integer.toOctalString(24);
　　String m = Integer.toBinaryString(6);

5.其它進位轉十進位
　　int x = Integer.parseInt("3c",16); //第一個參數是被轉的數，第二個參數說明第一個參數的進位
　　int x = Integer.parseInt("30",8);
　　int x = Integer.parseInt("110",2);

6: 裝箱和拆箱
　　

 1 Integer tt=6;// new Integer(6) ---自動裝箱
 2 　　tt=tt+2;// tt.intValue()---6 自動拆箱 6+2==8 new Integer(8) 自動裝箱
 3 
 4 
 5 　　Integer m=127;
 6 　　Integer n=127;
 7 
 8 　　sop(m==n);//true jdb1.5開始
 9 
10 　　m=128;
11 　　n=128;
12 
13 　　sop(m==n);//false
14 　　//如果一個數在byte的範圍之內(-128---127)，之前已經定義過，再定義時使用已經定義的

7：異常:程式在運行過程中出現的特殊情況，
　　Java把程式在運行時出現的不正常情況，提取屬性和行為描述(異常名稱，異常發生的位置，異常具體信息)
　　從而出現了異常，從而實現了異常的面向對象

8.異常體系: (繼承Object類)Throwable
　　　　　　　　(Throwable的子類)--| Error：嚴重的錯誤，沒辦法處理的
　　　　　　　　(Throwable的子類)--| Exception:異常,程式運行時可處理的問題
9.異常特點：具備可拋性

　　預設的異常處理方式：系統創建異常類對象，因為main方法不能處理異常，拋給了JVM，JVM調用異常類對象的printStackTrace()方法，
　　輸出異常名，異常信息，異常發生的位置，然後程式中斷

　　try{

　　}catch(Exception e){
　　}

　　throws聲明可能會出現的異常
　　必須處理：1：使用 try{}catch(){} 2:使用throws繼續聲明拋出

10.多重異常：

1 try{
2 
3 }catch(XXX e){
4 
5 }catch(YYY ee){
6 
7 }

　　子類異常要寫在父類異常的上邊

11.自定義異常：

1 class MyException extends Exception{
2 
3 MyException(){}
4 
5 MyException（String message）
6 {
7 super(message);
8 }
9 }

　　對於自定義異常，系統不會自動創建異常類對象，所以需要使用throw 手動創建異常類對象

12.throw:用於手動拋出異常類對象
　　用了throw，必須處理，處理方式有2種：
　　　　1.使用try{}catch{}
　　　　2:使用throws繼續聲明拋出

13.throw和throws對比：
　　1.throw用在方法內部，throws用在方法後邊
　　2.throw後邊是異常類對象，throws後邊是異常類

14.java把異常分為兩類：
　　非運行時異常：編譯時檢測的異常，必須接收處理
　　運行時異常：編譯時不檢測的異常-------RuntimeException及其子類，編譯不檢測，即使使用了throws或throw，不處理，編譯照樣通過
　　　　　　原因：java認為出現運行時異常，程式就該中斷，不該處理
　　　　　　　　　運行時異常都是因為數據傳送出錯造成的，程式就該中斷，修改錯誤數據，然後再執行

 1 例子：
 2 class MyMath
 3 {
 4 　　public int div(int a,int b)
 5 　　{
 6 　　　　return a/b;// throw new ArithmeticException()
 7 　　}
 8 }
 9 class Demo5 
10 {
11 　　public static void main(String[] args) //不用try{}catch(){} 可以，只不過是程式異常時會中斷
12 　　{
13 　　　　MyMath myMath=new MyMath();
14 　　　　//檢測異常
15 　　　　try
16 　　　　{
17 　　　　　　int m = myMath.div(5,0); //new ArithmeticException()
18 　　　　　　System.out.println(m); //不執行
19 
20 　　　　}catch(Exception e)//捕獲 Exception e=new ArithmeticException() 多態
21 　　　　{
22 　　　　　　System.out.println(e.getMessage());//異常信息
23 　　　　　　System.out.println(e.toString());//異常類名：異常信息
24 　　　　　　e.printStackTrace(); //異常類名：異常信息 異常發生的位置
25 
26 　　　　　　System.out.println("除數為0了");
27 　　　　}
28 　　　　System.out.println("hehe")    
29 　　}
30 }

　　註意：對於程式來說，最好把問題提前到編譯時期，也就是說運行時可能發生的異常，在編譯時期就能知道

15.finally中的代碼在return之前執行的

 1 System.exit()退出JVM虛擬機，finally中的代碼不能執行
 2 
 3 try{}catch(){}
 4 
 5 try{}catch(){}finally{}
 6 
 7 try{}finally{必須執行的語句}
 8 
 9 特殊情況：
10 class MyMath
11 {
12 　　public int div(int a,int b)
13 　　{
14 　　return a/b;
15 　　}
16 }
17 class Demo11 
18 {
19 　　public static void main(String[] args)
20 　　{
21 　　　　MyMath myMath=new MyMath();
22 
23 　　try{
24 
25 　　　　int m = myMath.div(5,0); 
26 　　　　System.out.println(m);
27 
28 　　}catch(Exception e)
29 　　{
30　　 　　System.out.println(e.getMessage());
31 　　　　//return;
32 　　　　System.exit(1);//退出JVM finally中的代碼不能執行
33 　　}finally
34 　　{
35 　　　　System.out.println("哈哈");//finally中的代碼在return之前執行
36 　　}
37 　　}
38 }