Skip to main content

Java Exceptions Handling – Fehler- und Ausnahmenbehandlung in Java

Java Exceptions Handling umfasst den richtigen Umgang mit Ausnahmen und Fehlern.

Wie geht das?
Und braucht man so etwas wirklich?

Vielleicht sagst du jetzt:

„Brauch ich nicht. Ich mache niemals Fehler.“

Doch…
Bei der Java Fehlerbehandlung geht es nicht ausschließlich nur um deine Programmierfehler.
Es geht auch um falsche Nutzereingaben, Hardware- und Ablauffehler.

Und deshalb – Lass uns in diesem Beitrag einmal anschauen:

  • Welche Fehler in einem Java Programm auftreten können.
  • Wie du dir eine Fehlerbehandlung in Java theoretisch vorstellen kannst.
  • Und wie die praktische Umsetzung aussehen würde.

In einem Java Programm können alle möglichen Fehler auftreten

Hier ein paar Beispiele:

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		int[] zahlen = new int[1];//neues Integer-Array mit einm Fach
		zahlen[0] = 1; //Belegung des erstes Faches mit der Zahl 1

		//For-Schleife durchläuft die ersten 10-Fächer des Arrays
		for (int i = 0; i <= 10; i++) {
			System.out.println("Fach " + i + ": " + zahlen[i]);
		}
	}
}

In der main-Methode wird ein neues Array angelegt.
Dieses Array hat eine Länge von 1.
Somit bietet es Platz für eine einzige Zahl.
Und zwar im Fach Null.

Okay – Also habe ich, in das Fach Null den Wert 1 platziert.

Soweit ist alles gut.
Doch dann….
Habe ich eine For-Schleife angelegt, welche die ersten zehn Fächer des Arrays durchlaufen soll.
Und im Rumpf der Schleife sollen mir dann die Werte der einzelnen Fächer auf der Konsole ausgegeben werden.

Am besten ist es, du schreibst den Code ab und probierst es selbst einmal aus.
Klick dann auf „RUN“ und schau nach, was passiert.

Und?
Es kommt zur Fehlermeldung.

Warum?
Einfach aus dem Grund, da die For-Schleife 10 Fächer durchlaufen soll.
Das Array hat aber nur ein Fach.

Als Fehlermeldung steht dann:

„Exception in thread „main“ java.lang.ArrayIndexOutOfBoundsException“

Java Exceptions Index out of Bounds

Oder ein zweites Beispiel:

Beispiel 2: Die Division durch Null.

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		int dividend = 10;
		int divisor = 0;

		System.out.println(dividend / divisor);
	}
}

Probiere auch diesen Code einmal selbst aus.
Und? Wieder erscheint eine Fehlermeldung.

Es können aber noch mehr Fehler auftreten.

Zum Beispiel durch Nutzereingaben:
Angenommen du möchtest in deinem Programm das Alter des Nutzers prüfen.
Dazu forderst du den Nutzer auf, sein Alter anzugeben.
Locker wie er ist – schreibt dieser statt des Alters, seinen Namen in das Feld.

Und bei diesem eingegebenen Textwert (Namen), kann dein Programm kein Alter finden.
Also – Fehler.

Oder dein Programm speichert bestimmte Daten lokal auf der Festplatte ab.
Und beim Neustart will das Programm jetzt die alten Daten anfordern.
Jetzt will es Laden….
Und auf einmal ist die Datei nicht mehr da.
Was dann?

Bis jetzt ist es so, dass durch die Fehlermeldungen das Java Programm abstürzen würde.

Es kommt nämlich nicht nur zu einer Fehlermeldung auf der Konsole.
Nein – das Programm wird beendet.
So wie hier.

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		int dividend = 10;
		int divisor = 0;

		System.out.println(dividend / divisor);
		System.out.println("Test");// Diese Ausgabe erscheint nicht.
	}
}

Die zweite Bildschirmausgabe enthält keinen Fehler.
Ohne die Divisionsanweisung sollte somit der zweite Teil des Programmes ausgeführt werden.

Das klappt aber nicht.
Sobald das Programm irgendeinen Fehler erkennt – kommt es zur Meldung und zum Programmabsturz.

Also was kannst du machen?

Java bietet dir für die Fehlerbehandlung eine spezielle Klasse an.

Und diese Klasse nennt sich Throwable.
Wie sämtliche andere Klassen, findest du die Dokumentation in den Java API Docs.

Ganz oben siehst du die Importanweisung und die Vererbungsstruktur.
Wie sämtliche anderen Java Klassen erbt auch diese Klasse von der Klasse Objekt.

