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

Overriding und Vererbung – So lassen sich Java Methoden überschreiben

Java Methoden überschreiben

In Deutschland entstehen jeden Tag tolle Geschichten. So wie diese hier…. Die größte Turmuhr der Welt, die Makkah Clock, steht in Saudi – Arabien. Und zwar direkt in Mekka. Hier ein paar Eckdaten zur Uhr: Höhe des Turmes 601 m. Das Ziffernblatt der Turmuhr hat einen Durchmesser von 43 Meter Die Länge des Minutenzeigers beträgt […]

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 […]

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

So legst du Utility Klassen in Java an

Java Utility Klassen

Utility Java Klassen – was ist das? Man nennt diese auch Hilfsklassen von Java. Diese Utility Klassen sind Java Klassen, welche lediglich Methoden und Konstanten anbieten. Am Beispiel: Die Klasse Math ist so eine klassische Utility Klasse. Wozu braucht man solche Klassen? Diese Klassen sind so etwas wie ein Werkzeugkoffer für jedes Java Programm. Hier […]

So organisierst und verwaltest du ganz bequem deine Java Projekte

Du kennst das auch. Denn du bist ja fleißig. Und weil du so fleißig bist, hast du mitunter auch mehrere Java Projekte gleichzeitig laufen. Und dann kommt es vor, dass du enorm viele Java Projekte am Laufen hast. Und dein Package-Explorer wird extrem unübersichtlich. In diesem Beitrag möchte ich dir zwei Varianten vorstellen, wie du […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

So kannst du Java Arrays mit for Schleife füllen und auslesen

Java Arrays For Schleife

Wir haben in einem anderen Beitrag bereits über Java Arrays gesprochen. So ein Array speichert Zahlen, Texte oder Objekte in eine Art Liste. Und dann kannst du ganz bequem über den Index das Array füllen und die bereits enthaltenen Werte abrufen. Ganz bequem? So, wie ich dich aus dem letzten Beitrag entlassen habe, war das […]

Java Übung 11 – Java Objekte in Java Methoden übergeben

Java Übung Java Methoden Objekte

In dieser Java Übung möchte ich dir zeigen, dass du auch in Klassenmethoden auf Objekte und deren Instanzvariablen zugreifen kannst. Schau dir dazu einmal diesen Java Code an. public class Umwandlung { private int x; public int getX() { // getter Methode return x; } public void setX(int x) { // setter Methode this.x = […]

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]