Nehmen wir an, wir haben die Klasse VogelReader, mit der man Dateien des Typs .vogel auslesen kann. Diese Klasse besitzt einen konventionellen Konstruktor, dem man einen String als Pathname übergibt.
Sie wirft, sofern die Datei nicht gefunden wurde, eine IOException.
Jetzt ist die Frage: Wo soll die gecatcht werden?
Variante 1:
Hier wird in der Main-Methode gecatcht.
Vorteile:
Der Code ist flexibler. Die VogelReader-Klasse kann auch woanders noch verwendet werden. Es kann immer nach Bedürfnissen eine Fehlermeldung angepasst werden, oder sie kann direkt an die GUI weitergeleitet werden. Das wäre OOP, da Wiederverwendung.
Nachteile:
Der Code in der Main-Klasse (oder in anderen Klassen) hat immer einen try-catch-Block am Hals. Das stört mMn den Lesefluss erheblich, vor allem dann, wenn es mehrere Klassen gibt, die teilweise auch noch gleiche Exception werfen. Dann braucht man mehrere Blöcke.
Variante 2:
Hier wird in der Klasse itself direkt gecatcht.
Vorteile:
Der Main-Code ist klar lesbar und nicht von aufdränglichen try-catch-Blöcken zugeballert oder überhäuft. Wenn man diese Code liest, weiß man, dass man sich gar nicht mehr um das Catchen in irgendeiner Weise braucht, sondern dass es automatisch erfolgt. Das wäre OOP, da die Komplexität verringert wird, also Abstraktion.
Nachteile:
Die Wiederverwendbarkeit sinkt stark, da nun die Fehlermeldungen nicht mehr den entsprechenden Bedürfnissen angepasst werden oder in eine GUI-Ausgabe umgeleitet werden können.
Was denkt ihr darüber? Was ist besserer Codestil?
Sie wirft, sofern die Datei nicht gefunden wurde, eine IOException.
Jetzt ist die Frage: Wo soll die gecatcht werden?
Variante 1:
Java:
packe com.wayne.util;
import java.io.IOException;
public class VogelReader
{
private String pathname;
public VogelReader(String pathname)
throws IOException
{
if ( doesNotExist(pathname) )
{
throw new IOException;
}
this.pathname = pathname;
}
//and-so-on-methods
}
//MainClass.java
public class MainClass
{
public static void main(String[] args)
{
try
{
VogelReader vR = new VogelReader("gibbetsnich.vogel");
}
catch (IOException ioe)
{
System.out.println("Die Datei existiert nicht!");
}
}
}Vorteile:
Der Code ist flexibler. Die VogelReader-Klasse kann auch woanders noch verwendet werden. Es kann immer nach Bedürfnissen eine Fehlermeldung angepasst werden, oder sie kann direkt an die GUI weitergeleitet werden. Das wäre OOP, da Wiederverwendung.
Nachteile:
Der Code in der Main-Klasse (oder in anderen Klassen) hat immer einen try-catch-Block am Hals. Das stört mMn den Lesefluss erheblich, vor allem dann, wenn es mehrere Klassen gibt, die teilweise auch noch gleiche Exception werfen. Dann braucht man mehrere Blöcke.
Variante 2:
Java:
packe com.wayne.util;
import java.io.IOException;
public class VogelReader
{
private String pathname;
public VogelReader(String pathname)
{
if ( doesNotExist(pathname) )
{
System.out.println("Die Datei existiert nicht!");
}
else
{
this.pathname = pathname;
}
}
//and-so-on-methods
}
//MainClass.java
public class MainClass
{
public static void main(String[] args)
{
VogelReader vR = new VogelReader("gibbetnich.vogel");
}
}Vorteile:
Der Main-Code ist klar lesbar und nicht von aufdränglichen try-catch-Blöcken zugeballert oder überhäuft. Wenn man diese Code liest, weiß man, dass man sich gar nicht mehr um das Catchen in irgendeiner Weise braucht, sondern dass es automatisch erfolgt. Das wäre OOP, da die Komplexität verringert wird, also Abstraktion.
Nachteile:
Die Wiederverwendbarkeit sinkt stark, da nun die Fehlermeldungen nicht mehr den entsprechenden Bedürfnissen angepasst werden oder in eine GUI-Ausgabe umgeleitet werden können.
Was denkt ihr darüber? Was ist besserer Codestil?
Zuletzt bearbeitet:
