Skip to main content

Du musst in Java nicht jede Exception fangen

Java Exception fangen Beispiel

Kennst du die Metapher mit dem Jongleur und den Bällen?

Ein Jongleur hält drei Bälle in der Luft, dann vier und irgendwann fünf.
Aber irgendwann ist es genau ein Ball zu viel.
Und Alles bricht zusammen.

Ja ein Ball zu viel, kann alles versauen. 🙂

Java Exception zu viele fangen

Und so ist es doch immer im Leben.
Du kannst dich um zwei oder drei Dinge gleichzeitig kümmern.
Vielleicht sogar um vier oder fünf. Irgendwann ist aber immer Schluss – Ende.

Dann bricht alles zusammen.
Für manche Menschen endet das Spiel mit zu vielen Bällen im Burnout oder in einer Depression.

Eines der besten Bücher, welches ich kenne behandelt dieses Thema ebenfalls.
Das Buch „Der Weg zum erfolgreichen Unternehmer“ ist so geil – Dieses lese ich eigentlich jedes Jahr einmal.
Also immer wieder.

Denn hier geht es ganz klar um Fokussierung und eben darum, nicht jeden Ball zu fangen.
Wer von Euch ein Business aufbauen möchte oder mit seinem Java Programm irgendwann einmal, kommerziell Geld verdienen will – sollte dieses Buch mal gelesen haben.
Es ist wirklich empfehlenswert.

So genug Werbung.
Aber es ist eine perfekte Überleitung zum Fangen von Exceptions.
Denn dies gestaltet sich mitunter schwierig.
Du kannst nicht jede Ausnahme bzw. Ausnahmentyp separat abfangen, oder?

Irgendeine Exception flutscht immer durch.
An irgendetwas hast du nicht gedacht.
Irgendeine falsche Benutzereingabe oder sonstige Ausnahme führt unweigerlich zum Softwareabsturz.

Doch zum Glück gibt es in Java das Feature Polymorphie. Dadurch musst du nicht jede Ausnahme behandeln.

Es kann wirklich ganz schön stressig werden, jede mögliche Ausnahme abzufangen.

Aber zum Glück ist Java eine objektorientierte Programmiersprache mit der Möglichkeit zur Vererbung.
Wirf doch mal einen Blick in die Java API Docs.
Und suche dir einmal die Klasse Exceptions.

Java Exception Klasse

Du siehst – jede Menge Unterklassen.
Und alle diese erben von der Klasse Exception.
Java Exception Kindklassen

Kannst du dich noch an das Beispiel zu den Exceptions errinnern.

Dies haben wir in einen der letzten Beiträge behandelt.
Zur Erinnerung – Wir haben die Exception für die Division durch Null abgefangen.
Hier nochmal der Code dazu:

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int dividend = 10;// Dividend erhält den Wert 10
		int divisor = 0;// Divisor mit Wert 0

		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe 10 /0
		} 
		catch (ArithmeticException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
	}
}

Wir haben also ganz konkret eine ArithmeticException behandelt und gefangen.
Jetzt such doch einmal unsere behandelte Ausnahme – also die Subklasse „ArithmeticException“ – in den API Docs.
Nicht zu finden, oder?

Was bedeutet das?
ArithmeticException ist scheinbar keine Kindklasse von Exception.

Was dann?
Du kannst diese Klasse direkt in den API Docs suchen oder du kennst bereits den Vererbungsbaum dieser Exception.
Hier der Baum:

Java Exception Vererbungsbaum

Was bedeutet das?
Durch Polymorphie ist es möglich, ein Objekt in einem anderen allgemeiner Datentypen der selben Vererbungslinie zu speichern.

Du kannst somit die Ausnahme entweder mit einem Objekt der Kindklasse ArithmeticException, mit der Kindklasse RuntimeException oder aus der Superklasse Exception fangen.

Also dann – Lass uns diese Exception mal auf verschiedene Art und Weise fangen.

Zum Beispiel mit der RuntimeException.
Dazu brauchst du nur ein anderes Objekt anlegen.
Aus ArithmeticException wird RuntimeException.

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int dividend = 10;// Dividend erhält den Wert 10
		int divisor = 0;// Divisor mit Wert 0

		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe 10 /0
		} 
		catch (RuntimeException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
	}
}

Klar kannst du die Exception auch mit einem Objekt der Klasse Exception fangen.
So wie hier:

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int dividend = 10;// Dividend erhält den Wert 10
		int divisor = 0;// Divisor mit Wert 0

		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe 10 /0
		} 
		catch (Exception eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
	}
}

Du siehst – durch Polymorphie wird das Exception fangen – eine äußerst facettenreiche und flexibel gestaltbare Geschichte.

Du kannst jede Java Exception auch mit weiteren catch-Block fangen.

Auch das haben wir bereits in einem anderen Beitrag teilweise schon gemacht.

Durch mehrere catch-Blöcke kannst du verschiedene Exception fangen.
Du kannst allerdings auch eine Exception mit mehreren catch-Blöcken fangen.

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int dividend = 10;// Dividend erhält den Wert 10
		int divisor = 0;// Divisor mit Wert 0
		
		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe 10 /0
		} 
		catch (ArithmeticException eArith) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
		catch (RuntimeException eNull) {
			System.out.println("Laufzeitfehler");
		}
		catch (Exception e) {
			System.out.println("Fehler");
		}
	}
}

Durch Polymorphie hast du jetzt aber ganz andere Gestaltungsmöglichkeiten.

Ein zweites Beispiel.

Die IndexOutOfBound Exception fangen.