Java Exceptions Klasse Throwable

Du siehst auch, dass diese Klasse zwei Kindklassen besitzt.

  1. Zum einen die Klasse Error bzw. Fehler.
  2. Und zum anderen die Klasse Exceptions bzw. Ausnahme.

Java Exceptions Vererbungshierarchien

Worin liegt jetzt der Unterschied zwischen einem Fehler und einer Ausnahme?

Ein Fehler ist immer etwas Generelles.
Das würde bedeuten, dass dies immer auftritt.
Eine Ausnahme tritt nur in bestimmten Fällen auf.

Wenn du dir die eingangs erwähnten Beispiele mal so anschaust- handelt es sich um Fehler oder um Ausnahmen?
Falsche Benutzereingabe führt zum Programmabsturz:
Dies ist eine Ausnahme – denn die richtige Eingabe führt zu einem weiterhin stabilen Programmablauf.
Wenn die Benutzereingabe ein Fehler wäre – dann würde jede Eingabe zum Absturz führen.

Bei allen anderen Beispielen ist es genauso:
Nicht die Division führt generell zum Programmabsturz.
Nein – Nur die Division durch Null führt zum Absturz.
Also wird auch hier eine Ausnahme behandelt.

Wir sprechen also bei sämtlichen auftretenden Beispielen, von Ausnahmen anstatt von Fehlern.
Und deshalb solltest du das Wort „Fehlerbehandlung“ durch das Wort „Ausnahmebehandlung“ ersetzen.

Schauen wir uns die Kindklasse Exceptions genauer an

Klicke dazu einmal auf die Unterklasse in den API Docs und du wirst direkt zur Dokumentation geleitet.

Java Exceptions Klasse Throwable Klasse Exceptions

Oben siehst du wieder die Klassenhierarchien.
Die Klasse Exceptions erbt von Throwable.
Und diese wiederum erbt von Objekt.

Direkt darunter, siehst du die einzelnen Kindklassen von Exceptions.

Java Exceptions Klasse Exception Vererbung

Ne ganze Menge, oder?
Es gibt eben jede Menge verschiedene Ausnahmen.
Und all diese werden entsprechend separat behandelt.

Aber es geht noch weiter.
Denn auch diese einzelnen Kindklassen, haben wiederum speziellere Kindklassen.

Warum so detailliert?
Und warum bietet Java nicht ganz einfache Standards an?
Schließlich ist doch die ganze Ausnahmebehandlung nur so eine Art Beiwerk in einem Programm.

Die Ausnahmebehandlung ist die Aufgabe des Entwicklers und nicht Aufgabe von Java

Stell dir vor – Java würde die Ausnahmebehandlung „Division durch Null“ in der Standardbibliothek anbieten.

Und du hättest eine grafische Oberfläche in einem Programm.
Dein Nutzer müsste zwei Zahlen in einem Feld eingeben und diese würden dann mit einander dividiert werden.
Eben eine Art Taschenrechner.

Jetzt kommt es zur Ausnahme.
Also würde in einer grafischen Oberfläche ein Pop-Up-Fenster aufblinken.
Und der Nutzer würde auf seine Falscheingabe hingewiesen werden.
Diese grafische Oberfläche müsste aber vom Design, von den Farben und vom Logo zum restlichen Programm passen.

Es ist ganz logisch, dass Java dies nicht standardisiert für sämtliche Programme bereitstellen könnte.
Du als Java Programmierer musst dich eben schon selbst, um deine Exceptions kümmern.

Und das machen wir jetzt auch.

Java Exceptions Handling am klassischen Beispiel.

Nehmen wir den Klassiker – die Division durch Null.

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		int dividend = 10;
		int divisor = 0;

		System.out.println(dividend / divisor);
	}
}

Verfeinern wir doch das Ganze.
Und legen richtige Benutzereingaben mit dem Scanner an.

import java.util.Scanner;//Importanweisung für den Scanner

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		Scanner eingabe = new Scanner(System.in);//neues Scannerobjekt
		
		System.out.println("Gib eine Zahl für den Dividenden");
		int dividend = eingabe.nextInt();//Dividend wird gespeichert
		
		System.out.println("Und jetzt gib den Divisor ein");
		int divisor = eingabe.nextInt();//Divsior wird gespeichert

		System.out.println(dividend / divisor);
	}
}

Wenn du jetzt auf „RUN“ klickst – läuft die Show. 🙂
Und zwar nur solange – bis du auf die Idee kommst, als Divisor die 0 einzugeben.
Dann endet das Ganze in einem Programmabsturz.

