Skip to main content

So verwendest du in Java try und catch Blöcke

Ich bereue lieber die Dinge, die ich getan habe – als die Dinge, welche ich gar nicht erst versucht habe.

Ja ich würde mich als den typischen „try-and-error-Menschen“ bezeichnen.
Was ich will, probiere ich einfach aus und schaue dann erst was passiert.

So etwas wie Pläne kenne ich eigentlich nicht.
Und wenn ich mal einen Plan zu einer bestimmten Idee oder einem Projekt hatte, bin ich gnadenlos damit gescheitert.

Ich musste erkennen, ich bin kein Planer oder Planmensch.

Natürlich ist nicht immer alles vom Erfolg gekrönt.
Aber spätestens seit dem Buch „Gegen den Schwarm“ von Matthias Kolbusa, weiß ich:

„Niederlagen sind wertvoller als Siege.“

Denn in jeder Niederlage steckt enormes Wachstums- und Lernpotential.
Somit begrüße ich auch Niederlagen, als erheblich wertvollen Teil des Gesamterfolges.

Das Java try und catch Prinzip setzt eigentlich auch beim einfachen Ausprobieren an.
Das Programm probiert einen Codeblock aus und falls es zu einer Ausnahme kommt – wird diese gefangen bzw. abgefangen.

Doch lass mich dies am Beispiel zeigen.

Den Java Try und catch Block am Beispiel einer einfachen Mathematikaufgabe.

Dies ist der Klassiker – die Division durch Null.
Ich hatte dieses Beispiel auch schon einmal in einem anderen Beitrag zur Exception-Einführung aufgenommen.
Dieser Beitrag soll tiefer in die Materie eindringen.
Denn diesmal sollen mehrere unterschiedliche Ausnahmen behandelt werden.

Für diesen Beitrag habe ich eine neue Klasse, namens „TryUndCatchDemo“, angelegt.
Da ich das Programm gleich aus dieser Klasse heraus starten möchte, habe ich die main-Methode implementiert.

public class TryUndCatchDemo {

	public static void main(String[] args) {

	}
}

Jetzt bekommt die Klasse noch zwei schicke lokale Variable vom Datentyp Integer.
Und zwar einmal den Dividenden und zum anderen den Divisor.

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int dividend;//Dividend vom Datentypen Integer
		int divisor;//Divisor vom Datentypen Integer
		
	}
}

Beim Programmstart soll eine Bildschirmausgabe erfolgen, welche mir das Ergebnis aus Dividend/Divisor zurückgibt.

public class TryUndCatchDemo {

	public static void main(String[] args) {
		int dividend;
		int divisor;
		
		System.out.println(dividend / divisor );//Bildschirmausgabe liefert Ergebnis der Division
	}
}

Falls du dieses Beispiel bis hierher selbst vollzogen hast….
Dann siehst du sicherlich die Fehlermeldung am linken Rand.

Java Try und Catch am Beispiel

Da lokale Variablen immer initialisiert sein müssen, musst du beiden Variablen jeweils einen Wert zuweisen.

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
		
		System.out.println(dividend / divisor );//Bildschirmausgabe: Ergebnis aus 10 geteilt durch 0
	}
}

Also dann…
Die Division durch Null ist nicht möglich.
In der Mathematik würde man so eine Aufgabe als nicht lösbar bezeichnen.

Und auch Java gibt dir bei diesem Code – eine Exception zurück.
Klicke einmal auf „RUN“ und probiere dieses kleine Programm einmal selbst aus.


Java-Try-und-Catch-Division-durch-0-Exception

Wie erwartet – kam es zur Exception.
Unten in der Ausgabekonsole – kannst du nachlesen, um was für eine Exception es sich genau handelt.
In diesem Fall ist es eine „java.lang.ArithmeticException“.

Also….
Falls du irgendwann einmal diese Ausnahmemeldung liest, weißt du irgendwo wurde durch 0 dividiert.

Jetzt lass uns diese Exception einmal fangen.

Fangen hört sich niedlich an, oder?
Aber genauso ist die Bezeichnung.

Exceptions oder Ausnahmen werden gefangen bzw. abgefangen.
Und zwar mit dem Java Keywort catch.

