Java - 例外と例外処理

Javaで例外的な出来事が起こることを、例外が投げられる（be thrown）と表現する。例外に対処して何かの実行をする責任を持つコードのことを「例外ハンドラ」という。例外ハンドラは、投げられた例外を「キャッチ」（catch）する。例外処理は、例外が起きたとき（0で割ったなど）、プログラムの実行を適切な例外ハンドラに転送することで機能する。特定の例外が発生した時、実行すべきコードをJVMにに伝えるためにtryキーワードとcatchキーワードを使う。tryキーワードは、例外が発生する可能性のあるコードブロック(保護領域)を定義するために使用。catchキーワードは、特定の例外(正確には例外クラス)をそれを処理する1つまたは複数のコードブロックに対応付ける働きをする。

try句には、例外が発生しそうなコードを書く。

catch句には、例外を処理するコードを書く。

try句とcatch句の間には関係ないコードを書かない。すなわち、連続で書く。

catch句は複数あってよい。catch句も複数ある場合は、連続して書く。

    try{
        //例外の投げそうなコードを書く
    }
    catch(例外クラス 変数名){
        //例外ハンドラ
        //例外を処理するコードを書く
    }
    catch(例外クラス 変数名){
        //例外ハンドラ
        //例外を処理するコードを書く
    }
    //危険のないコードを書く
    //この文は例外が発生しようがしなかろうが必ず実行される。

catch(例外クラス名オブジェクト変数名){ /*処理内容*/}

public class Test{
    public static void main(String[] args){
        int i = 10 ;
        int j = 0 ;
        try{
            System.out.println(i/j) ;
        }
        catch(ArithmeticException e){
            System.out.println("0で除算しました。") ;
            e.printStackTrace() ;
        }
    }
}

この例外は、RuntimeExceptionの例外であり、try-catch句を書かなくても、コンパイルできる。また、自動的にスタックトレースを実行時に表示してくれるので、例外の箇所の判別がわかりやすい。しかし、RuntimeExceptionクラス以外の場合は、try-catch句もしくは、throwsを使わない場合コンパイルできない。

import java.io.* ;

public class Test{
    public static void main(String[] args){
        FileReader file = new FileReader("sample.txt") ;
    }
}

この例はコンパイルできない。何故ならファイルがないことにより、FileNotFoundExceptionが生成される。これを対処するには、try-catch文で例外を投げて処理するしかない。次の例はコンパイルできる。

public class Test{
    public static void main(String[] args){
        try{
            FileReader file = new FileReader("sample.txt") ;
        }
        catch(FileNotFoundException e){
            System.out.println("例外が発生しました。") ;
            e.printStackTrace() ;
        }
    }
}

メソッド内に特定の例外に対するcatch句が無い場合、そのメソッドは例外を「かわす」。すなわち、他に責任転嫁する。かわされた例外は、呼び出し元のメソッドに行きコールスタックを辿っていく。main()メソッドでも例外をcatchできなかった場合、プログラムはクラッシュし、コールスタックがダンプする。

public class Test{
    public static void main(String[] args){
        Test t = new Test() ;
        t.methodA(t) ;
    }
    void methodA(Test s){
        s.methodB() ;
    }
    void methodB(){
        System.out.println(10/0) ;//①
    }
}

このコードを実行すると「スタックトレース」が表示される。①でランタイムエラーになり、methodB()は例外をかわす。methodA()も例外をかわし、最後にmain()メソッドに辿りつく。ここでも例外を処理できないので、スタックトレースがダンプする。次の例はmethodAで例外をキャッチする例。

public class Test{
    public static void main(String[] args){
        Test t = new Test() ;
        try{
            t.methodA(t) ;
        } catch (ArithmeticException e){
            System.out.println("0で除算しました") ;
        }
    }
    void methodA(Test s){
        s.methodB() ;
    }
    void methodB(){
        System.out.println(10/0) ;
    }
}

全ての例外はExceptionクラスを拡張するクラスのインスタンス。例外は常にjava.lang.Exceptionのサブクラスである。

例外が投げられると、Exceptionクラスの特定のサブクラスのオブジェクトがインスタンス化され、catch句の引数として例外ハンドラに渡される。

全ての例外はExceptionクラスのサブクラスであり、ExceptionクラスはThrowableクラスから派生しており、さらにThrowableクラスはObjectクラスから派生している。

Throwableクラスは「Error」と「Exception」の2つのサブクラスを派生している。

「Error」クラスから派生するクラスは、プログラムの実行中に何らかのトラブル(メモリー不足)によって起こる事態。