Was kannst du jetzt tun?
Eine Alternative wäre die Null abzufangen.
Und zwar mit einem if und else Block.
So etwas haben wir in den Übungen auch regelmäßig gemacht.
Das würde dann so aussehen:

import java.util.Scanner;//Importanweisung für den Scanner

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		Scanner eingabe = new Scanner(System.in);//neues Scannerobjekt
		
		System.out.println("Gib eine Zahl für den Dividenden");
		int dividend = eingabe.nextInt();//Dividend wird gespeichert
		
		System.out.println("Und jetzt gib den Divisor ein");
		int divisor = eingabe.nextInt();//Divsior wird gespeichert
		
		if (divisor !=0){
		System.out.println(dividend / divisor);
		}
		else {
			System.out.println("Eingabe ungültig!");
		}
	}
}

Und jetzt funktioniert es solange bis ein User auf die Idee kommt, keine Zahlen einzugeben.
Statt der 5 gibt dieser Nutzer dann den Text „Fünf“ ein.
Was dann? – Klar nächster Fehler.

Du könntest jetzt sämtliche if / else Kontrollstrukturen aufstellen und versuchen jede Ausnahme abzufangen.

Doch es geht natürlich einfacher.
Und zwar mit Exceptions.

Und wie?

Beim Exception Handling benötigst du zwei Codeblöcke.

Der erste Codeblock beginnt mit dem Keywort try.
Hier platzierst du deine Anweisungen, welche ausgeführt werden sollen.

Der zweite Codeblock beginnt mit dem Keywort catch.
In diesem platzierst du all das, was passieren soll – falls eine Ausnahme auftritt.

Außerdem musst nach dem Keywort catch eine Variable vom Datentyp Exception anlegen.
In dieser wird dann die Ausnahme gespeichert.
Und du kannst diese auch später auswerten

import java.util.Scanner;

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		Scanner eingabe = new Scanner(System.in);

		System.out.println("Gib eine Zahl für den Dividenden");
		int dividend = eingabe.nextInt();

		System.out.println("Und jetzt gib den Divisor ein");
		int divisor = eingabe.nextInt();

		try {
			System.out.println(dividend / divisor);
		} catch (Exception e) {
			System.out.println("Falsche Eingabe!");
		}
	}
}

So fertig.
Wenn du jetzt die 0 als Divisor übergeben würdest, würde das Programm nicht abstürzen.
Stattdessen kommt es zur Fehlermeldung bzw. Ausnahmebehandlung.

Doch probiere mal einen Textwert einzugeben.
Und klicke dann auf „RUN“.

Na was passiert?
Wieder ein Fehler.
Denn die Anweisungen int dividend = eingabe.nextInt(); oder int divisor = eingabe.nextInt(); wurden noch nicht abgefangen.

Bis jetzt wird nur die Ausnahme bei der Division behandelt.
Die Ausnahme bei der Eingabe steht nicht im try-Block und wird somit nicht behandelt.

Also was wäre noch zu tun?
Klar den try-Block einfach weiter oben ansetzen.

import java.util.Scanner;

public class JavaFehlerBehandlung {

	public static void main(String[] args) {
		Scanner eingabe = new Scanner(System.in);

		try { // Beginn try-Block
			System.out.println("Gib eine Zahl für den Dividenden");
			int dividend = eingabe.nextInt();
			System.out.println("Und jetzt gib den Divisor ein");
			int divisor = eingabe.nextInt();
			System.out.println(dividend / divisor);
		} // Ende try-Block

		catch (Exception e) {
			System.out.println("Falsche Eingabe!");
		}
	}
}

Jetzt werden sämtliche Ausnahme bei der Eingabe und Verarbeitung abgefangen.
Klicke auf „RUN“!
Und läuft, oder?

Zusammenfassung:

  • In Java können Fehler und Ausnahmen behandelt werden.
  • Von einem Fehler spricht man, wenn etwas generell und immer auftritt.
  • Von einer Ausnahme spricht man, wenn das Programm eigentlich stabil läuft und es nur, beim Auftreten einer bestimmten Ursache, zum Abbruch kommt. Zum Beispiel bei einer Falscheingabe.
  • Programmfehler und auch die Ausnahme führen immer zum Programmabsturz.
  • Die Ausnahmen oder Exceptions kannst du aber behandeln.
    Dazu musst du einen try-Block einsetzen.
    Und in diesen Block platzierst du alle Anweisungen, welche ausgeführt und überprüft werden sollen.
    Also all das – was passieren soll, falls keine Ausnahme auftritt.
  • Im zweiten Block, den catch Block, platzierst du all das – was passieren soll – falls es zur Ausnahme kommt.
    Außerdem musst du im catch Block ein Objekt vom Datentyp Exception anlegen, welches die Ausnahme entgegen nimmt.
  • Somit kannst du in Java Exceptions abfangen und behandeln.