Dazu wird ein sogenannter Catch-Block in der Methode angelegt.
So wie hier auf dem Bild.


Java Catch Block

  • Der weiße Block ist die Klasse – begrenzt durch zwei geschweifte Klammern.
  • Innerhalb der Klasse befindet sich die main-Methode.
    In diesem Bild ist diese blau und wird ebenfalls durch zwei Klammern begrenzt.
  • Und innerhalb der main-Methode platzierst du deinen Catch-Block.
    In diesem Bild ist dieser Lila dargestellt.

Also dann:

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

		System.out.println(dividend / divisor);// Bildschirmausgabe 10 /0
													
		 catch (ArithmeticException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
	}
}
  • Zuerst das Keywort catch.
  • Dann in die Klammern ein Objekt der Klasse „ArithmeticException“.
    Ich nenne diese eNull – für Division durch Null.
  • Und dann eine Anweisung, welche ausgeführt werden soll – sobald die Exception gefangen wurde.
    Hier kannst du sämtliche Programmlogik platzieren – zB. If-else Konstrukte anlegen, Schleifen durchlaufen oder neue Methodenaufrufe implementieren.
  • In diesem Beispiel kommt es zu einer einfachen Bildschirmausgabe.
    Und zwar: „Division durch 0 ist nicht möglich.“

Soweit – so gut.
Dennoch fehlt jetzt noch der Try-Block.
Ich sagte ja bereits:

„Das Java try und catch Prinzip besteht aus Ausprobieren und Abfangen.“

Der Try Block umschließt den ganz normalen Code, welcher ausgeführt werden soll.

Also all das, was dein Java Programm probieren soll.

Und ausprobieren soll es – die Division durch Null.
Also packst du den Try-Block um die Bildschirmausgabe mit der Division.
So wie hier im Bild.

Java-Try-und-Catch-Blöcke

  • Auch dieser try Block beginnt mit einem Java Keywort try.
  • Dann folgt die öffnende Klammer.
  • Und im Code-Block packst du alles rein, was normalerweise ausgeführt werden soll.
  • Die schließende Klammer kennzeichnet dann das Ende des try-Blockes.

Hier der Code zum Mitschreiben:

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");
		}
	}
}

Probiere auch dieses Programm einmal aus.
Und läuft?
Die Division durch Null wird somit abgefangen.

Lass uns dieses Programm erweitern.

Und zwar durch eine Bildschirmeingabe.
Denn die Zahlen sollen nicht vorbelegt sein.

Stattdessen soll dich das Programm zur Eingabe bestimmter Zahlen auffordern.
Und dann werden diese automatisch mit einander verrechnet und das Ergebnis als Bildschirmausgabe präsentiert.

Die Eingabe der Zahlen machst du mit einem Scanner-Objekt.

Dazu legst du zwei neue Scannerobjekte an, welche die Eingabe für den Dividenden und Divisor speichern sollen.

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

public class TryUndCatchDemo {

	public static void main(String[] args) {
		Scanner scanDividend = new Scanner (System.in);//Neues Scannerobjekt speichert den Dividend
		Scanner scanDivisor = new Scanner (System.in);//Neues Scannerobjekt speichert den Divisor
		
		int dividend = scanDividend.nextInt();//Speichert die Bildschirmeingabe zum Dividenden 
		int divisor = scanDividend.nextInt();//Speichert den Divisor in die Variable

		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe des Ergebnisses
		} 
		catch (ArithmeticException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
	}
}

Dazu noch die jeweilige Aufforderung zur Eingabe.
Somit weißt du zur Laufzeit des Programmes auch, welche Werte du gerade eingibst.

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

public class TryUndCatchDemo {

	public static void main(String[] args) {
		Scanner scanDividend = new Scanner (System.in);//Neues Scannerobjekt speichert den Dividend
		Scanner scanDivisor = new Scanner (System.in);//Neues Scannerobjekt speichert den Divisor
		
		System.out.println("Dividend:");//Eingabeaufforderung für den Dividenden
		int dividend = scanDividend.nextInt();//Speichert die Bildschirmeingabe zum Dividenden 
		System.out.println("Divisor:");//Eingabeaufforderung für den Divisor
		int divisor = scanDividend.nextInt();//Speichert den Divisor in die Variable

		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe des Ergebnisses
		} 
		catch (ArithmeticException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
	}
}

