c++.de :: throws

Unregistrierter

Hi!

was bedeutet eigentlich dieses throws?

wenn ich zB hab:
[java]
public test (filename)

throws IOException
{
...
}[/code]

Titus Mitglied 12:45:00 18.04.2002 Titel:

Das heisst, dass in der Funktion test() eine IOException ausgeworfen werden könnte, die man dann ausserhalb von test() auffangen sollte.

void test(String filename) throws IOException {
if(!filename.endsWith(".txt"))
throw new IOException("Kann nur .txt lesen");
}

...

try {
test("hallo.txt");
} catch (IOException e){
System.out.println("Fehler: " + e.toString());
}

cm Mitglied 13:31:00 18.04.2002 Titel:

Hallo!

Das throws bedeutet, dass Du es der Java Laufzeitumgebung (JRE) überlässt den Fehler zu behandeln. Normalerweise heisst dies, dass der Stackinhalt angezeigt wird und je nach Fehler das Programm evtl. unkontrolliert weiterläuft.
Lässt Du das throws weg, so musst Du mit try, catch den Fehler selbst behandeln.

Gruss

Carsten

[ Dieser Beitrag wurde am 18.04.2002 um 13:32 Uhr von cm editiert. ]

CengizS Mitglied 16:24:00 18.04.2002 Titel:

@Titus: Das ist nicht ganz richtig.

Wenn eine Methode throws XYZ angibt bedeutet dies, dass der Code in dieser Methode zu einer XYZException führen kann und dass dieser aber nicht explizit aufgegangen wird. Statt dessen propagiert sie die Exception an die aufrufende Stelle. Diese muss dann die Exception XYZ entweder behandeln oder wie die "untere" Methode als "throws XYZ" deklariert werden womit sie wieder eine aufrufende Stelle nach oben propagiert wird etc. pp.

Wenn in der Aufrufehierarchie niemand die Exception auffängt tritt das ein, was cm schon angedeutet hat. Es wird der stackTrace ausgegeben.

[ Dieser Beitrag wurde am 18.04.2002 um 16:28 Uhr von CengizS editiert. ]

Unregistrierter

Also ist es egal ob ich entweder nur ein throws nehme oder das try mit dem catch? läuft das auf das selbe hinaus, oder ist da ein unterschied?

CengizS Mitglied 08:43:00 19.04.2002 Titel:

Na ja wie schon gesagt. Mit try und catch behandelst Du die Exception lokal - also an ihrem Entstehungsort. Wenn du die Exception weiter nach oben propagierst muss sie halt an anderer Stelle aufgefangen werden. Das nach oben propagieren wird i.A. nur dann gemacht wenn man eine Klasse schreibt, die von anderen genutzt wird und dementsprechend die Möglichkeit freihalten will, dass die Programmierer ihre eigenen Fehlerbehandlungscodes dort einbauen. Eine allgemeine Fehlerbehandlung (solange es nicht für den anderen Programmierer von Interessant ist) kann natürlich lokal gemacht werden.

Sylvester Mitglied 11:10:00 24.04.2002 Titel:

Hi!

Also das mit dem throws ist noch immer sehr schwer zu verstehen. Mal sehen ob ich bis jetzt richtig liege:

Das throws sagt mir hier, dass in der Funktion X (= eine Subklasse) eine IO Exception auftreten kann. Diese wird hier nicht aufgefangen sonder weitergeworfen. ZB zu einer anderen klasse die das readNext() ebenfalls verwendet. Sprich die IO Exception wird an eine aufrufende Methode weitergegeben. Ist das so richtig? Nur verstehe ich den Sinn immer noch nicht ganz!!  Was bedeutet dann dieses throw new IO Exception?

Bitte um Hilfe!

[java]

public X readNext() //Subklasse X
throws java.io.IOException
{
try
{
String a = br.readLine();
String b = br.readLine();

if (a == null || b == null ||)
return null;
else
return (new Objekt(a,b,));

}

catch(Exception e)
{
throw new IOException("Daten konnten nicht gelesen werden: "+e);
}
}[/code]

CengizS Mitglied 11:15:00 24.04.2002 Titel:

Du kannst ja auch selbstdefinierte Exceptions in die throws-Liste aufnehmen um dem Programmierer, der deine Routine nutzen wird, zu signalisieren dass er gefälligst ein try-catch um die Routine basteln soll welches genau diese Exceptions, die in der Liste aufgeführt sind, auffangen wird.

CengizS Mitglied 11:31:00 24.04.2002 Titel:

Also doch noch mal ein Beispiel:

[java]public class MySuperToolsClass {
...
public int renderSomething(Object o) throws NullPointerException, ProgrammingException {
if(!(o instanceOf Shape)) {
throw new ProgrammingException("Parameter o must be an instance of de.sahinc.gui.Shape!");
}
...
o.renderYourself(); // <-- hier geschieht NullPointerException
}
...
}[/code]Der Aufruf von

[java]MySuperToolsClass mstc = MySuperToolsClass.getInstance();
mstc.renderSomething(new Shape());[/code]würde einen Compilerfehler verursachen. Er beschwert sich nämlich dass die Exceptions in der throws-Liste der Routine renderSomething nicht abgefangen werden ... an diesem Punkt gibt es 2 Möglichkeiten ... entweder man folgt dem Compiler und macht ein try-catch-Block um den Aufruf von renderSomething:

[java]MySuperToolsClass mstc = MySuperToolsClass.getInstance();
try {
mstc.renderSomething(new Shape());
} catch (NullPointerException npex) {
npex.printStackTrace();
} catch (ProgrammingException pex) {
pex.printStackTrace(); // ... oder irgendeine andere Fehlerbehandlung
}[/code]

oder

man definiert für die Routine, die renderSomething() aufruft ebenfalls eine throw-Liste und sorgt so dafür, dass sie wieder eine Instanz nach oben propagiert wird:

[java]public class RenderEngine {
...
public void renderNow() throws NullPointerException, ProgrammingException {
// hier der Aufruf von renderSomething()
MySuperToolsClass mstc = MySuperToolsClass.getInstance();
mstc.renderSomething(new Shape());
...
}
...
}[/code]

Also mit beiden Lösungen ist der Compiler zufrieden ... wenn es keine obere Instanz gibt bekommt die VM die Exception und dann sieht man den berühmten StackTrace und das Programm hängt oder ist komplett abgebrochen worden...

Hope this helps :)

[ Dieser Beitrag wurde am 24.04.2002 um 11:35 Uhr von CengizS editiert. ]