Java從菜鳥到精通（7）

Object類和equals類
Object：是所有對象的直接後者間接父類，傳說中

的上帝。

該類中定義的肯定是所有對象都具備的功能。
Object類中已經提供了對對象是否相同的比較方法

。
如果自訂類中也有比較相同的功能，沒有必要重

新定義。
只要沿襲父類中的功能，建立自己特有的比較內容

即可，這就是覆蓋。

內部類：
將一個類定義在另一個類的裡面，對裡面那個類就

成為內部類（內建類，嵌套類）。
訪問特點：
    1、內部類可以直接存取外部類中的成員

，包括私人成員。
之所以直接存取外部類中的成員，是因為內部類中

持有了一個外部類的引用，格式：外部類名.this
    2、而外部類要訪問內部類中的成員必須

要建立內部類的對象。

訪問格式：
1、當內部類定義在外部類的成員位置上，而且非

私人，可以再外部其他類中，可以直接建立內部類

。
格式：
外部類名.內部類名 變數名=外部類對象.內部類對

象;
2、當內部類在成員位置上，就可以被成員修飾符

所修飾。
  比如，private：將內部類再外部類中進行封裝

。
        static：內部類就具備static的特性。
    當內部類被static修飾後，只能直接存取

外部類中的static成員，出現了訪問局限。

    在外部其它類中，如何直接訪static內部

類的非靜態成員呢？
    new 類名().靜態內部類名()；
    在外部其它類中，如何直接訪static內部

類的靜態成員呢？
    外部類.靜態內部類.靜態方法

注意：當內部類中定義了靜態成員，該內部類必須

是static的
      當外部類中的靜態方法訪問內部類時，內部

類也必須是靜態。

當描述事物時，事物的內部還有事物，該事物用內

部類來描述。因為內部事物在使用外部事物的內容

。

 
內部類定義在局部時：
1.不可以被成員修飾符修飾；
2.可以直接存取外部類中的成員，因為還持有外部

類中的引用。但是不可以訪問它所在的局部中的變

量。只能訪問被final修飾的局部變數。

匿名內部類：
1、匿名內部類其實就是內部類的簡寫格式。
2、定義匿名內部類的前提：
    內部類必須是繼承一個類或者實現介面。
3、匿名內部類的格式  new 父類或者介面（）括

號指建構函式{定義子類的內容}
4、其實匿名內部類就是一個匿名子類對象。而且

這個對象有點胖：可以理解為帶內容的對象。
5、匿名內部類中定義的方法最好不要超過3個。

異常：
異常的體系
1、Throwable
    1.Error
    *通常出現重大問題：如啟動並執行類不存在

或者記憶體溢出。
    *不編寫針對代碼對其處理。
    2.Exception
    *在運行時運行出現異常的情況，可以通

過try catch finally
2、Exception和Error的子類名都是以父類名作為

尾碼。

異常：就是程式在運行時出現不正常情況。
異常由來：問題也是現實生活中一個具體的事物。

也可以通過Java的類的形式進行描述，並封裝成對

象。其實就是Java對不正常情況進行描述後的對象

體現。

對於問題的劃分：分為兩種、一種是嚴重的問題，

一種是非嚴重問題。
對於嚴重的：java語言通過Error類進行描述。
     對於Error一般不編寫針對性的代碼對其進行

處理、
對於非嚴重的：java通過Exception類進行描述、
     對於Exception可以使用針對性的處理方式進

行處理。

無論Error或者Exception都具有一些共性內容。

Throwable
  | Error
  | Exception

2、異常的處理：
java提供了特有的語句進行處理
try{
   //需要被檢測得代碼
}catch（異常類 變數）{
   //處理異常的代碼（處理方式）
}finelly{
   //一定會執行語句
}
 
3、對捕獲到得異常對象進行常見方法操作。
 String getMessage(); 擷取異常資訊。
 toString();  異常名稱：異常資訊
 printStackTrace(); 異常名稱，異常資訊，異常

出現的位置

其實 JVM預設的異常處理機制，就是調用

printStackTrace方法。列印異常的堆棧的跟蹤信

息。

方法() thows Exception //在功能上通過Throws

的關鍵字聲明了該功能有可能出現的問題。

在函數上聲明異常。
便於提高安全性，讓調用者進行處理，不處理編譯

