Allgemeine Java-Ausnahmen

1. Einleitung

Dieses Tutorial konzentriert sich auf einige häufige Java-Ausnahmen.

Wir werden zunächst diskutieren, was eine Ausnahme im Grunde ist. Später werden wir verschiedene Arten von aktivierten und nicht aktivierten Ausnahmen im Detail besprechen.

2. Ausnahmen

Eine Ausnahme ist ein abnormaler Zustand, der in einer Codesequenz während der Ausführung eines Programms auftritt. Dieser abnormale Zustand tritt auf, wenn ein Programm zur Laufzeit bestimmte Einschränkungen verletzt.

Alle Ausnahmetypen sind Unterklassen der Klasse Exception . Diese Klasse wird dann in aktivierte und nicht aktivierte Ausnahmen unterteilt. Wir werden sie in den folgenden Abschnitten ausführlich betrachten.

3. Überprüfte Ausnahmen

Überprüfte Ausnahmen sind obligatorisch. Sie sind direkte Unterklassen der Klasse Exception .

Es gibt eine Debatte über ihre Bedeutung, die einen Blick wert ist.

Definieren wir einige geprüfte Ausnahmen im Detail.

3.1. IOException

Eine Methode löst eine IOException oder eine direkte Unterklasse davon aus, wenn eine Eingabe- / Ausgabeoperation fehlschlägt.

Typische Verwendungen dieser E / A-Operationen umfassen:

  • Arbeiten mit dem Dateisystem oder Datenströmen mit dem Paket java.io.
  • Erstellen von Netzwerkanwendungen mit dem Paket java.net

FileNotFoundException

FileNotFoundException ist eine häufige Art von IOException bei der Arbeit mit dem Dateisystem:

try { new FileReader(new File("/invalid/file/location")); } catch (FileNotFoundException e) { LOGGER.info("FileNotFoundException caught!"); }

MalformedURLException

Bei der Arbeit mit URLs kann es zu MalformedURLException kommen - wenn unsere URLs ungültig sind.

try { new URL("malformedurl"); } catch (MalformedURLException e) { LOGGER.error("MalformedURLException caught!"); }

3.2. ParseException

Java verwendet Textanalyse, um ein Objekt basierend auf einer bestimmten Zeichenfolge zu erstellen . Wenn das Parsen einen Fehler verursacht, wird eine ParseException ausgelöst .

Zum Beispiel könnten wir Datum auf verschiedene Arten darstellen, z. B. TT / MM / JJJJ oder TT, MM, JJJJ, aber versuchen, eine Zeichenfolge mit einem anderen Format zu analysieren :

try { new SimpleDateFormat("MM, dd, yyyy").parse("invalid-date"); } catch (ParseException e) { LOGGER.error("ParseException caught!"); }

Hier ist der String fehlerhaft und verursacht eine ParseException .

3.3. InterruptedException

Immer wenn ein Java-Thread join (), sleep () oder wait () aufruft, wechselt er entweder in den Status WAITING oder in den Status TIMED_WAITING .

Darüber hinaus kann ein Thread einen anderen Thread unterbrechen, indem er die Interrupt () -Methode eines anderen Threads aufruft .

Folglich löst der Thread eine InterruptedException aus, wenn ein anderer Thread sie unterbricht, während er sich im Status WAITING oder TIMED_WAITING befindet .

Betrachten Sie das folgende Beispiel mit zwei Threads:

  • Der Hauptthread startet den untergeordneten Thread und unterbricht ihn
  • Der untergeordnete Thread startet und ruft sleep () auf

Dieses Szenario führt zu einer InterruptedException:

class ChildThread extends Thread { public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { LOGGER.error("InterruptedException caught!"); } } } public class MainThread { public static void main(String[] args) throws InterruptedException { ChildThread childThread = new ChildThread(); childThread.start(); childThread.interrupt(); } }

4. Deaktivierte Ausnahmen

Bei nicht aktivierten Ausnahmen prüft der Compiler während des Kompilierungsprozesses nicht. Daher ist es für die Methode nicht zwingend erforderlich, diese Ausnahmen zu behandeln.

Alle nicht aktivierten Ausnahmen erweitern die Klasse RuntimeException.

Lassen Sie uns einige ungeprüfte Ausnahmen im Detail diskutieren.

4.1. NullPointerException

Wenn eine Anwendung versucht, null zu verwenden, wo tatsächlich eine Objektinstanz erforderlich ist, löst die Methode eine NullPointerException aus .

Es gibt verschiedene Szenarien, in denen die illegale Verwendung von null eine NullPointerException verursacht . Betrachten wir einige davon.

Aufrufen einer Methode der Klasse ohne Objektinstanz:

String strObj = null; strObj.equals("Hello World"); // throws NullPointerException.

Auch wenn eine Anwendung für den Zugriff versucht oder eine Instanzvariable mit einer ändern null Referenz, erhalten wir eine Nullpointer:

Person personObj = null; String name = personObj.personName; // Accessing the field of a null object personObj.personName = "Jon Doe"; // Modifying the field of a null object

