『Javaプログラミング思想』--異常総括

概要
異常といえばBug、つまりよく言う信春兄、無Bug、何がBugなのか思い出します.私が理解しているBugは、自分の仮想的な論理に従って実行されていないことです.これには、コード文法の問題と論理の問題が含まれています.例えば、正常な論理で買い物をして支払いをしなければなりませんが、バイヤーが買い物をしても支払いをしていません.直接荷物を持って行きます.これは論理の問題です.あるいは、元の配列に3つの要素が格納されています.あなたは4つ貯金して、この時もBugが現れて、プログラムは間違っていて、このBugは異常です.例外もJavaクラスの一種で、newでオブジェクトを作成します.彼らの構造はこうです.

Throwable

error

Exception

はい、そうです.異常はエラーと異常に分かれていて、少し早口な感じがしますが、errorのようなエラーはコンパイル中に報告されます.IDEを使用している場合は、Exception異常に注目すればいいだけです.
例外の取得と処理
異常の取得と処理は異常のすべてである可能性があります.私たちの原則は次のとおりです.

異常が発生したらプログラマーに

を知らせなければならない.
例外の取得
どうやって異常を取得しますか?Javaはtryキーワードを提供して解決します.私たちは異常が発生する可能性のあるコードをtryに置くだけでいいです.このようにします.

    try{
        ...
    }

JAvaは、異常を処理するためにできるだけ優雅な解決策を提供しています.異常を処理するコードと自身のビジネスコードが過度に混合されることを望んでいません.異常を取得するには、異常を処理する必要があります.この場合、このように書くべきです.

    try{
        ...
    }catch(Type1 type1){
        ...
    }catch(Type2 type2){
        ...
    }

catchのtypeはtryに現れる可能性のある異常タイプ

を表す.
catchはどのように異常をマッチングしますか?

は、1番目から最後まで順番に、異常マッチングが発見された場合、マッチングを停止し、switchモードとは異なる

ベースクラスにはサブクラス異常が含まれており、最初がExceptionである場合、後のクラスは

に一致する必要はありません.
ではcatchではこの異常をどう処理しますか?

処理しない(「飲み込み」が現れる)

は、コンソール

に印刷する.

書き込みログ

は

を投げ続けた.
tryブロックに例外を投げ出すと、catchで対応する例外タイプに一致します.このとき、対応する例外オブジェクトの参照が得られ、throwalbeのメソッドを呼び出して処理します.

public class ExceptionMethods {
    public static void main(String[] args) {
        try {
            throw new Exception("My Exception");
        } catch (Exception e) {
            System.out.println("Caught Exception");
            System.out.println(e.getMessage());
            System.out.println(e.getLocalizedMessage());
            System.out.println(e);
            System.out.println(e.toString());
            e.printStackTrace();
            e.printStackTrace(System.out);
        }
    }
}

一般的にe.printStackTrace()を使用します.異常スタック情報を打てば

またはログに書き込み、loggerを使用する.error

人によって例外の処理方法が異なる場合がある

.
私たちはtryを使って異常を捕獲することができるだけでなく、私たちもこの異常を投げ出すことができます.私たちは異常を今の制度にたとえることができます.地球村は少し問題を出しました.村長は測って、このことは自分で処理できないと思って、郷長に任せました.このような問題を上層部やJavaのプログラミング思想の中で言っている現在の環境から飛び出しました.より大きな環境に任せて処理するのもJava異常処理の考え方です.

if(t == null)
    throw new NullPointerException();

実は異常の最も重要なのは異常の名前で、今Javaは異常の種類を拡張していますが、多くの異常は私たちが望んでいない可能性があります.では、私たちは異常をカスタマイズすることができます.

class SystemErrException extends Exception{

}

これは異常クラスです.私たちはExceptionを継承しています.このSysteErrExceptionは私たちが異常を処理するのに使用できます.もちろん、パラメータを追加することができます.