Und schick?
Probiere es aus!
Gib zwei beliebige Zahlen, wie beispielsweise 10 und 2 ein.
Es wird ein ganzzahliges Ergebnis zurückgegeben.

Java Try und Catch Mathematikaufgabe

Probiere einmal, in einem zweiten Durchlauf, die 0 als Divisor aus!
Und klappt auch.
Keine Exception, oder?
Stattdessen bekommst du die Fehlermeldung angezeigt, welche im Catch-Block vereinbart wurde.

So und jetzt – probiere einmal aus – die Null einzugeben.
Nein, nicht die Zahl 0.
Schreibe das Wort: Null.

Java Try und Catch Exceptions fangen

Boah, neue Exception.

Du musst jede Exceptionsart einzeln fangen.

Und jede will einen einzelnen catch-Block für sich haben.
So ist das mit den Ausnahmen. Sie sind eitel. 🙂

Also dann.
Die Eingabe eines Textwertes bzw. Strings verursachte eine „InputMismatchException“.

Java-try-und-catch-InputMismatchException

Dann lass uns diese Exception einmal separat behandeln.

Und das ist jetzt ganz einfach.
Denn du benötigst lediglich einen neuen catch-Block.

  • In den Klammern legst du eine neue Variable vom Datentyp InputMismatchException an.
  • Die Klasse „InputMismatchException“ musst du über die Importanweisung importieren.
  • Dann noch die Logik, was passieren soll – falls diese Ausnahme auftritt.
  • Fertig.
import java.util.InputMismatchException;//Importanweisung der InputMismatch Exception
import java.util.Scanner;//Importanweisung für den Scanner

public class TryUndCatchDemo {

	public static void main(String[] args) {
		Scanner scanDividend = new Scanner (System.in);//Neues Scannerobjekt speichert den Dividend
		Scanner scanDivisor = new Scanner (System.in);//Neues Scannerobjekt speichert den Divisor
		
		System.out.println("Dividend:");//Eingabeaufforderung für den Dividenden
		int dividend = scanDividend.nextInt();//Speichert die Bildschirmeingabe zum Dividenden 
		System.out.println("Divisor:");//Eingabeaufforderung für den Divisor
		int divisor = scanDividend.nextInt();//Speichert den Divisor in die Variable

		try {
			System.out.println(dividend / divisor);// Bildschirmausgabe des Ergebnisses
		} 
		catch (ArithmeticException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		}
		catch (InputMismatchException eText){
			System.out.println("Du musst eine echte Zahl eingeben!");
		}
	}
}

Klicke auf „RUN“ und schau was passiert.
Und läuft, oder?

Probiere es wirklich selbst aus.
Kopiere den Code und klicke auf „Ausführen“.

Java try und catch Exception Handling

Hier im Bild ist wirklich nur der Ausschnitt zu sehen.
Die Exception wurde gecatcht bzw. gefangen.
Dennoch kommt es zur Exception.

Was ist falsch gelaufen?
Ich gebe dir einen Tipp. 🙂
Schau dir einmal den Code an. Wo und wann tritt die Exception auf?
Das heißt an welcher Stelle im Code kommt es eigentlich zur Ausnahme.

Wenn du dies herausgefunden hast….
Dann schau mal auf den try-Block.
Umfasst der diesen Code oder nicht?

Hier der Code-Ausschnitt zur Veranschaulichung.

Java try und catch Mismatch Exceptions Fehlerbehandlung

  • Die erste Ausnahme, die „ArithmeticException“, entsteht bei der Division durch Null.
    Somit bei der Berechnung.
  • Diese liegt im try-Block und kann somit ordentlich abgefangen werden.
  • Die zweite Ausnahme – die Eingabe von Text statt einer Zahl – liegt aber ganz woanders.
  • Und zwar bei der Speicherung und Verarbeitung der beiden Integervariablen.
    Dieser Codebereich liegt aber noch nicht im try-Block.

