Java-Ausnahmebehandlung

Die Grundlagen

Ausnahmen verstehen: Was passiert, wenn etwas schief geht?

Stellen Sie sich vor, Sie spielen ein Spiel und plötzlich fällt Ihr Charakter in eine Grube. Was würden Sie tun? Beim nächsten Mal würden Sie wahrscheinlich das Spiel neu starten oder einen Weg finden, die Grube zu umgehen. Beim Programmieren kann etwas Ähnliches passieren: Ihr Code könnte in eine „Grube“ fallen, die als Ausnahme bezeichnet wird. In diesem Fall funktioniert das Programm möglicherweise nicht mehr oder führt etwas Unerwartetes aus.

Was genau ist eine Ausnahme?

Eine Ausnahme ist wie ein Signal dafür, dass während der Ausführung Ihres Codes ein Fehler aufgetreten ist. Möglicherweise haben Sie versucht, eine Zahl durch Null zu dividieren (was nicht zulässig ist), oder Sie haben versucht, eine Datei zu öffnen, die nicht existiert. Wenn diese Probleme auftauchen, hisst Java eine Flagge und sagt: „Hey! Hier gibt es ein Problem!“

Was passiert ohne Ausnahmebehandlung?

Wenn wir Ausnahmen nicht behandeln, stürzt das Programm möglicherweise ab und der gesamte Fortschritt geht verloren – genau wie wenn Sie Ihr Spiel nicht speichern und der Computer plötzlich abschaltet.

Sehen wir uns ein Beispiel an:

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;
        int result = number / 0; // This will cause an exception!
        System.out.println("Result: " + result); // This line will never be reached.
    }
}

Wenn Sie versuchen, diesen Code auszuführen, stoppt er und meldet sich mit der Meldung: „Sie können nicht durch Null dividieren!“

Wie können wir die Grube vermeiden?

Um dieses Problem zu vermeiden, gibt uns Java etwas namens Try and Catch.

• versuchen Sie es mit Blockieren: Hier versuchen Sie, etwas zu tun, das ein Problem verursachen könnte.
• catch-Block: Hier erkennen Sie das Problem, falls es auftritt, damit Ihr Programm nicht abstürzt.

Lassen Sie uns unser Beispiel umschreiben:

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;

        try {
            int result = number / 0; // We know this might cause a problem.
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

Das passiert jetzt:

• Der Try-Block versucht, durch Null zu dividieren.
• Wenn Java das Problem erkennt, springt es zum Catch-Block und sagt: „Ups! Sie können nicht durch Null dividieren.“

Verschiedene Probleme erkennen

Mehr zum Abfangen von Ausnahmen

Da Sie nun wissen, wie man eine Ausnahme abfängt, fragen Sie sich vielleicht: „Was wäre, wenn mein Code verschiedene Arten von Problemen haben könnte? Wie fange ich sie alle ab?“

Stellen Sie sich vor, Sie versuchen, in einem Spiel eine Schatztruhe zu öffnen. Manchmal passt der Schlüssel nicht (das ist ein Problem) und manchmal ist die Truhe leer (das ist ein anderes Problem). Sie möchten doch genau wissen, was schief gelaufen ist, oder?

Verschiedene Arten von Ausnahmen

In Java gibt es verschiedene Arten von Problemen oder Ausnahmen. Zum Beispiel:

• ArithmeticException: Wenn Sie versuchen, Mathematik zu machen, die keinen Sinn ergibt, wie zum Beispiel eine Division durch Null.
• NullPointerException: Wenn Sie versuchen, etwas zu verwenden, das noch nicht existiert (z. B. der Versuch, eine Schatztruhe zu öffnen, die noch nicht vorhanden ist).
• ArrayIndexOutOfBoundsException: Wenn Sie versuchen, in ein Array nach etwas zu greifen, das außerhalb seiner Grenzen liegt, beispielsweise nach dem 11. Keks in einem Glas zu fragen, das nur 10 enthält.

Mehrere Ausnahmen abfangen

Sehen wir uns an, wie Sie verschiedene Arten von Problemen in Ihrem Code erkennen können:

public class MultipleExceptionsExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // This will cause an ArrayIndexOutOfBoundsException!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Oops! You tried to access an index that doesn’t exist.");
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

Das passiert:

• Der Code im Try-Block versucht, etwas zu tun, das ein Problem verursachen könnte.
• Wenn es auf eine ArrayIndexOutOfBoundsException stößt, springt es zum ersten Catch-Block.
• Wenn es auf eine ArithmeticException stößt, springt es zum zweiten Catch-Block.

Was ist, wenn ich ein Problem erkennen möchte?

Manchmal wissen Sie vielleicht nicht, was schief gehen könnte, möchten aber trotzdem jedes Problem erkennen. Sie können eine allgemeine Ausnahme verwenden, um alles abzufangen, was schief geht:

public class GeneralExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an ArithmeticException!
        } catch (Exception e) {
            System.out.println("Oops! Something went wrong.");
        }
    }
}

Auf diese Weise wird der Catch-Block trotzdem damit umgehen, wenn etwas schiefgeht, und Ihr Programm stürzt nicht ab.

Aufräumen und benutzerdefinierte Ausnahmen erstellen

Der endliche Block

Stellen Sie sich vor, Sie spielen ein Spiel und finden einen Schatz, aber egal, ob Sie Erfolg haben oder nicht, Sie möchten die Schatztruhe immer schließen, wenn Sie fertig sind. In Java ist der „finally“-Block so, als würde man sicherstellen, dass die Schatzkiste immer geschlossen ist, egal was passiert.

Was ist der „finally“-Block?

Der „finally“-Block ist ein Codeteil, der immer ausgeführt wird, unabhängig davon, ob eine Ausnahme auftritt oder nicht. Es wird zum Aufräumen verwendet, z. B. zum Schließen einer Datei, zum Stoppen eines Timers oder zum Wegräumen der Schatztruhe.

Sehen wir uns ein Beispiel an:

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception.
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        } finally {
            System.out.println("This will always run, no matter what.");
        }
    }
}

Das passiert:

• The try block tries to do something risky.
• The catch block catches the problem if it happens.
• The finally block always runs, even if there’s no problem.

Making Your Own Custom Exceptions

Sometimes, the problems you face in your code are special. Maybe the game doesn’t just have treasure chests, but also magical doors that can sometimes be locked. You might want to create a special exception for when the door is locked.

Creating a Custom Exception

You can create your own exceptions by making a new class that extends Exception. Let’s create an exception called LockedDoorException:

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

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            openDoor(false);
        } catch (LockedDoorException e) {
            System.out.println(e.getMessage());
        }
    }

    private static void openDoor(boolean hasKey) throws LockedDoorException {
        if (!hasKey) {
            throw new LockedDoorException("The door is locked! You need a key.");
        }
        System.out.println("The door is open!");
    }
}

Here’s how it works:

• We create a new exception called LockedDoorException.
• When we try to open the door without a key, we throw the LockedDoorException.
• The catch block catches our custom exception and tells us what went wrong.

Summary

In this post, we’ve learned that:

• Exceptions are problems that happen when your code is running.

• try and catch blocks help us handle these problems, so our program doesn’t crash.

• Different types of exceptions are like different kinds of problems.

• We can catch multiple exceptions to handle specific problems.

• We can also catch any exception using the general Exception type.

• The finally block is used to clean up, and it always runs no matter what.

• You can create custom exceptions to handle special problems in your code.

And that it! Now you’re ready to handle any problem that comes your way in your code. If you have any questions, feel free to ask!

Das obige ist der detaillierte Inhalt vonJava-Ausnahmebehandlung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!