Verwendungsregeln für die Behandlung von Java-Ausnahmen

Vorschriften für den Umgang mit Ausnahmen

Hier ist eine Zusammenfassung der Regeln, die ich persönlich für try, catch und schließlich halte (oder die weitgehend befolgt werden). Wenn Sie andere zu schützende Inhalte haben, kommentieren Sie diese bitte.

Kehre nicht mit Versuch zurück

endlich wird immer ausgeführt.

try {
    return 1;
} finally {
    return 2;
}

1. Der Rückgabewert ist 2.
2. try return kann durch finally return überschrieben werden.

versuchen / aus der Schleife fangen

Die Ausnahmegenerierung ist nicht kostenlos.

in für

int sum = 0;
for (int i = 0; i < 99900000; i++) {
    try {
        sum += i;
    } catch (Exception ex) {
    }
}

für draußen

int sum = 0;
try {
    for (int i = 0; i < 99900000; i++) {
        sum += i;
    }
} catch (Exception ex) {
}

Durch die Messung der Zeit ergibt sich ein Leistungsunterschied von 21%. in für: 1312 draußen: 1042

Wenn Sie JIT (Just In Time) nicht deaktivieren, wird der Code optimiert und es gibt keinen Unterschied. JIT ungültige Option: -Djava.compiler = keine

Bringen Sie das Objekt in einen gültigen Zustand zurück, bevor Sie eine Ausnahme auslösen

Das Objekt mit der Ausnahme kann weiterhin verwendet werden.

Stichprobe

private static class A {
private final int maximale Größe= 10;
private int aktuelle Größe= 0;
    String[] values = new String[20];
    public void add(String val) throws Exception {
Momentane Größe++;
        if (Momentane Größe>Maximale Größe) {
            throw new Exception("Die maximale Größe überschritten");
        }
        values[Momentane Größe- 1] = val;
    }
}

Code in Frage

Momentane Größe++;
if (Momentane Größe>Maximale Größe) {
    throw new Exception("Die maximale Größe überschritten");
}

1. Ich habe eine Ausnahme ausgelöst, aber die maximale Größe dieses Objekts bleibt "maximale Größe + 1".
2. Wenn Sie "Werte [aktuelle Größe]" ausführen, ist dies möglicherweise unzulässig.

Steuern Sie den Prozess nicht mit Ausnahmebehandlung

Prozesse, die durch normale Verarbeitung gesteuert werden können, sollten nicht ausnahmsweise verarbeitet werden.

1. Schlechte Lesbarkeit
2. Ausnahmebehandlung ist kostspielig

Steuern Sie den Prozess mit Ausnahmen

private static void showWithEx(String[] src) {
    try {
        int i = 0;
        while (true) {
            String s = src[i++];
        }
    } catch (ArrayIndexOutOfBoundsException ex) {
    }
}

Nach der Renovierung

private static void show(String[] src) {
    int i = 0;
    while (i < src.length) {
        String s = src[i++];
    }
}

Messung der Ausnahmekosten

python

public static void main(String[] args) {
    final int COUNT = 100000;
    String[] src = {"ab", "cd", "ef"};
    long start = 0L;
    
    start = System.currentTimeMillis();
    for (int i = 0; i < COUNT; i++) {
        showWithEx(src);
    }
    System.out.println(System.currentTimeMillis() - start);

    start = System.currentTimeMillis();
    for (int i = 0; i < COUNT; i++) {
        show(src);
    }
    System.out.println(System.currentTimeMillis() - start);

    start = System.currentTimeMillis();
    for (int i = 0 ; i < COUNT; i++ ) {
        Object o = new ArrayIndexOutOfBoundsException();
    }
    System.out.println(System.currentTimeMillis() - start);
}

Ausgabe

0
156
63

1. Nach der Reparatur war es 0, egal wie oft es erhöht wurde.
2. Es dauerte 156 vor der Renovierung
3. new ArrayIndexOutOfBoundsException () ist 63, sodass andere Kosten als die Generierung nicht ignoriert werden können.

