6 Fehlerbehandlung mit Java

Transkript

1 6 Fehlerbehandlung mit Java Ausnahmen, Handling, Auswerfen Fehlerbehandlung In jedem Programm kann es zur Laufzeit zu Fehlern kommen, die verschiedenste Ursache haben können, z.b.: Falsches Eingabenformat illegaler Speicherzugriff (zu hoher Array-Iindex etc.) fehlende Resourcen (keine Datei, lesen am Dateiende etc.) In Java werden solche Fehler als Exception : Ausnahme, behebbarer Fehler oder Error : fataler Fehler ausgeworfen und können dann im Programm ggf. abgefangen und entsprechend behandelt werden. Java hat damit eine deutliche (optische) Trennung zwischen Programmablauf und Fehlerbehandlung.

2 //Ausnahmen.java import java.io.*; class Ausnahmen Ausnahmen { public static void main(string[] args) {PrintWriter out = new PrintWriter(System.out, true); int i = Integer.parseInt(args[0]); out.println("i = " + i); Die Deklaration von i kann aus zwei Gründen schiefgehen: Ausnahmen ist ohne Parameter aufgerufen worden, d.h. args hat 0 Felder und es wird eine ArrayIndexOutOfBoundsException ausgeworfen. Der erste Parameter von Ausnahmen ist nicht als Integer interpretierbar (z.b. "x1234") und es wird eine NumberFormatException ausgeworfen. Ausnahmetypen Exception ClassNotFoundException CloneNotSupportedException IllegalAccessException InstantiationException InterruptedException NoSuchFieldException NoSuchMethodException Throwable RuntimeException Error LinkageError VirtualMachineError ThreadDeath

3 ungeprüfte Fehler Java verlangt in der Regel, daß Fehlersituationen überprüft (abgefangen) werden müssen. Ausnahmen sind alle Errors und die RuntimeExceptions. Ein LinkageError wie etwa AbstractMethodError, NOSuchFieldError oder NoSuchMethodError oder ein VirtualMachineError wie etwa OutOfMemoryError, StackOverflowError, InternalError oder UnknownError kann zur Laufzeit nicht sinnvoll aufgefangen werden und braucht es deshalb auch nicht. Eine RuntimeException wie etwa ArithmeticException, NullPointerException, NumberFormatException, ArrayIndexOutOfBoundsException ist manchmal nur mit einem Aufwand aufzufangen, der den Nutzen nicht aufwiegt, darum braucht er nicht unbedingt behandelt zu werden. Standard-Ausnahmebehandlung Java hat einen Standard-Ausnahmehandler, der den Typ der Ausnahme und die Reihenfolge der Methodenaufrufe, die zu dieser Ausnahme geführt haben (StackTrace) aus. d.h. nicht abgefangene Ausnahmen werden mit Programmabbruch bestraft! Dies kann man auch explizit tun out.print(e) gibt den Ausnahmetyp aus e.printstacktrace() gibt die Methodenaufrufe aus Ausnahmen können auch mit einem erklärenden Text versehen sein, der dann ausgegeben werden kann mit out.println(e.getmessage())