Diese Ausnahme tritt auf, wenn du ein Array hast.
Und in diesem Array auf ein Fach zugreifen willst, welches größer als die Länge des Arrays ist.
So wie hier:

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int zahlen [] = new int [1];// Array mit Länge 1
		
		try {
			System.out.println(zahlen[10]);//Auslesen des 10-ten Faches
		} 
		catch (ArithmeticException eArith) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
		catch (RuntimeException eNull) {
			System.out.println("Laufzeitfehler");
		}
		catch (Exception e) {
			System.out.println("Fehler");
		}
	}
}

Klick einmal auf „RUN“ und schau, was passiert.
Die Ausnahme wird jetzt durch den zweiten catch-Block gefangen und dort behandelt.

Wieso im zweiten?
Ganz einfach. Die Klasse „IndexOutOfBoundException“ erweitert ebenfalls die Klasse „RuntimeException“.

Java-Exception-fangen-Index-out-of-bound

Somit haben die „ArithmeticException“ und die „IndexOutOfBoundException“ die selbe Superklasse.
Nämlich die Klasse „RuntimeException“.

Das bedeutet für dich.
Du kannst beide Exceptiontypen mit einem Objekt der Klasse „RuntimeException“ abfangen und behandeln.

Die catch Blöcke werden von oben nach unten durchlaufen.

So wie beim switch-case-Statement.

Java Exceptions Fangen

  • Das Programm bemerkt, dass es zur Ausnahme gekommen ist und springt aus dem try-Block.
  • Dann untersucht das Programm den ersten catch-Block.
    Besser gesagt, es prüft – ob das Exceptionobjekt kompatibel ist, zur aufgetretenen Ausnahme.
  • Falls die Ausnahme und dass Objekt kompatibel sind, hakt das Programm dort ein und die Exception wird gefangen.
  • Wenn die Exception nicht zum Objekt des catch-Blockes passt, geht sie zum Nächsten und prüft weiter.
  • Spätestens bei einem Objekt der Superklasse „Exception“ ist Schluss.
    Denn dieses Objekt ist abstrakt und somit kompatibel zu jeder Exceptionart.

Zusammenfassung:

  • Polymorphie besagt, dass du Objekte auch in abstrakteren bzw. allgemeineren Datentypen halten kannst.
    Und dadurch kannst du eine Java Exception auf unterschiedliche Art fangen.
  • Die Catch-Blöcke werden dabei von oben nach unten durchlaufen.
    Und falls das Programm feststellt, dass eine Exception in einen der Blöcke richtig gefangen wird – hakt es dort ein.
  • Da der Datentyp „Exception“ der abstrakteste ist, kannst du jede Exception mit einem Objekt der Klasse Exception fangen.

Ähnliche Beiträge

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]

So kannst du gelöschte Java Projekte oder Dateien in Eclipse wieder herstellen

Wahrscheinlich passiert es jedem einmal, dass man versehentlich Dateien löscht. Und dann? Die Wut ist riesig, weil man ja alles nochmal schreiben muss. In Eclipse hast du die Möglichkeit sämtliche Dateien wieder herzustellen. In diesem Beitrag möchte ich dir demonstrieren, wie du gelöschte Java Klassen, Dateien, Projekte oder Packages wieder herstellen kannst.

Java Übung 16 – Bestimme den größten gemeinsamen Teiler

Java Übung Teiler

In dieser Java Übung möchte ich, dass du den größten gemeinsamen Teiler zwei Zahlen ermittelst. Ich möchte, dass du das Ganze mit einer while-Schleife umsetzt. Und wie? Du legst eine neue Klasse „GGT“ (größter gemeinsamer Teiler) an. In diese Klasse implementierst du eine Klassenmethode „berechneGGT“. Diese erwartet zwei Argumente vom Datentyp Integer.

Die vier verschiedenen Zahlensysteme in der Java Programmierung

Java Zahlensysteme

Java Zahlensysteme – Was soll das? In sämtlichen Programmiersprachen werden Zahlen in Variablen abgespeichert. Wenn du dir die einzelnen primitiven Datentypen in Java einmal anschaust – wirst du feststellen – dass die Masse der Datentypen Zahlen annehmen und speichern können. Zahlen und die Mathematik dahinter spielen in der Programmierung eine sehr große Rolle. Ganz am […]

Beim Aufruf werden Java Methoden auf dem Stack gestapelt

Java Methoden gestapelt

Java Methoden werden beim Aufruf gestapelt. Und jedes Element auf dem Stapel nimmt Speicherplatz weg. Und manchmal ist es so, dass der Stapel richtig hoch wird und dann…. Ja was passiert eigentlich dann? Betrachten wir einmal ein Computerspiel. Irgendeines. In diesem Computerspiel gibt es Vögel, welche abgeschossen werden sollen. Was bedeutet das denn genau? Beim […]

So kannst du in den Java Klassen Attribute anlegen

Java Klassen Attribute

Die bisherigen Java Klassen in unserem Einführungsbeispiel besitzen noch keine Attribute. Das ändern wir und legen diese jetzt an. In diesem Beitrag erfährst du: Warum Variablen in deinen Klassen eine entscheidende Rolle spielen. Was es bedeutet eine Variable zu deklarieren. Wo du Attribute in den Java Klassen anlegen darfst und wo nicht. Wie du durch […]

Java lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

So verwendest du in Java try und catch Blöcke

Java try und catch

Ich bereue lieber die Dinge, die ich getan habe – als die Dinge, welche ich gar nicht erst versucht habe. Ja ich würde mich als den typischen „try-and-error-Menschen“ bezeichnen. Was ich will, probiere ich einfach aus und schaue dann erst was passiert. So etwas wie Pläne kenne ich eigentlich nicht. Und wenn ich mal einen […]