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

So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen.

Java Arrays verrechnen

Wie kann man Werte aus zwei oder mehreren Java Arrays miteinander verrechnen? Zum Beispiel: Du möchtest alle Werte des ersten Arrays mit allen Werten des zweiten Arrays addieren Oder du möchtest die Summe aus beiden Arrays wissen und erst dann diese miteinander addieren. Was erwartet dich in diesem Beitrag? Zuerst werde ich dir zeigen, wie […]

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

Java Übung 17: Char-Zeichen mit For-Schleife

Java Übung Char Zeichen For Schleife

In dieser Java Übung werden wir uns die Zeichen des Character Datentypen näher anschauen. Die einzelnen Zeichen sollen auf der Konsole ausgegeben werden. Und wie? Das ganze sollst du mit einer For Schleife machen. Erstelle deshalb eine Klasse „CharZeichen“. In dieser Klasse implementierst du dann eine Klassenmethode, namens „gibZeichen“. Und im Methodenrumpf durchläuft eine For-Schleife […]

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 Duales Zahlensystem – Binäre Zahlen in Java umwandeln

Java Dual System

Das duale Zahlensystem hat viele Bezeichnungen. Oft wird auch es Dualsystem oder Binärsystem genannt. Es besteht aber immer aus 2 Zahlen. Man verwendet oft die Zahlen 0 und 1. Es können aber auch sämtliche anderen Zahlenpaare sein. Zum Beispiel 7 und 175 sind für sich genommen, auch ein normales Zahlenpaar und somit ein Dualsystem. Mit […]

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

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?

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]