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: Error und Exception.

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

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

Es gibt zwei Arten von Ausnahmen in Java. Referenz

Geprüfte Ausnahmen

Eine aktivierte Ausnahme ist wie eine Situation, von der Sie wissen, dass sie schiefgehen kann, deshalb müssen Sie dafür planen. 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 zum Beispiel 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 innerhalb eines Codeblocks ausgelöst werden könnten

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 ausgeführt wird, unabhängig davon, 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 }

Verwenden Sie spezifische Ausnahmen: Verwenden Sie spezifische Ausnahmen, anstatt generische Ausnahmen zu verwenden.

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()); } } }

Vermeiden Sie die übermäßige Verwendung von Ausnahmen: Warnen Sie davor, Ausnahmen zur Steuerung des Flusses zu verwenden. 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!