Javaでいう例外とは、「Throwable」クラスから派生したサブクラスに当てはまる例外のこと。当然「Error」クラスから派生するエラーに遭遇した場合、プログラマーは回避することはできない。

Exceptionクラスのサブクラス。特殊な例外である。

例外オブジェクトのprintStackTrace()メソッドを呼び出すと、例外が起こった時点でのスタックトレースが出力される。スタックトレースは上に向かい作成される。最も新しく呼び出されたメソッドが最上部にくる。printStackTrace()メソッドは、最も新しく呼び出されたメソッドを先頭に、その後下に向かって順に各メソッド名を出力する。これを「スタックの巻き戻し」という。

catch句で例外をcatchする場合、例外クラスを記述する。記述する例外クラスにサブクラスがない場合、そのクラスの例外だけがキャッチされる。仮に、サブクラスを持つ例外クラスを記述した場合は、サブクラスの例外もキャッチできる。

catch句に記述するクラスがたくさんのサブクラスを持っている場合、例外の詳細がわかりにくくなるのでオススメできない。例えば、「Exception」クラスを指定した場合、全ての例外をキャッチしてしまうので、何の例外が起きたのかわからなくなる。

例外が投げられると、Javaはその例外クラスに対応するcatch句をさがす。その例外クラス用のハンドラが見つからない場合は、その例外のスーパークラス用のハンドラをさがす。例外のスーパークラスに対するcatch句が見つからない場合は、コールスタックの下に向かって例外が伝達される。このプロセスを例外マッチングという。

catch句を複数書く場合は、例外のサブクラス(範囲の小さいもの)から順に書く。範囲の大きいものから書くと、コンパイルエラーになる。ちなみに階層が同じ場合は順序に決まりはない。

public class Test{
    public static void main(String[] args){
        Test t = new Test() ;
        try{
            t.methodA(t) ;
        } catch (ArithmeticException e){
            System.out.println("0で除算しました") ;
        } catch (RuntimeException e){
            System.out.println("例外が発生しました") ;
        } catch (Exception e){
            System.out.println("例外が発生しました") ;
        }
    }
    void methodA(Test s){
        s.methodB() ;
    }
    void methodB(){
        System.out.println(10/0) ;
    }
}

このコードは正しい。もし、catch句の順序を逆にするとコンパイルできなくなる。

メソッドが例外を投げる可能性がある場合は、例外を記述しなけらばならない。但し、RuntimeException内のサブクラスは書かなくても構わない。

メソッドが例外を投げる可能性がある場合は、例外を記述し呼び出し元に例外処理を委ねるか、その場でcatch句で例外を受け取る。メソッドが例外を投げた場合、必ずどこかで例外をキャッチし処理しなければならない。(処理か宣言か、キャッチか宣言か)

import java.io.* ;

public class Test{
    public static void main(String[] args){
        Test t = new Test() ;
        try{
            t.methodA(t) ;//①
        } catch (Exception e){
            //e.printStackTrace() ;
        }
    }
    void methodA(Test s) throws Exception{//②
        s.methodB() ;
    }
    void methodB() throws Exception{//③
        FileReader file = new FileReader("sample.txt") ;
    }
}

③で例外を投げる可能性があるので、メソッド内に記述し呼び出し元に処理を譲る。呼び出し元の②も例外を投げ②の呼び出し元に処理を委ねる。①で例外をキャッチし例外ハンドラで処理する。

チェック例外・・・コンパイル時にエラーの起きる例外。ファイルが開けないなど。この例外は必ず処理しないとコンパイルできない

非チェック例外・・・RuntimeExceptionクラスから派生しているサブクラスの例外。これらは、例外を処理しなくてもコンパイルできる。例えば、0で整数を除算したなど。

class Test extends Exception{
    public static void main(String[] args){
        Test t = new Test() ;
        try{
            t.check() ;
        } catch (Test e){//チェック例外を処理する
            e.printStackTrace() ;
        }
    }
    void check() throws Test{
        throw new Test() ;//チェック例外を投げる
    }
}

class Test extends Exception{
    public static void main(String[] args){
        Test t = new Test() ;
        try{
            t.check(t) ;
        } catch (Exception e){
            System.out.println("例外をキャッチしました") ;
            e.printStackTrace() ;
        }
    }
    void check(Test s) throws Test{
        try{
            s.errormethod() ;
        } catch(Test e){
            throw e ;//チェック例外を投げる
        }
    }
    void errormethod() throws Test{
        throw new Test() ;//チェック例外を投げる
    }
}