class SystemErrException extends Exception{
    public SystemErrException(){ 
    }
    public SystemErrException (String message){
        super(message);
    }
} 

あるいは、

class SystemErrException extends Exception{
    private int i;
    public SystemErrException(){ 
    }
    public SystemErrException (String message){
        super(message);
    }
    public SystemErrException (String message, int i){
        super(message);
        this.i = i;
    }
} 

これはいくつかのパラメータを追加したにすぎませんが、これらは一般的に必要ありません.

throws
これといえば、もう一つのキーワードthrowsを言わなければなりません.はっきり見てください.throwではなくthrowsです.これは初心者を面接するときに聞く質問かもしれません.throwsは異常の中の申明で、IO学習ではよく見られます.それは声明です.コンパイラはあなたのコードに何か異常が発生する可能性があることをチェックしています.声明してください.メソッドに宣言します.

public void inputFile() throws IOException{
    ....
}

finally
finallyの用途は彼の意味と一致して、最終的な意味を表して、つまりfinallyの中のコードはきっと実行されます:ケース1

public class FinallyException {
    static int count = 0;

    public static void main(String[] args) {
        while (true){
            try {
                if (count++ == 0){
                    throw new ThreeException();
                }
                System.out.println("no Exception");
            }catch (ThreeException e){
                System.out.println("ThreeException");
            }finally {
                System.out.println("in finally cause");
                if(count == 2)
                    break;
            }
        }
    }
}

class ThreeException extends Exception{

}

実行結果:

ThreeException
in finally cause
no Exception
in finally cause

ケース2:returnケース

public class MultipleReturns {

    public static void f(int i){
        System.out.println("start.......");
        try {
            System.out.println("1");
            if(i == 1)
                return;
            System.out.println("2");
            if (i == 2)
                return;
            System.out.println("3");
            if(i == 3)
                return;
            System.out.println("else");
            return;
        }finally {
            System.out.println("end");
        }
    }

    public static void main(String[] args) {
        for (int i = 1; i<4; i++){
            f(i);
        }
    }
}

実行結果:

start.......
1
end
start.......
1
2
end
start.......
1
2
3
end

ベストプラクティス
このような状況に遭遇する可能性があります.ファイルを開き、ファイルを読み取り、ファイルを閉じます.通常の論理はそうですが、いくつかの問題があります.

ファイルを開く過程で異常が発生したが、ファイル

も閉じる.
このように:

    try{
        A a = new A();
        ...
    }catch(){
        ...
    }finally{
        a.close();
    }

Aは作成中に異常が発生するが、ファイル

を閉じるなどのaの方法を実行する.
私たちはこうすべきです

    try{
        A a = new A();
        try{
            ...
        }finally{
            a.close();
        }
    }catch(){
        ...
    }

例外スタック
普通は間違いを報告してすべてたくさんの間違いを報告して、みんなは見ることができなくて、実は異常な間違いを報告するのも規則があって、これはスタックの構造で、先進的に出て、栗を挙げます:

public class WhoCalled {
    static void f() {
        try {
            throw new Exception();
        } catch (Exception e) {
            for (StackTraceElement ste : e.getStackTrace()){
                System.out.println(ste.getMethodName());
            }
        }
    }

    static void g(){
        f();
    }

    static void h(){
        g();
    }


    public static void main(String[] args) {
        f();
        System.out.println("---------------------------");
        g();
        System.out.println("---------------------------");
        h();
        System.out.println("---------------------------");

    }
}

実行結果:

f
main
---------------------------
f
g
main
---------------------------
f
g
h
main
---------------------------

異常情報はすべて内から外まで見えるので、私の理解で異常を見るときは最初の異常情報から見なければなりません.それは異常発生の源だからです.
まとめ
異常は総じて重要であり、プログラムの丈夫性を保障する重要な欄でもあり、すぐに効果が現れることができる.ここでは異常のよくある問題を基本的にまとめただけで、自分で運用する過程で探求しなければならないことが多い.