Verwenden Sie keinen großen Versuch

Es ist einfach, die gesamte Verarbeitung in einem Versuch zusammenzufassen, was auf den ersten Blick schön und einfach aussieht, aber eigentlich eine Falle ist.

1. "Langer Code = hohe Wahrscheinlichkeit einer Ausnahme", daher ist es schwierig zu debuggen, wo die Ausnahme aufgetreten ist
2. Ein großer Versuch enthält mehr catch-Klauseln, und diese logischen Beziehungen müssen gelöst werden.

Großer Versuch ist NG

public static void main(String[] args) {
    try {
        //Abkürzung
        String src;
   
        src = "123";
        int val1 = Integer.parseInt(src);

        src = "abc";
        int val2 = Integer.parseInt(src);
        //Abkürzung
        src = null;
        src.getBytes();
    } catch (NumberFormatException ex) {
        System.out.println(ex.getMessage());
    } catch (NullPointerException ex ) {
        System.out.println(ex.getMessage());
    }
}

Verwenden Sie nicht Catch all

Es ist NG, mit einer oberen Ausnahmeklasse (Throwable) zu fangen.

1. Für verschiedene Ausnahmen können nur die gleichen Maßnahmen ergriffen werden. Die Verarbeitung kann mit if und instanceOf in catch aufgeteilt werden, aber ... stop ...
2. Selbst wenn das Programm gestoppt werden sollte, z. B. RuntimeException, wird es abgefangen und unterdrückt, ohne dass es jemand weiß.

Verwenden Sie Catch nicht_all

try {
    // Checked Exception
    File f = new File("nicht existieren");
    int b = new FileInputStream(f).read();
    // Runtime Exception
    Object o = null;
    o.getClass();
} catch (Throwable ex) {
    ex.printStackTrace();
}

Verstecke keine Ausnahmen

Wenn catch schließlich eine Ausnahme auslöst, wird der Ausnahmeinhalt möglicherweise ausgeblendet.

public static void main(String[] args) {
    try {
        m1();
    } catch (Exception ex) {
        System.out.println("In main : " + ex.getMessage());
    }
}
private static void m1() throws Exception {
    try {
        System.out.println("m1 : try");
        throw new Exception("First EX");
    } catch (Exception ex) {
        System.out.println("m1 : catch");
        throw new Exception("Second EX");
    } finally {
        System.out.println("m1 : finally");
        throw new Exception("Third EX");
    }
}

Ausgabe

m1 : try
m1 : catch
m1 : finally
In main : Third EX.

Die Hauptursache ist "Neue Ausnahme auslösen (" Erste EX ");" Ich habe eine neue Ausnahme ("Third EX") aufgenommen.

Ausnahmen nicht ignorieren

Ich habe eine Ausnahme festgestellt, aber "nichts tun oder nur das Protokoll ausgeben" ist eine Verschleierungsarbeit. Dies hat große Auswirkungen auf die Gesundheit des Programms.

Ausnahmen ignorieren

try {
    File f = new File("nicht existieren");
    int b = new FileInputStream(f).read();
} catch (FileNotFoundException ex) {
} catch (IOException ex) {
}

Angemessene Ausnahmebehandlung

1. Überprüfte Ausnahmen sollten programmgesteuert repariert werden
2. Verwenden Sie für nicht reparierbare Ausnahmen Würfe, um den Anrufer zur Reparatur aufzufordern

Bonus

(Normales) Ausnahmeklassensystem

Ausnahmeklassenklassifizierung

• Runtime Exception
• RuntimeException oder geerbte Klasse
• Ausnahmen, die programmatisch irreparabel erscheinen
• Du musst nicht fangen
• Checked Exception
• Andere Klassen als RuntimeException
• Ausnahmen, die programmgesteuert reparierbar zu sein scheinen
• Zum Fangen oder Werfen gezwungen