內部類和例外

內部類

在一個類的內部定義的一個類，例如，A類中定義了一個B類，則B類相對于A類就是內部類，而A類相對于B類就是外部類

1. 成員內部類
2. 靜態內部類
3. 區域內部類
4. 匿名內部類

成員內部類

public class outer {
    private int ID;
    public void out(){
        System.out.println("外部類方法");
    }
    public class inner{
        public void in(){
            System.out.println("內部類方法");
        }
        public void getId(){
            System.out.println(ID);    //內部類可以獲得外部類的私有屬性，但是外部類使用內部類要借助內部類的物件
        }
    }
}

這就是一個類中定義一個內部類，可以通過實體化這個外部類來實體化內部類

outer o = new outer();
outer.inner o2 = o.new inner();
o2.in();
o2.getId();

靜態內部類

上述inner類的定義中直接改為 public static inner即為靜態內部類，靜態內部類無法訪問外部非靜態屬性（static會先加載）

一個java類中可以有多個class類，但是這個public class之外不能再寫public class

public void method(){
    class inner1{
        //區域內部類
        public void in(){
            
        }
    }
}

匿名內部類（甚至匿名內部介面）

public class internalClass {
    public static void main(String[] args) {
        outer o = new outer();
        outer.inner o2 = o.new inner();
        o2.in();

        new Apple().show();
        UserService use = new UserService(){
            @Override
            public void hello(){
                System.out.println("hello");
            }
        };
    }
}


class Apple{
    public void show(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

這些都是非常見的用法，記錄下來，這樣用方便在于可以直接呼叫匿名內部類的方法

例外

例外和中斷等具體將會寫在”作業系統部分“

一般需要掌握以下三種型別的例外：

• 檢查型例外：最具代表性的是用戶錯誤或問題引起的例外，例如打開一個不存在的檔案等
• 運行時例外：該類例外可能會在編譯時被忽略
• 錯誤ERROR：錯誤不是例外，是脫離程式員控制的問題，例如：堆疊溢位等等

java.lang.Throwable為所有例外的超類

例外總的分為兩大類：錯誤Error和例外Exception

Error類物件由JVM生成并拋出，大多數錯誤與代碼撰寫者執行的操作無關，當運行錯誤時，JVM不再有繼續操作所需要的記憶體資源，將會發生OutOfMemoryError，這些例外發生時，JVM一般會選擇終止執行緒；

Error是程式無法控制和處理的，而Exception通常情況下是可以被程式處理的

捕獲和拋出例外

簡單地說，例外總是先被拋出，后被捕捉的，

例外處理5個關鍵字：try, catch, finally, throw, throws

int a = 1;
int b = 0;

//try 監控區域
try{
    System.out.println(a/b);
}catch (ArithmeticException e ){    //捕獲例外，若堆疊溢位的話，該類例外捕獲不到，型別不同
    System.out.println("發生例外，變數b不能為0");
}finally {    //一般處理善后作業
    System.exit(0);
}

//finally可以不要，但是在IO中，有些資源需要關閉，一般可以放在finally中處理

以上為捕獲例外的一個例子，若ArithmeticException e改為Throwable e，則均可被捕獲，可寫多個catch，相當于多個if進行判斷，catch中所寫的例外型別要從小到大來捕獲，否則會報錯

選中sout(a/b); IDEA中 ctrl+alt+T 可自動補寫 try catch finally等

try {
    System.out.println(a/b);
} catch (Exception e) {
    e.printStackTrace();  //列印錯誤的堆疊資訊
} finally {
}

以上為IDEA自動補寫部分

主動拋出例外，用到throw，一般在方法中使用

public static void main(String[] args) {
    int a = 1;
    int b = 0;
    new exceptiondemo2().test(1,0);
}

public void test(int a,int b){
    if(b==0){
            throw new ArithmeticException();
        }
}

方法上主動拋出例外，則用throws

public void test(int a,int b)throws ArithmeticException{
    
}

自定義例外類可寫一個類繼承于Exception，可重寫列印資訊方法.toString

public void doA(int a) throws Exception1,Exception3{......}

throws E1,E2,E3只是告訴程式這個方法可能會拋出這些例外，方法的呼叫者可能要處理這些例外，而這些例外E1，E2，E3可能是該方法產生的，throws只是告知該方法可能會產生的例外，而throw則會在具體陳述句拋出例外

void doA(int a) throws Exception1,Exception2,Exception3{
           try{
                 ......

           }catch(Exception1 e){
              throw e;
           }catch(Exception2 e){
              System.out.println("出錯了！");
           }
           if(a!=b)
              throw new  Exception3("自定義例外");
}

該段共可能出現3種例外，E1出現時，先catch后throw，而E2出現時只進行了捕獲，后續沒有拋出E2，if為自定義的判斷，

throws表示出現例外的一種可能性，并不一定會發生這些例外；throw則是拋出了例外，執行throw則一定拋出了某種例外，

以上僅為內部類和例外的知識總結，不夠詳細，未涉及的部分可能會在未來補充，

標籤：Java

上一篇：go time/rate 介面-賬戶/IP 限流

下一篇：HashMap底層原理分析