Hallo,

habe eine Frage, wo denn die Fehlerbehandlung in einer Klasse
stattfindet.

Beispiel:

 
public class Adresse {
privat String plz;
...

public Adresse(..., String plz, ...){
this.plz = plz;
...
}

Wo überprüfe ich aber nun, ob diese PLZ wirklich fünf-stellig sind?

Eine Möglichkeit, die ich sehe, ist es, im Konstruktor
evtl eine setPlz(String plz)-Methode aufzurufen und in dieser Set-Methode
zu prüfen.

public Adresse (..., String plz, ...){
setPlz(plz);
...
}

public void setPlz(String plz){
if (plz.length() < 5)
    this.plz = plz;
else
   throw new IllegalArgumentException e;
}

Das hab ich aber noch nirgends gesehen.
Laut unserem Prof muss die Prüfung aber unbedingt in der Klasse selbst
stattfinden, was ja eigentlich auch sinnvoll ist.

Also, wo macht man das?

Vielen Dank für Eure Hilfe,
liebe Grüße, Tina

[Sym]

Hi,

ich hoffe, ich habe Dich richtig verstanden. Du kannst (bzw. solltest) den Fehler schon in der jeweiligen Methode senden. Allerdings muss die Methode in Java auch wissen, dass sie Fehler schmeißen kann.
Bsp:

public void setPlz(String plz) throws IllegalArgumentException { 
if (plz.length() < 5) 
* * this.plz = plz; 
else 
* *throw new IllegalArgumentException e; 
}

.

Das ist in diesem Fall nicht notwendig. Die IllegalArgumentException leitet sich von RuntimeException ab. Alle Exceptions, die sich von RuntimeException ableiten, brauchen nicht deklariert zu werden. Völlig korrekt ist daher:

public void setPlz(String plz) { 
if (plz.length() <= 5) 
    this.plz = plz; 
else 
   throw new IllegalArgumentException(); 
}

Ungewöhnlich ist höchstens, dass der Konstruktor so groß ist und überhaupt die Postleitzahl setzen kann. Viele ältere Entwickler ziehen kleine Konstruktoren vor, die keine Exceptions werfen. Das hat meiner Meinung nach aber nur historische Gründe, denn in C++ waren Exceptions in Konstruktoren eine prima Möglichkeit, um Speicherlecks zu produzieren.

Ungewöhnlich ist vielleicht auch die Stellung der Exception im Code. Die meisten Programmierer, die ich kenne, schreiben lieber:

public void setPlz(String plz) { 
  if (plz.length() > 5)
    throw new IllegalArgumentException();
  this.plz = plz; 
}

Es ist noch anzumerken, dass neben der IllegalArgumentException auch eine NullPointerException vom Code geworfen wird, wenn nämlich der Aufrufparameter null ist. Die NullPointerException ist auch von RuntimeException abgeleitet und wird ebenfalls nicht deklariert.

Ok, ich fange also meine Fehler in den Set-Methoden des Konstruktors
ab.
Jetzt stelle ich mir vor, ich lese meine Daten aus einer GUI und schreibe
sie dann per Konstruktor in einen neuen Kunden. Es sind einige Felder
falsch ausgefüllt, z.B. PLZ und Geburtsdatum.
Im Konstruktor wird dann beim ersten Fehler, also PLZ eine Exception
geworfen, es wird abgebrochen und der Fehler im Geburtsdatum
bleibt hier an dieser Stelle unentdeckt.
Ist aber auch nicht optimal, denn ich will ja eigentlich an dieser Stelle
aus allen Exceptions eine Fehlermeldung generieren, die alle Fehler
anzeigt.
Wie gehe ich dann vor? Wo generiere ich die Fehlermeldung?

Liebe Grüße, Tine

Hi

Da muß ich mal etwas ins Detail gehen:

Die IllegalArgumentException ist eine RuntimeException (wie schon oben erläutert). Solche RuntimeException sollen in Java Programierfehler anzeigen und keine Eingabefehler des Benutzers. Die Länge der Postleizahl sollte also schon die Eingabemaske geprüft haben und die IllegalArgumentException ist nur eine Rückversicherung für Dich, dass die Eingabemaske auch die Prüfung wirklich durchgeführt hat.

Normale Exceptions für das Abfangen ungewöhnlicher Situationen verwendet werden, wenn z.B. eine Datei nicht auf der Platte vorhanden ist, obwohl sie da sein müßte etc. Flasche Benutzereingaben sind aber nicht so ungewöhnlich, dass sie mit Exceptions abgefangen werdne sollten. Wenn der Professor nicht auf Exceptions bestehen würde, würde ich Dir für diesen Fall ganz dringend raten: Benutze keine Exception, sondern frage die Fehler ganz normal ab. Dafür kann man z.B. eine statische Methode einrichten, die falsche Werte erkennt und eine eine boolean zurückgibt, wenn der Wert falsch ist bzw. einen kurzen String mit der Fehlermeldung.

Nun besteht der Professor aber wohl auf Exceptions. In einem solchen Fall sind "normale" Exceptions angeraten. Solche Exceptions werden als eigene Klassen angelegt und deklariert. Sie enthalten dann z.B. die Fehlerursache. Ich habe Dir mal einen Code aufgeschrieben. Der Code ist auch nicht unbedingt üblich. Das liegt aber daran, dass die Anforderung nach einer Exception mit einer Liste von Fehlern sehr selten ist.

Die Klasse verfügt zusätzlich über zwei Methoden, mit denen die Korrektheit der Werte abgefragt werden kann. Da die Methoden statisch sind, können sie auch aufgerufen werden, ohne das ein Objekt angelegt werden muß.

import java.util.ArrayList;
import java.util.Collection;

public class Adresse {