4 try-catch Um in Java eine Ausnahme abzufangen, die durch einen Befehl ***** ausgeworfen werden könnte, verwendet man das Schlüsselwort try {*****. Nach einer try-klausel muß dann mindestens eine catch- Klausel (Handler) folgen: try { int i = Integer.parseInt(args[0]); out.println("i= "+i); catch (NumberFormatException e) { out.print("als erstes Kommandozeilen-Argument"); out.println("wird ein int-wert benötigt!"); catch (ArrayOutOfBoundsException e) { out.print("aufruf in der Form :"); out.println("java <Programmname> <int-wert>"): Beispiel // Argumente.java import java.io.*; class Argumente { static PrintWriter out = new PrintWriter(System.out,true); static int n=0; public static void main(string[] args) { for (n=0;;n++) { try {out.println((n+1) + " : " + args[n]); catch(arrayindexoutofboundsexception e){break; out.println("****ende der Argumentenliste****");

5 geschachtelte try-blöcke Das obige Beispiel könnte auch geschachtelt werden: try {try { int i = Integer.parseInt(args[0]); out.println("i= "+i); catch (NumberFormatException e) { out.print("als erstes Kommandozeilen-Argument"); out.println("wird ein int-wert benötigt!"); catch (ArrayOutOfBoundsException e) { out.print("aufruf in der Form :"); out.println("java <Programmname> <int-wert>"); finally-block statt einer catch-klausel oder nach allen catch-klauseln darf noch ein Block finally {... stehen, in der z.b. das Schließen von Dateien, Datenbanken, Netzverbindungen o.ä. erledigt werden kann. Der finally-block wird in jedem Fall ausgeführt, gleichgültig ob: keine Ausnahme ausgeworfen wird der try-block durch ein explizites return verlassen wird eine Ausnahme ausgeworfen wird, die durch ein catch abgefangen wird eine Ausnahme ausgeworfen wird, die nicht abgefangen wird

6 try-blöcke können ineinander geschachtelt sein. Regeln für try Wird in einem try-block keine Ausnahme ausgeworfen, so werden alle unmittelbar danach stehenden catch-blöcke (Handler) übersprungen. Wird eine Ausnahme ausgeworfen, - so wird unter den nachfolgenden Handlern der erste ausgeführt, der auf die Ausnahme passt und alle darauffolgenden Handler werden übersprungen. - Wird kein passender Handler gefunden so wird hinter dem umfassenden try-block nach ihm gesucht u.s.w. - Gibt es keinen umfassenden try-block mehr, so wird der Standard-Ausnahmehandler eingesetzt (Dump + Abbruch). throws-klausel In einer Methodendeklaration kann nach dem Namen ein throws mit einer Liste von Typen stehen, die alle Subtypen von Throwable sein müssen. Dies zeigt an, daß die Methode mit einer der in der Liste aufgeführten Ausnahmen abbrechen kann. Die throws-klausel muß stehen, wenn die ausgeworfenen Ausnahmen nicht vom Typ Error oder RuntimeException sind und nicht innerhalb der Methode abgefangen werden können oder sollen. Mit diesem Mechanismus kann Java kontrollieren, ob alle Ausnahmen (außer Errors und RuntimeExceptions) auch abgefangen werden.

7 Hierarchie(1) // Hierarchie.java import java.io.*; class Hierarchie { static PrintWriter out=new PrintWriter(System.out,true); static boolean superklasse(class cs, String t) // Fehler { Class ct = Class.forName(t); if (!cs.isassignablefrom(ct)) return false; out.println(t + " ist Subklasse von " + cs); return true; public static void main(string[] args) // Fehler { if (args.length == 0) {out.println("start in der Form java Hierarchie <Name>" + "\n!!! voll qualifizierte Klassennamen!!!" + "\n(z.b. java.io.filenotfoundexception)");return; String s = args[0]; if (superklasse(java.lang.throwable.class, s)) if (superklasse(java.lang.exception.class, s)) {if (superklasse(java.lang.runtimeexception.class, s)); else if (superklasse(java.lang.error.class, s)); Hierarchie(2) Die Methode superklasse kann in der Zeile Class ct = Class.forName(t) eine ClassNotFoundException auswerfen, wenn t kein gültiger Klassenname ist, darum wird superklasse ohne den Zusatz throws ClassNotFoundException nicht übersetzt. Die Methode main verwendet superklasse, ohne die ClassNotFoundException abzufangen, daher muß auch sie mit dem Zusatz throws ClassNotFoundException versehen werden, damit sie übersetzt werden kann. Regel: Exceptions müssen in einer Methode abgefangen oder mit einer throws-klausel nach außen weitergereicht werden.

8 eigene Ausnahmen Jeder Programmierer kann natürlich auch eigene Ausnahmen aus Throwable oder deren Unterklassen ableiten. Ausnahmen könne in einer Methode explizit mit dem Befehl throw... ausgeworfen werden. Regel: Werden Methoden aus Superklassen überschrieben, so darf die neue Methode nur solche Ausnahmen auswerfen, die die überschriebene Methode nach ihrer throws-klausel auch hätte auswerfen können. Alle sonstigen Ausnahmen müssen innerhalb der Methode abgefangen werden. Beispiel Throw // Throw.java import java.io.*; import java.util.*; class Throw { static PrintWriter out = new PrintWriter(System.out, true); static class Closed extends Exception { ClosedShop(String text) { super(text); void connect() throws Closed { int tag = Calendar.getInstance().get(Calendar.DAY_OF_WEEK); if (tag == Calendar.SUNDAY) throw new Closed("sonntag"); if (tag == Calendar.THURSDAY)throw new Closed("donnerstag"); out.println("heute normaler Betrieb."); public static void main(string[] args) { try { new Throw().connect(); catch (Closed ex) { out.println( ex.getmessage() + "s geschlossen.");

9 Passwortabfrage(1) // Login.java import java.awt.*;import java.awt.event.*;import java.io.*; class Login extends Frame { TextField text; final int MAX = 5; int anz = 0; Login() // Konstuktor { super(" "); setlayout(new GridLayout(2, 1)); setfont(new Font("Monospaced", Font.PLAIN, 14)); add(new Label("Zum Starten Passwort eingeben")); add(text = new TextField(20)); text.setechochar('*'); text.setbackground(color.darkgray); text.setforeground(color.white); pack(); text.addactionlistener(new ActionListener() { public void actionperformed(actionevent e) {Frage();); setvisible(true); class PasswdEx extends Exception { Passwortabfrage(2) public static void main(string[] args) {new Login(); void Frage() { ++anz; try {try {if (!(text.gettext().equals("passwort"))) throw new PasswdEx(); //exit aus if.. dispose(); //Fenster zerstören new PrintWriter(System.out, true).println("login ok"); System.exit(0); catch (PasswdEx ex) {if (anz == MAX) throw ex; //exit aus try.. text.seteditable(false); text.settext(""); try {Thread.sleep(1000*anz); catch (InterruptedException ign) { text.seteditable(true); catch (PasswdEx ex) {new PrintWriter(System.out, true).println("login fail"); System.exit(0); //exit aus main

10 Passwortabfrage(3) // LoginA.java import java.applet.*; import java.net.*;... class LoginA extends Applet { TextField text,nachr;... LoginA()// Konstuktor { //super(" ");... //pack(); void Frage() {... nachr.seteditable(false); nachr.settext("login ok"); try {getappletcontext().showdocument (new URL(" catch(java.net.malformedurlexception e){ // ruft eine URL auf Zeichenfeld // Scribble.java import java.applet.*;import java.awt.*; public class Scribble extends Applet { private int last_x = 0, last_y = 0 ; //zum Speichern von Punkten // Aufruf erfolgt beim Anklicken durch den Benutzer. public void mousedown(event e, int x, int y) { last_x = x; last_y = y; //Position des Klicks merken // Aufruf erfolgt, wenn Maus mit gedrückter Taste bewegt wird public void mousedrag(event e, int x, int y) { Graphics g = getgraphics(); // in g wird gezeichnet g.drawline(last_x, last_y, x, y); // Linie vom letzten Punkt zum aktuellen Punkt last_x = x ; last_y = y ; // Position aktualisieren

11 Dieses Applet erlaubt kleine Bilder mit der Maus zu zeichnen. Zeichenfeld(2)