Tauchen Sie tief in die Java-Ausnahmen ein

Java Core-Ausnahmeklasse

Hierarchie der Ausnahmeklassen: Throwable < Fehler < Ausnahme, wenn das Throwable die Superklasse ist

Wurfbar

Die Throwable-Klasse ist die Oberklasse aller Fehler und Ausnahmen in der Java-Sprache. Nur Objekte, die Instanzen dieser Klasse (oder einer ihrer Unterklassen) sind, werden von der Java Virtual Machine geworfen oder können von der Java-Throw-Anweisung geworfen werden. Referenz

In der Praxis wird Throwable normalerweise nicht direkt von Entwicklern verwendet. Stattdessen dient es als Grundlage für seine beiden direkten Unterklassen: Fehler und Ausnahme.

try {
 // some process
} catch (Throwable t) {
    throw new Throwable(t);
}

Fehler

Ein Fehler ist eine Unterklasse von Throwable, die auf schwerwiegende Probleme hinweist, die eine vernünftige Anwendung nicht abfangen sollte. Fehler stellen typischerweise abnormale Bedingungen dar, die in der JVM-Referenz selbst auftreten

Ein abnormaler Zustand bedeutet, dass das Problem typischerweise auf Faktoren zurückzuführen ist, die außerhalb der Kontrolle der Anwendung liegen, und im Allgemeinen nicht behebbar ist. Beispiel: OutOfMemoryError, StackOverflowError

Ausnahme

Eine Ausnahme bezieht sich auf ein unerwartetes Ereignis oder eine unerwartete Bedingung, die während der Ausführung eines Programms auftritt, und wir sollten es mit Catch versuchen. Durch das Abfangen von Ausnahmen sollten wir in der Lage sein, unerwartete Situationen elegant zu bewältigen und sicherzustellen, dass das Programm nicht abstürzt.

int[] arr = {1, 2, 3};
try {
    System.out.println(arr[3]); // This will throw ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Unchecked Exception: " + e.getMessage());
}

 

Arten von Ausnahmen

In Java gibt es zwei Arten von Ausnahmen. Referenz

Geprüfte Ausnahmen

Eine aktivierte Ausnahme ist wie eine Situation, von der Sie wissen, dass sie schiefgehen kann, weshalb Sie eine entsprechende Planung durchführen müssen. Sie müssen entweder mit einem Try-Catch-Block abgefangen oder in der Methodensignatur mit einer Throws-Klausel deklariert werden. Wenn eine Methode eine geprüfte Ausnahme auslösen kann und Sie diese nicht behandeln, wird das Programm nicht kompiliert.

// Checked exception
try {
    readFile("nonexistent.txt");
} catch (FileNotFoundException e) {
    System.out.println("Checked Exception: " + e.getMessage());
}

// Checked exception
public void getData() throws SQLException { // throw SQLException
    throw new SQLException("err");
}

Ungeprüfte Ausnahme

Unkontrollierte Ausnahmen, auch bekannt als: Laufzeitausnahmen sind Ausnahmen, deren Behandlung der Java-Compiler nicht erfordert. Sie sind Unterklassen von RuntimeException. Im Gegensatz zu geprüften Ausnahmen müssen diese Ausnahmen nicht abgefangen oder in der Methodensignatur deklariert werden. Sie weisen in der Regel auf Programmierfehler hin, wie z. B. logische Fehler, falsche Verwendung von APIs oder Verstöße gegen Annahmen im Code.

String text = null;
System.out.println(text.length()); // This will throw a NullPointerException

 

Häufige Arten von Java-Ausnahmen

NullPointerException: Tritt auf, wenn eine Anwendung versucht, eine Objektreferenz zu verwenden, die nicht initialisiert wurde.

String text = null; // text is not initialized
try {
    System.out.println(text.length()); // Attempting to call length() on a null reference
} catch (NullPointerException e) {
    System.out.println("Caught a NullPointerException: " + e.getMessage());
}

ArrayIndexOutOfBoundsException: Wird ausgelöst, wenn versucht wird, auf ein Array mit einem ungültigen Index zuzugreifen.

int[] numbers = {1, 2, 3};
try {
    int value = numbers[5]; // Attempting to access index 5, which is out of bounds
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught an ArrayIndexOutOfBoundsException: " + e.getMessage());
}

IllegalArgumentException: Wird ausgelöst, wenn eine Methode ein unangemessenes Argument empfängt.

public class IllegalArgumentExample {
    public static void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative"); // Illegal argument
        }
        System.out.println("Age set to: " + age);
    }

    public static void main(String[] args) {
        try {
            setAge(-5); // Passing a negative age, which is illegal
        } catch (IllegalArgumentException e) {
            System.out.println("Caught an IllegalArgumentException: " + e.getMessage());
        }
    }
}

 