Ähnliche Beiträge

10 ganz nützlichen Feature der Klasse Java Math

In diesem Beitrag geht es um eine spezielle Java Klasse. Die Klasse nennt sich Java Math. Diese ist in der Standardbibliothek von Java enthalten. Warum solltest du diese Klasse kennen? Die Math Klasse bietet dir einen Menge Methoden an, welche zur Berechnung von mathematischen Gleichungen ganz hilfreich sind. Aber auch für Nichtmathematiker ist etwas dabei. […]

So kannst du deine Eclipse Oberfläche anpassen

Eclipse anpassen

In diesem Beitrag möchte ich dir zwei ganz nette Features von Eclipse vorstellen. Es geht um Views und um Perspektiven. Wie du schon weißt, besteht Eclipse aus einer grafischen Oberfläche. Und in dieser Oberfläche stehen dir verschiedene Views zur Verfügung. Was ist so ein View?

8 Java Datentypen, die du kennen solltest

Java Datentypen

Java Datentypen Ich gebe zu, ich hasse dieses Thema. Denn es ist eigentlich nichts weiter als graue Theorie. Dennoch müssen wir dieses Thema behandeln. Um schnell in das Thema zu kommen, stelle ich dir eine Übersicht aller primitiven Datentypen zur Verfügung. Wieso primitive? Es gibt außer den primitiven Datentypen, noch Referenztypen. Und diese Referenztypen sind […]

Ende vom Java Blog?

Falls du hier schon länger dabei bist, wird dir aufgefallen sein – dass kaum noch Beiträge veröffentlicht werden. Das tut mir wirklich leid und dafür möchte ich mich auch entschuldigen. Ich weiß, dass Einige unter Euch den Java-Blog wirklich lieben. Aber es ist verdammt schwierig so ein aufwendiges Thema – stilvoll, unterhaltend und methodisch umzusetzen. […]

So kannst du in drei einfachen Schritten Java Arrays dynamisch vergrößern

Java Arrays vergrößern

Es ist der 31.März 1727. Es ist ein Montag. Die Welt nimmt Abschied von einem sehr bedeutenden Weltveränderer. Seine Sichtweisen beeinflussen, heute noch, die Forschung und Entwicklung im Bereichen der Physik und Chemie. Ja selbst unser aller Leben – unsere Sicht auf die alltäglichen Dinge – wurden durch seine Denkstöße revolutioniert. Dieser große Vorreiter starb […]

Java Vererbung – Die Hierarchien richtig planen

Java Vererbung Hierarchien

Java Vererbung hat nichts mit Biologie zu tun. Die Genetik besagt, dass bestimmte Merkmalsausprägungen von den Eltern auf die Kinder übergehen. Solche Merkmalsausprägungen sind: die Hautfarbe die Haarfarbe die spezifische Größe und weitere körperliche Merkmale. Und in Java – was ist da Vererbung? Lass es uns herausfinden. Was erwartet dich in diesem Beitrag? Zuerst schauen […]

Java Übung 19 – Zähle die Kommastellen

Java Übung Kommastellen Zählen

In dieser Java Übung möchte ich, dass du eine Methode zum Zählen von Kommastellen schreibst. Lege dazu eine Klasse „KommaZahl“ an. Diese Klasse enthält die statische Methode „zaehleKommaStellen“, welche eine Kommazahl als übergebenen Parameter erwartet.

Java Methoden mit variabler Argumentenanzahl – VarArgs

Java Methoden mit variabler Argumentenanzahl VarArgs

Du kennst das noch. Kopfrechnen und zwar auf Zeit. So etwas ist das Standardprogramm in den Schulklassen 1 bis 5. Irgendwann, in Klasse 6 oder 7, kommt der Taschenrechner ins Spiel und Kopfrechnen ist aus dem Schulalltag gestrichen. Schade eigentlich. Dabei kann man diese Disziplin auch wunderbar in kleinen Spielen unterbringen. Ich erinnere mich noch: […]

Der Java Datentyp boolean im Interview

Java boolean

Nein, ich bin nicht verrückt. Aber… Neulich traf ich zufällig den Java Datentyp boolean. 🙂 Er erklärte sich bereit, mir ein Interview zu geben. In diesem Interview geht es um die Werte, welcher dieser Wertetyp annehmen kann. Und in diesem Zusammenhang geht es auch um Logik. Also lassen wir uns doch die Logik vom direkten […]