失敗。

對多異常的處理。

1.聲明異常時，建議聲明更為具體的異常，這樣處

理的可以更具體。
2.對方聲明幾個異常，就對應幾個catch塊。不要

定義多餘的catch塊。
如果多個catch塊中的異常出現繼承關係，父類異

常catch塊放在最下面。

建立在進行catch處理時，catch中一定要定義具體

處理方式。
不要簡單定義一句 e.printStackTrce();
也不要簡單的就書寫一條輸出語句。

用檔案記錄下來異常資訊，這個檔案叫做異常日誌

。

因為項目中會出現特有的問題。
而這些問題並未被java所描述並封裝對象。
多以對於這些特有的問題可以按照java的對象問題

封裝的思想。將特有的問題，進行自訂的異常封

裝。

自訂異常。

需求：在本程式中，對於除數是-1，也視為是錯誤

的是無法進行運算的。那麼就需要對這個問題進行

自訂的描述。

當在函數內部出現了throw 拋出異常對象，那麼就

必須要給出對應的處理動作。
要麼在內部try catch處理。
要麼在函數上聲明讓調用者處理。

一般情況在，函數內出現異常，函數上需要聲明。

發現列印的結果中只有異常的名稱，卻沒有異常的

資訊。
因為自訂的異常並未定義資訊。

如何定義異常資訊呢？
因為父類中已經把異常資訊的操作都完成了。
所以子類只要在構造時，將異常資訊傳遞給父類調

用過Super語句。那麼就可以直接通過getMessage

方法擷取自訂的異常資訊。

自訂異常：
必須是自訂類繼承Exception。

為什麼要繼承Exception？
異常體系有一個特點，因為異常類和異常對象都會

被拋出，他們都具備可拋性，這個可拋性是

Throwable這個體系中專屬特點。
只有這個體系中的類和對象才可以被throws和

throw操作。

throws  和 throw 區別
1、throws 使用在函數上；throw使用在函數內
2、throws 後面跟的是異常類，可以跟多個，用逗

號隔開；throw後面跟的是異常對象。

class MyException extends Exception
{
 /*
 private  String msg;
 MyException(String msg){
    this.msg=msg;
}
//重寫getMessage
public String getMessage(){
 return msg;
}
*/

 private int value;
 MyException(){
    super();
}
 MyException(String msg,int value){
    super(msg);
    this.value=value;
}
public int getValue(){
    this.value=value;
}

}

class Demo{
   int div(int a,int b) throws MyException
   {
    if(b<0)
    throw new MyException("出現了除數是

負數的情況 ",b);//手動通過throw關鍵字拋出一

個自訂異常對象。        return a/b;
    }
}

class ExceptionDemo{