So behandeln Sie Ausnahmen

Try-Catch

Verwenden Sie Try-Catch, wenn Sie bestimmte Ausnahmen behandeln möchten, die möglicherweise innerhalb eines Codeblocks ausgelöst werden

try {
    int result = 10 / 0; // This will throw ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Caught an ArithmeticException: " + e.getMessage());
}

Mehrfachfang

Verwenden Sie Multi-Catch, wenn Sie mehrere Ausnahmetypen auf ähnliche Weise behandeln möchten

try {
    String str = null;
    System.out.println(str.length()); // This will throw NullPointerException
} catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught an exception: " + e.getMessage());
}

Versuchen Sie es mit Ressourcen

Verwenden Sie „Try-with-Ressourcen“, wenn Sie mit Ressourcen arbeiten, die nach der Verwendung geschlossen werden müssen, wie z. B. Dateien, Sockets oder Datenbankverbindungen.

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.out.println("Caught an IOException: " + e.getMessage());
}

Endlich

Verwenden Sie den „finally“-Block, wenn Sie sicherstellen müssen, dass bestimmter Code unabhängig davon ausgeführt wird, ob eine Ausnahme ausgelöst wurde oder nicht

try {
    file = new FileReader("file.txt");
} catch (IOException e) {
    System.out.println("Caught an IOException: " + e.getMessage());
} finally {
    if (file != null) {
        file.close(); // Ensure the file is closed
    }
}

 

Best Practices für die Ausnahmebehandlung

Ausnahmen nicht ignorieren: Ausnahmen sollten angemessen behandelt und nicht nur abgefangen und ignoriert werden.

try {
    file = new FileReader("file.txt");
} catch (IOException ignored) {
    // ignored
}

Spezifische Ausnahmen verwenden: Verwenden Sie spezifische Ausnahmen anstelle allgemeiner Ausnahmen.

try {
    // Code that may throw exceptions
    String text = null;
    text.length();
} catch (Exception e) {
    // Too broad; will catch all exceptions
    System.err.println("An error occurred: " + e.getMessage());
}

Richtiger Umgang damit:

try {
    // Code that may throw exceptions
    String text = null;
    text.length();
} catch (NullPointerException e) {
    // Handle specific exception
    System.err.println("Null pointer exception: " + e.getMessage());
} catch (Exception e) {
    // Handle other exceptions
    System.err.println("An error occurred: " + e.getMessage());
}

Sauberer Umgang mit Ressourcen: Schließen Sie immer Ressourcen, um Speicherlecks zu vermeiden

FileReader fileReader = null;
try {
    fileReader = new FileReader("file.txt");
    // Read from the file
} catch (IOException e) {
    System.err.println("File not found: " + e.getMessage());
} finally {
   fileReader.close(); // clouse resources
}

Benutzerdefinierte Ausnahmen: Erstellen Sie benutzerdefinierte Ausnahmen, wenn die Standardausnahmen nicht den spezifischen Fehlerbedingungen entsprechen.

// Custom Exception
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// Usage
public class Example {
    public void performOperation() throws CustomException {
        // Some condition
        throw new CustomException("Custom error message");
    }

    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.performOperation();
        } catch (CustomException e) {
            System.err.println("Caught custom exception: " + e.getMessage());
        }
    }
}

Protokollierung: Ausnahmen für Debugging und Wartung protokollieren.

public class Example {
    private static final Logger logger = Logger.getLogger(Example.class.getName());

    public void riskyMethod() {
        try {
            // Code that may throw an exception
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            // Log the exception
            logger.severe("An arithmetic error occurred: " + e.getMessage());
        }
    }
}

Übermäßige Verwendung von Ausnahmen vermeiden: Warnung vor der Verwendung von Ausnahmen zur Steuerung des Flusses; Sie sollten nur zur Bewältigung wirklich außergewöhnlicher Situationen eingesetzt werden.

public class Example {
    public void process(int[] array) {
        try {
            // Using exceptions to control flow
            if (array.length < 5) {
                throw new ArrayIndexOutOfBoundsException("Array too small");
            }
            // Process array
        } catch (ArrayIndexOutOfBoundsException e) {
            // Handle exception
            System.out.println("Handled array size issue.");
        }
    }
}

Richtiger Umgang damit:

public class Example {
    public void process(int[] array) {
        if (array.length >= 5) {
            // Process array
        } else {
            // Handle the condition without using exceptions
            System.out.println("Array is too small.");
        }
    }
}





 

Jedes Feedback wird hilfreich sein :)


          

            
        
Das obige ist der detaillierte Inhalt vonTauchen Sie tief in die Java-Ausnahmen ein. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!