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

Java lernen – 10 nützliche Tipps für Java Anfänger

Java Lernen Anfänger

Wenn du die Programmiersprache Java lernen möchtest, bist du hier prinzipiell erst einmal richtig. Und wenn du es wirklich ernst meinst und in die Java Programmierung einsteigen möchtest, solltest du auch meinen kostenlosen Java Kurs beanspruchen. Wenn du dabei bist, bekommst du: Eine Lektion pro Woche zu den Basics. Hier geht es um die ersten […]

So einfach lassen sich Java Strings umkehren

Java Strings umkehren

Kennst du noch das Lied „ANNA“ von Freundeskreis? Da hieß es: Du bist von hinten, wie von vorne A-N-N-A. Solche Namen oder Wörter, welche von hinten nach vorne gelesen – die gleiche Bedeutung haben, nennt man Palindrome. Anna, Ehe oder Ebbe sind recht kurze Palindrome. Aber auch längere zusammengesetzte Palindrome kennt die deutsche Sprache: Regallager […]

So lassen sich aus Java Klassen Instanzen erstellen

Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen. Im Einführungsbeispiel hast du bereits gelernt, wie du: Instanzvariablen bzw. Attribute anlegst Wie du aus einer normalen Java Klasse eine Programmstart Klasse machst In diesem Artikel erfährst du: Was Objekte bzw. Instanzen sind. Wie sich Objekte zusammensetzen. Wo und wie du Instanzen aus Java Klassen […]

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag

Eine Java Konsoleneingabe machst du über den Scanner

Es wird Zeit für die erste Java Konsoleneingabe. Und diese Eingaben machst du über den Java Scanner. Was ist das? Der Scanner ist eine vorgefertigte Java Klasse, welche Java mit seiner API anbietet. Das heißt du musst nichts selbst erschaffen. Du musst nur wissen, wie du darauf zugreifst. Erst einmal musst du einen Scanner anlegen. […]

Heap & Stack – Die Speicherverwaltung in Java

Java Speicher

Java nutzt eine interne Speicherverwaltung. Eigentlich sind es mehrere. Uns interessieren lediglich zwei. Da das Thema Speicherverwaltung recht umfangreich ist, habe ich dir im Folgenden einmal die wichtigsten Artikel zusammengestellt. Die zwei Speichersysteme von Java Java Methoden werden auf dem Stack gestapelt. Der Speicher auf dem Java Methoden zu Hause sind, nennt sich Stack Speicher. […]

So kannst du Java installieren

Java installieren

Bevor du loslegst und deine ersten Java Programme schreibst, benötigst du die entsprechende Arbeitsumgebung. Du solltest also Java installieren. Und diese Arbeitsumgebung beinhaltet dann Bibliotheken für die einzelnen Java-Standard-Klassen, Dateien um deine Programme auszuführen. Dateien um deine Programme zu packen, Logische Verzeichnisstrukturen

Der wichtige Unterschied zwischen Java Methoden

Java Methoden Unterschied

Jetzt machen wir Nägel mit Köpfen. Dieses Sprichwort stammt aus den Anfängen des Industriezeitalters. Denn früher wurden Nägel nicht industriell, sondern per Hand gefertigt. Und da kam es schon einmal vor, dass versehentlich Nägel ohne Kopf produziert wurden. Was blieb ist das Sprichwort „Nägel mit Köpfen“ Und dieses steht sinngemäß für eine schnelle, qualitativ hochwertige […]

Drei Möglichkeiten um Java Objekte zu zerstören

Java Objekte zerstören

Java Objekte leben genau solange, wie eine Referenzvariable auf sie zeigt. Wenn dieser Zeiger nicht mehr existiert, wird dieses Objekt aufgeben. Und wenn dieses Objekt erst einmal aufgegeben wurde, dann kommt der Garbage Collector und entsorgt dieses. Aber wie kannst du nun am Sinnvollsten Objekte aufgeben? Lass es uns herausfinden.

Lassen wir Java rechnen – Die Rechenoperationen für Variablen

Java rechnen

Ich liebe Mathe. In der Biographie „Der Mann, der die Zahlen liebte“, stellt Paul Hoffmann das Mathematikgenie Paul Erdös vor. Erdös war eines der größten Genies des 20 Jahrhunderts. Er arbeitete mit zahlreichen Wissenschaftlern zusammen und verfasste durchschnittlich mehr Publikationen im Jahr, als andere Mathematiker im ganzen Leben. Da Erdös sich mit sehr vielen Theoremen […]