TOC

Häufige Java-Ausnahmen

Häufige Java-Ausnahmen

1. Einführung

Dieses Tutorial konzentriert sich auf einige häufig vorkommende 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

An exception is an abnormal condition that occurs in a code sequence during the execution of a program. Dieser abnormale Zustand tritt auf, wenn ein Programm zur Laufzeit bestimmte Einschränkungen verletzt.

Alle Ausnahmetypen sind Unterklassen der KlasseException. 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

Checked exceptions are mandatory to handle. Sie sind direkte Unterklassen der KlasseException.

Es gibt eindebatefür ihre Wichtigkeit, das einen Blick wert ist.

Definieren wir einige geprüfte Ausnahmen im Detail.

3.1. IOException

Eine Methode löst einIOException 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 Paketjava.io

  • Erstellen von Netzwerkanwendungen mit dem Paketjava.net

FileNotFoundException

FileNotFoundException ist ein häufiger Typ vonIOException 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 tritt möglicherweiseMalformedURLException – auf, 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 einem bestimmtenString.If parsing causes an error, it throws a ParseException. zu erstellen

Zum Beispiel könnten wirDate auf verschiedene Arten darstellen, z. dd/mm/yyyy oderdd,mm,yyyy,, aber versuchen Sie,string mit einem anderen Format zu analysieren: 

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

Hier istString fehlerhaft und verursachtParseException.

3.3. InterruptedException

Immer wenn ein Java-Threadjoin(), sleep() oderwait() aufruft, wechselt er entweder in den StatusWAITINGoder in den StatusTIMED_WAITING.

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

Folglich istthe thread throws an InterruptedException if another thread interrupts it while it is in the WAITING or in the TIMED_WAITING state.

Betrachten Sie das folgende Beispiel mit zwei Threads:

  • Der Hauptthread startet den untergeordneten Thread und unterbricht ihn

  • Der untergeordnete Thread startet und ruftsleep() auf

Dieses Szenario ergibt einInterruptedException: 

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

For Unchecked Exceptions, the compiler doesn’t check during the compilation process. Daher ist es für die Methode nicht zwingend erforderlich, diese Ausnahmen zu behandeln.

Alle nicht aktivierten Ausnahmen erweitern die KlasseRuntimeException.

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

4.1. NullPointerException

Wenn eine Anwendung versucht,null dort zu verwenden, wo tatsächlich eine Objektinstanz erforderlich ist, gibt die MethodeNullPointerException aus.

Es gibt verschiedene Szenarien, in denen die illegale Verwendung vonnullNullPointerException. verursacht. Betrachten wir einige davon.

Aufruf einer Methode der Klasse ohne Objektinstanz: 

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

Wenn eine Anwendung versucht, auf eine Instanzvariable mit einernull-Referenz zuzugreifen oder diese zu ändern, erhalten wir eineNullPointerException: 

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, if a piece of code tries to access an illegal index of an array, the respective method throws an ArrayIndexOutOfBoundException.

Sehen wir uns einige Beispiele an, dieArrayIndexOutOfBoundException werfen: 

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

DieString-Klasse in Java bietet die Methoden, um auf ein bestimmtes Zeichen der Zeichenfolge zuzugreifen oder ein Zeichenarray aus denString. herauszuschneiden. Wenn wir diese Methoden verwenden, konvertiert sie intern dieString in ein Zeichenarray.

Auch hier kann es zu einer illegalen Verwendung von Indizes für dieses Array kommen. In solchen Fällen lösen diese Methoden der KlasseStringStringIndexOutOfBoundsException aus.

Diese Ausnahmeindicates that the index is either greater than or equal to the size of the String. StringIndexOutOfBoundsException erweitertIndexOutOfBoundsException.

Die MethodecharAt(index) der KlasseString löst diese Ausnahme aus, wenn wir versuchen, auf ein Zeichen am Index zuzugreifen, das der Länge vonString’soder einem anderen unzulässigen Index entspricht: 

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

Sehr oft erhält eine Anwendung numerische Daten inString. Um diese Daten als numerisch zu interpretieren, ermöglicht Java die Konvertierung vonString in numerische Typen. Die Wrapper-Klassen wieInteger, Float, etc. enthalten zu diesem Zweck Dienstprogrammmethoden.

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

Betrachten wir das folgende Snippet.

Hier deklarieren wir einString mit alphanumerischen Daten. Außerdem versuchen wir, die Methoden der Wrapper-KlasseIntegerzu verwenden, um diese Daten als numerisch zu interpretieren.

Folglich ergibt diesNumberFormatException: 

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. Außerdem giltArithmeticException nur für die Datentypenint andlong.

Wenn wir zum Beispiel versuchen, eine ganze Zahl durch Null zu teilen, erhalten wir einArithmeticException: 

int illegalOperation = 30/0; // Throws ArithmeticException

4.6. ClassCastException

Java erlaubttypecasting zwischen den Objekten, um Vererbung und Polymorphismus zu unterstützen. Wir können ein Objekt entweder upcasten oder downcasten.

Beim Upcasting werfen wir ein Objekt auf seinen Supertyp. Und beim Downcasting werfen wir ein Objekt in einen seiner Untertypen.

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.

Die Laufzeitinstanz ist das, worauf es beim Typecasting ankommt. Betrachten Sie die folgende Vererbung zwischenAnimal,Dog, and Lion: 

class Animal {}

class Dog extends Animal {}

class Lion extends Animal {}

Außerdem wandeln wir in der Treiberklasse die ReferenzAnimal, die eine Instanz vonLion enthält, inDog um.

Zur Laufzeit stellt die JVM jedoch fest, dass die InstanzLion nicht mit dem Subtyp der KlasseDog kompatibel ist.

Dies ergibtClassCastException: 

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

4.7. IllegalArgumentException

Eine Methode löst einIllegalArgumentException aus, wenn wir es mit illegalen oder unangemessenen Argumenten aufrufen.

Zum Beispiel erwartet diesleep()-Methode derThread-Klasse eine positive Zeit und wir übergeben ein negatives Zeitintervall als Argument. Dies ergibtIllegalArgumentException: 

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

4.8. IllegalStateException

IllegalStateException signalisiert, dass eine Methode zu einem illegalen oder unangemessenen Zeitpunkt aufgerufen wurde.

Jedes Java-Objekt hat einen Status (Instanzvariablen) und ein bestimmtes Verhalten (Methoden). IllegalStateException bedeutet also, dass es illegal ist, das Verhalten dieses Objekts mit den aktuellen Statusvariablen aufzurufen.

Bei einigen unterschiedlichen Statusvariablen kann dies jedoch zulässig sein.

Zum Beispiel verwenden wir einen Iterator, um eine Liste zu iterieren. Immer wenn wir eine initialisieren, setzt sie intern ihre ZustandsvariablelastRet auf -1.

In diesem Zusammenhang versucht das Programm, die Methoderemovein der Liste aufzurufen: 

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

intListIterator.remove(); // IllegalStateException

Intern überprüft die Methoderemove die ZustandsvariablelastRet, und wenn sie kleiner als 0 ist, wirdIllegalStateException.  ausgelöst. Hier zeigt die Variable immer noch auf den Wert -1.

Als Ergebnis erhalten wir einIllegalStateException.

5. Fazit

In diesem Artikel haben wir zuerst die Ausnahmen besprochen. Einexception 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 geprüfte Ausnahmen und ungeprüfte Ausnahmen unterteilt.

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

Wir können den Code für diesen Artikelover on GitHub finden.

Related