4.2. ArrayIndexOutOfBoundsException

Ein Array speichert seine Elemente zusammenhängend. Somit können wir über Indizes auf seine Elemente zugreifen.

Jedoch , wenn ein Teil des Codes versucht , eine illegale Index eines Arrays zuzugreifen, führt das entsprechende Verfahren eine ArrayIndexOutOfBoundException.

Sehen wir uns einige Beispiele an, die ArrayIndexOutOfBoundException auslösen :

int[] nums = new int[] {1, 2, 3}; int numFromNegativeIndex = nums[-1]; // Trying to access at negative index int numFromGreaterIndex = nums[4]; // Trying to access at greater index int numFromLengthIndex = nums[3]; // Trying to access at index equal to size of the array

4.3. StringIndexOutOfBoundsException

The String class in Java provides the methods to access a particular character of the string or to slice out a character array out of the String. When we use these methods, internally it converts the String into a character array.

Again, there could be an illegal use of indexes on this array. In such cases, these methods of the String class throws the StringIndexOutOfBoundsException.

This exception indicates that the index is either greater than or equal to the size of the String.StringIndexOutOfBoundsException extends IndexOutOfBoundsException.

The method charAt(index) of the class String throws this exception when we try to access a character at the index equal to the String's length or some other illegal index:

String str = "Hello World"; char charAtNegativeIndex = str.charAt(-1); // Trying to access at negative index char charAtLengthIndex = str.charAt(11); // Trying to access at index equal to size of the string 

4.4. NumberFormatException

Quite often an application ends up with numeric data in a String. In order to interpret this data as numeric, Java allows the conversion of String to numeric types. The wrapper classes such as Integer, Float, etc. contains utility methods for this purpose.

However, if the String doesn't have an appropriate format during the conversion, the method throws a NumberFormatException.

Let's consider the following snippet.

Here, we declare a String with an alphanumeric data. Further, we try to use the methods of the Integer wrapper class to interpret this data as numeric.

Consequently, this results in NumberFormatException:

String str = "100ABCD"; int x = Integer.parseInt(str); // Throws NumberFormatException int y = Integer.valueOf(str); //Throws NumberFormatException

4.5. ArithmeticException

When a program evaluates an arithmetic operation and it results in some exceptional condition, it throws ArithmeticException. In addition, ArithmeticException applies to only int and long data types.

For instance, if we try to divide an integer by zero, we get an ArithmeticException:

int illegalOperation = 30/0; // Throws ArithmeticException

4.6. ClassCastException

Java allows typecasting between the objects in order to support inheritance and polymorphism. We can either upcast an object or downcast it.

In upcasting, we cast an object to its supertype. And in downcasting, we cast an object to one of its subtypes.

However, at runtime, if the code attempts to downcast an object to a subtype of which it isn't an instance, the method throws a ClassCastException.

The runtime instance is what actually matters in typecasting. Consider the following inheritance between Animal, Dog, and Lion:

class Animal {} class Dog extends Animal {} class Lion extends Animal {} 

Further, in the driver class, we cast the Animal reference containing an instance of Lion into a Dog.

However, at the runtime, the JVM notices that instance Lion isn't compatible with the subtype of the class Dog.

This results in ClassCastException:

Animal animal = new Lion(); // At runtime the instance is Lion Dog tommy = (Dog) animal; // Throws ClassCastException

4.7. IllegalArgumentException

A method throws an IllegalArgumentException if we call it with some illegal or inappropriate arguments.

For instance, the sleep() method of the Thread class expects positive time and we pass a negative time interval as an argument. This results in IllegalArgumentException:

Thread.currentThread().sleep(-10000); // Throws IllegalArgumentException

4.8. IllegalStateException

IllegalStateException signals that a method's been invoked at an illegal or inappropriate time.

Every Java object has a state (instance variables) and some behavior (methods). Thus, IllegalStateException means it's illegal to invoke the behavior of this object with the current state variables.

However, with some different state variables, it might be legal.

For example, we use an iterator to iterate a list. Whenever we initialize one, it internally sets its state variable lastRet to -1.

With this context, the program tries to call the remove method on the list:

//Initialized with index at -1 Iterator intListIterator = new ArrayList().iterator(); intListIterator.remove(); // IllegalStateException 

Internally, the remove method checks the state variable lastRet and if it is less than 0, it throws IllegalStateException. Here, the variable is still pointing to the value -1.

Als Ergebnis erhalten wir eine IllegalStateException .

5. Schlussfolgerung

In diesem Artikel haben wir zunächst die Ausnahmen erörtert. Eine Ausnahme ist ein Ereignis, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Programmanweisungen stört.

Anschließend haben wir die Ausnahmen in die überprüften Ausnahmen und die nicht aktivierten Ausnahmen unterteilt.

Als Nächstes haben wir verschiedene Arten von Ausnahmen besprochen, die während der Kompilierungszeit oder zur Laufzeit auftreten können.

Den Code für diesen Artikel finden Sie auf GitHub.