	private String plz;
	private String name;
	
	public Adresse(String name, String plz) throws UngueltigeAdresse {
		Collection<String> errors = new ArrayList<String>();
		if (validateName(name) != null)
			errors.add(validateName(name));
		else
			this.name = name;
		if (validatePlz(plz) != null)
			errors.add(validatePlz(plz));
		else
			this.plz = plz;
		if (errors.size() > 0)
			throw new UngueltigeAdresse(errors.toArray(new String[0]));
	}
	
	public static String validateName(String name) {
		if (name.length() > 20)
			return "Der Name ist zu lang";
		return null;
	}
	
	public void setName(String name) {
		if (validateName(name) != null)
			throw new IllegalArgumentException();
		this.name = name;
	}

	public static String validatePlz(String plz) {
		if (plz.length() > 5)
			return "Die Postleitzahl ist zu lang";
		if (plz.length() < 4)
			return "Die Postleitzahl ist zu kurz";
		return null;
	}
	
	public void setPlz(String plz) {
		if (validatePlz(plz) != null)
			throw new IllegalArgumentException();
		this.plz = plz;
	}
}

public class UngueltigeAdresse extends Exception
{
	private String[] errors;
	
	public UngueltigeAdresse(String[] errors)
	{
		super("Ungültige Adresse");
		this.errors = errors; 
	}
	
	public String[] getErrors()
	{
		return errors;
	}
}
[/highlight]

Der Code verwendet bereits an einer Stelle JAVA 5.0 Sprachelemente. Für Java 1.4 sieht der Code so aus:

[highlight=Java]
import java.util.ArrayList;
import java.util.Collection;

public class Adresse {

	private String plz;
	private String name;
	
	public Adresse(String name, String plz) throws UngueltigeAdresse {
		Collection errors = new ArrayList();
		if (validateName(name) != null)
			errors.add(validateName(name));
		else
			this.name = name;
		if (validatePlz(plz) != null)
			errors.add(validatePlz(plz));
		else
			this.plz = plz;
		if (errors.size() > 0)
			throw new UngueltigeAdresse((String[])errors.toArray(new String[0]));
	}
	
	public static String validateName(String name) {
		if (name.length() > 20)
			return "Der Name ist zu lang";
		return null;
	}
	
	public void setName(String name) {
		if (validateName(name) != null)
			throw new IllegalArgumentException(validateName(name));
		this.name = name;
	}

	public static String validatePlz(String plz) {
		if (plz.length() > 5)
			return "Die Postleitzahl ist zu lang";
		if (plz.length() < 4)
			return "Die Postleitzahl ist zu kurz";
		return null;
	}
	
	public void setPlz(String plz) {
		if (validatePlz(plz) != null)
			throw new IllegalArgumentException(validatePlz(plz));
		this.plz = plz;
	}
}

public class UngueltigeAdresse extends Exception
{
	private String[] errors;
	
	public UngueltigeAdresse(String[] errors)
	{
		super("Ungültige Adresse");
		this.errors = errors; 
	}
	
	public String[] getErrors()
	{
		return errors;
	}
}

Danke, hast mir sehr geholfen

Tina