    public static void main(String[]

args){
        Demo d=new Demo();
        
        try{
            int x=d.div(4,1);
    
        Syso("x="+x);
        }
        catch(MyException e){
        syso(e.toString());
        syso("XXXXXXXX"+e.getValue

());
    }
        syso("over");
    }
}
/*
class Throwable{
    private String message;
    Throwable(String message){
    this.message=message;
    }
    public String getMessage(){
    return message;
    }
}

class Exception extends Throwable{

    Exception(String message){
        super(message);
    }
}

*/

RuntimeException類
Exception中有一個特殊的子類異常

RuntimeException運行時異常。
如果在函數內容拋出異常，函數上可以不用聲明，

編譯一樣通過。
如果在函數上聲明了該異常，調用者可以不用進行

處理，編譯一樣通過。

注意：之所以不用在函數上聲明，是因為不需要讓

調用者處理。當該異常發生，希望程式停止。因為

在運行時，出現了無法繼續運算的情況，希望停止

成員後，對代碼進行修正。

自訂異常時：如果該異常的發生，無法在繼承進

行運算，就讓自訂異常繼承RuntimeException。

對於異常分兩種：
1.編譯時間被檢測的異常。

2.編譯時間不被檢測的異常（運行時異常，

RuntimeException以及子類）。

finally中存放的是一定會被執行的代碼。

第一個格式：try{} catch(){}
第二個格式：try{} catch(){}finally{}
第三個格式：try{}catch(){}finally{}

catch是處理異常的，如果沒有catch就代表異常沒

有被處理過，如果該異常時檢測時異常，那麼就必

須聲明。

異常在子父類覆蓋中的體現；
1.子類在覆蓋父類時，如果父類的方法拋出異常，

那麼子類的覆蓋方法，只能拋出父類的異常或者該

異常的子類。

2.如果父類方法拋出多個異常，那麼子類在覆蓋該

方法時，只能拋出父類異常的子集。
3.如果父類或者介面的方法中沒有異常拋出，那麼

子類在覆蓋方法時，也不可以拋出異常。如果子類

方法發生 了異常，就必須要進行try處理，絕對不

能拋。

*****總結***
異常：
是什嗎？
是對問題的描述，將問題進行對象的封裝。

異常體系
   Throwable
    |--Error
    |--Exception
        |--RuntimeException
異常體系的特點：
異常體系中的所有類以及建立的對象都具備可拋性

。也就是說可以被throw和throws關鍵字所操作。

只有異常體系具備這個特點。

throw和throws的用法：
throw定義在函數內，用於拋出異常對象；
throws定義在函數上，用於拋出異常類，可以拋出

多個用逗號隔開。

當函數內容有throw拋出異常對象，並未進行try處

理，必須要在函數上聲明，都在編譯失敗。
注意：RuntimeException除外。也就是說，函數內

如果拋出的RuntimeException異常，函數上可以不

用聲明。

如果函式宣告了異常，調用者需要進行處理。處理

方法可以throws可以try。

異常有兩種：
1、編譯時間被檢測異常
    該異常在編譯時間，如果沒有處理（沒有拋

也沒有try），編譯失敗。
    該異常被標識，代表這可以被處理。
2、運行時異常（編譯時間不檢測）
    在編譯時間，不需要處理，編譯器不檢查。
    該異常的發生，建議不處理，讓程式停止

。需要對代碼進行修正。

異常處理語句：
try{
需要被檢測的代碼
}catch{
處理異常的代碼
}finally{
一定會執行的代碼
}
第一個格式：try{} catch(){}
第二個格式：try{} catch(){}finally{}
第三個格式：try{}catch(){}finally{}

注意：
1.finally中定義的通常是關閉資原始碼，因為資

源必須要釋放。

2.finally只有一種情況不會被執行，當執行到

system.exit(0)的時候，finally不會被執行。

只有下面的條件達到了，finally語句塊裡的代碼

不能被讀到：在catch裡面寫System.exit(0)（系

統退出(JVM結束)）時finally裡面的不能被讀到。

自訂異常：
    定義類繼承Exception或者

RuntimeException
    1.是為了讓該自訂類具備可拋性。
    2.讓該類具備各操作異常的共性方法。
    
    當要定義自訂異常的資訊時，可以使用

父類已經定義好的功能。
    異常資訊傳遞給父類的建構函式。
    class MyException extends Exception{
        MyException(String message){
        Super(message);
        }
    }

自訂異常：按照Java的物件導向思想，將程式中

出現的特有問題進行封裝。

異常的好處：
    1.將問題進行封裝
    2.將正常流程代碼和問題處理代碼相分離

，方便閱讀

異常的處理原則：
    1、處理方式有兩種：try或者throws
    2、調用到拋出異常的功能時，拋出幾個

，就處理幾個。
    一個try對應多個catch。
    3、多個catch，父類的catch放到最下面
    4、catch內，需要定義針對性的處理方式

，不要簡單的定義printStackTrace，輸出語句。

也不要不寫。
    當捕獲到得異常，本功能處理不了時，可

以繼續在catch中拋出。
    try{
    throw new MyException();
    }catch(MyException e)    {
    trow e;
    }
    如果該異常處理不了，但並不屬於該功能

出現的異常，可以將異常轉換後，在拋出和該功能

相關的異常。
    或者異常可以處理，當需要將異常產生的

和本功能相關的問題提供出去。當調用者知道，並

處理，也可以將捕獲異常處理後，轉換成新的異常

。
    try{
    throw new MyException();
    }catch(MyExceptin e)
    {
    //對MyException處理
    throw new BException();
    }
     比如：匯款的例子。

異常的注意事項：
    在子父類覆蓋時：
    1、子類拋出的異常必須是父類的異常的

子類或者子集。
    2、如果父類或者介面沒有異常拋出時，

子類覆蓋出現異常，只能try不能拋。