Java Exceptions fangen: Mehr Möglichkeiten durch Polymorphie

Schlagwörter: Java Exceptions, Java Polymorphie, Java Programmierung

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.

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.

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:

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“.

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.

• 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.