Also muss dieser dort hinein.
Das bedeutet jetzt:
Verschiebe den try-Block nach oben.
Soweit, dass auch die Eingaben innerhalb des Blockes liegen.

Hier der komplette Code dazu:

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

public class TryUndCatchDemo {

	public static void main(String[] args) {
		Scanner scanDividend = new Scanner(System.in);// Neues Scannerobjekt
		Scanner scanDivisor = new Scanner(System.in);// Neues Scannerobjekt

		try {
			System.out.println("Dividend:");// Eingabeaufforderung
			int dividend = scanDividend.nextInt();// Speichert Dividend
			System.out.println("Divisor:");// Eingabeaufforderung
			int divisor = scanDividend.nextInt();// Speichert den Divisor
			System.out.println(dividend / divisor);//Ergebnisrückgabe
		} 
		catch (ArithmeticException eNull) {
			System.out.println("Division durch 0 ist nicht möglich");
		} 
		catch (InputMismatchException eText) {
			System.out.println("Du musst eine echte Zahl eingeben!");
		}
	}
}

So das war’s.
Jetzt fängst du beide Exceptions ab.
Selbst wenn du als Dividend einen Text eingibst, wird diese Ausnahme behandelt.

Zusammenfassung:

  • Mit Java try und catch Blöcken, lassen sich Ausnahmen abfangen.
  • Dadurch ist es dir möglich auf unterschiedliche Ausnahmearten zu reagieren.
  • In jedem catch-Block kannst du für jeden Ausnahmentypen eine separate Logik anlegen.
    Dabei hast du sämtliche Möglichkeiten, wie Schleifen oder Methodenaufrufe.

Ähnliche Beiträge

Lexikalik, Syntax und Semantik in Programmiersprachen

Programmiersprachen Semantik Programmiersprachen Syntax Programmiersprachen Lexikalik Java

Java ist eine Programmiersprache. Und wie jede andere Programmiersprache ist auch Java, lediglich eine künstliche Sprache.   Normalerweise bieten künstliche Projekte immer jede Menge Spielraum für Eigenkreationen. Bei der Programmierung ist dies nicht ganz so. Denn Programmiersprachen sind auch immer sehr exakt.   Jede Programmiersprache und auch jede gesprochene Sprache folgt immer einer Abstraktionsreihenfolge, welche […]

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

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

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Java Methoden Rückgabetypen

Was du vereinbarst, das bekommst du zurück. Ach wäre es schön, wenn alles im Leben so funktionieren würde. Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden. Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren. Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst…. Lass mich dir zeigen, wofür du den Kram […]

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

Hier sind ein paar richtig nette Features, die dich beim Java lernen unterstützen

Java lernen Eclipse

Was ist das Wichtigste beim Einstieg in ein neues Wissensgebiet? Nein, kein gutes Sachbuch oder ein besonders guter Lehrer. Es ist Spaß. Beim Java Lernen brauchst du Spaß. Es gibt Lehrer, welche ihren Stoff so vermitteln, dass Lernen Spaß bereitet. Aber die Grundvoraussetzung ist und bleibt der Spaß. Und nichts ist so spaßhemmend wie Langeweile […]

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

Die drei Bestandteile aller Java Klassen

Java Klassen Bestandteile

Java ist eine objektorientierte Programmiersprache. Was heißt das? Ja… Anscheinend hat es etwas mit Objekten zu tun. Also was ist ein Objekt? Ein Objekt ist ein bestimmtes Konstrukt im Programm. Bauen wir ein Spiel. Ein Grafik-Adventure. Du kennst das. Ein Held wird in eine bestimmte Spielwelt hinein gesteckt. Der Held muss mit bestimmten Personen sprechen. […]

So kannst du Java Konstruktoren anlegen und überladen

Java Konstruktoren

Der Name sagt es schon. Java Konstruktoren konstruieren oder bauen Java Objekte. Und diese Objekte baut der Konstruktor auf Vorlage der entsprechenden Java Klasse. In diesem Beitrag zeige ich dir natürlich verschiedene Ansätze wie du den Konstruktor einsetzt. Ich zeige dir dies Schritt für Schritt. Dabei zeige ich dir auch verschiedene Dinge, welche nicht funktionieren. […]

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