Exceotion.Handling Aufgabe mit "throw"

[llabusch]

Liebe Java gemeinde. Ich muss eine Aufgabe lösen, bei der ich einen Anstoß brauche...
Also ich denke, dass man mit "throw" arbeiten muss, aber wie genau entzieht sich meines Wissens....

Die Aufgabe Lautet wie folgt:

Überarbeiten Sie die Plausibilitätsprüfung in dem Konstruktor der Klasse Wein
aus dem Listing 5 dieses Studienheftes so, dass bei ungültigen Werten nicht mehr
„stillschweigend“ Standardwerte gesetzt werden, sondern jeweils eine Ausnahme
der Klasse IllegalArgumentException ausgelöst wird.
Sorgen Sie dafür, dass diese Ausnahmen an den Aufrufer weitergeleitet werden.
Erstellen Sie auch eine main()-Methode, in der Sie die Ausnahmen behandeln,
und testen Sie dort die Änderungen.​

Die Klasse Wein incl. Konstruktor(en):

public class Wein {
	private int alter;
	private double grundpreis;
	private double preisProFlasche;
	
	//der Standard-Konstruktor
	public Wein() {
		//er ruft �ber this() den Konstruktor mit den beiden Parametern auf
		//und �bergibt die Standardwerte
		this(1, 10);
	}
	
	//der Konstruktor setzt das Alter
	//der Preis erh�lt einen Standard-Wert
	public Wein(int alter) {
		//er ruft ebenfalls �ber this den Konstruktor mit den beiden Parametern auf
		this(alter, 10);
	}
	
	//der Konstruktor setzt den Preis
	//das Alter erh�lt einen Standard-Wert
	public Wein(double grundpreis) {
		//und dieser Konstruktor ruft auch den Konstruktor mit den beiden Parametern auf
		this(1, grundpreis);
	}
	
	//der Konstruktor setzt das Alter und den Grundpreis
	//er enth�lt jetzt Plausibilit�tspr�fungen
	public Wein(int alter, double grundpreis) {
		//die Plausibilit�tspr�fung f�r das Alter
		if (alter > 0)
			this.alter = alter;
		//sonst den Standardwert 1 setzen
		else
			this.alter = 1;
		//und auch f�r den Preis
		if (grundpreis > 9)
			this.grundpreis = grundpreis;
		else
			this.grundpreis = 10;
	}

DIe Main-Methode:

public class Java08a_05 {
	public static void main(String[] args) {
		//eine neue Instanz mit unsinnigen Werten erzeugen
		Wein flasche2 = new Wein(-10,20.5);
		//den Preis ausgeben
		//er wird aus Standard-Werten berechnet, die �ber den Konstruktor gesetzt werden
		System.out.println(flasche2.getPreisProFlasche());
	}
}

Ich hoffe ihr könnt mir vielleicht weiterhelfen...

Vielen Dank schon mal bis hier hin für's durchlesen!

 

[Joose]

Also ich denke, dass man mit "throw" arbeiten muss, aber wie genau entzieht sich meines Wissens....

:toll:

Einfach den Konstruktor anpassen und bei ungültigen Werten eine Exception werfen. Wie man eine Exception wirft solltest du leicht herausfinden können

public Wein(int alter, double grundpreis) {
    if (alter < 0) {
        // Exception werfen 
    }
    if(grundpreis <10){
        // Exception werfen
    }
    this.alter = alter;
    this.grundpreis = grundpreis;
}

 

[kaoZ]

public Wein(int alter, double grundpreis) {
    if (alter < 0) {
        throw new IllegalArgumentException("Der Paramater 'alter' kann keinen Wert unter 0 haben !");
    }
    if(grundpreis <10){
       throw new IllegalArgumentException("Der Parameter 'Grundpreis' muss zwischen 10 - n € liegen !");
    }
    this.alter = alter;
    this.grundpreis = grundpreis;
}

oder einfach auch :

public class Wein {
	
	private int alter;
	private int grundpreis;
	
	
	public Wein(final int alter, final int grundpreis) {
		if(alter  == 0 | grundpreis < 10){
			throw new IllegalArgumentException("Der Parameter 'alter' darf nicht 0, und der Grundpreis nicht < 10 sein !");	
		}
		else{
			this.alter = alter;
			this.grundpreis = grundpreis;
		}
	}
	
	public static void main(String[] args) {
		new Wein(0, 12); // zum Testen 
	}
}

sobald eine der Bedingungen unterschritten wird , wird eine aussagekräftige Exception geworfen .

 

[killermuck]

Hallo,


Die Aufgabenstellung lautet:

Überarbeiten Sie die Plausibilitätsprüfung in dem Konstruktor der Klasse Wein aus dem Code 1.5
dieses Studienhefts so, dass bei ungültigen Werten nicht mehr stillschweigend Standadwerte gesetzt
werden, sondern jeweils eine Ausnahme der Klasse IllegalArgumenException ausgelöst wird.

Sorgen Sie dafür, dass diese Ausnahmen an den Anrufer weitergeleitet werden. Erstellen Sie auch eine
main()-Methode, in der Sie die Ausnahmen behandeln, und testen Sie dort die die Änderungen.

Ich sehe das so, das der o. g. Lösungsvorschlag, nicht die Aufgabenstellung wiedergibt, siehe fettgedrucktes.

Ich denke es muss eine separate Klasse in main() für die Ausnahmebehandlung erstellt werden, die dann an die einzelnen Methoden weitegeleitet werden und über main() müssen dann die Ausnahmen mit try und catch behandelt werdnen.

Sehe ich das so richtig?

 

[mrBrown]

Ich denke es muss eine separate Klasse in main() für die Ausnahmebehandlung erstellt werden, die dann an die einzelnen Methoden weitegeleitet werden und über main() müssen dann die Ausnahmen mit try und catch behandelt werdnen.

Ja, in der main sollten auch "falsche" Werte getestet und die Exception dann in einem catch gefangen werden.

 

[killermuck]

Hallo,

wäre das eine gute, eine schlechte, oder eine mittelmäßige Lösung zur o. g. Aufgabe?


[CODE lang="java" title="public class Java08d_01_05"]package java08d_01_05;

public class Java08d_01_05 {
public static void main(String[] args) throws IllegalArgumentException {
//eine neue Instanz zum Testen
Wein flasche1 = new Wein(0,10);
//Ausnahmebehandlung für IllegalArgumentException
if (Wein.alter <= 1 | Wein.grundpreis < 10) {
throw new IllegalArgumentException("Das 'alter' darf nicht <1 sein und der 'Grundpreis' nicht <10!");
}
//den Preis ausgeben
System.out.println("Der Preis pro Flasche beträgt: " + flasche1.getPreisProFlasche());
}
} [/CODE]

und der 2. Partder Aufgabe:

[CODE lang="java" title="public class Wein {"]package java08d_01_05;

public class Wein {
public static int alter;
public static double grundpreis;
private double preisProFlasche;

//der Konstruktor setzt das Alter und den Grundpreis
public Wein(int alter, double grundpreis) {
Wein.alter = alter;
Wein.grundpreis = grundpreis;
}
//die Methode berechnet den Preis pro Flasche
public void preisBerechnen() {
preisProFlasche = alter * grundpreis;
}

//die Methode liefert den Preis pro Flasche
public double getPreisProFlasche() {
preisBerechnen();
return preisProFlasche;
}
}[/CODE]

Vielen Dank für euere Bemühungen!

Gruß
Lars

 

[mrBrown]

wäre das eine gute, eine schlechte, oder eine mittelmäßige Lösung zur o. g. Aufgabe?

Eher gar keine bis schlechte Lösung der Aufgabe.

Die Überprüfung soll innerhalb des Konstruktors stattfinden:

Überarbeiten Sie die Plausibilitätsprüfung in dem Konstruktor der Klasse Wein aus dem Code 1.5
dieses Studienhefts so, dass bei ungültigen Werten nicht mehr stillschweigend Standadwerte gesetzt
werden, sondern jeweils eine Ausnahme der Klasse IllegalArgumenException ausgelöst wird.

 

[killermuck]

Aber im zweiten Absatz der Aufgabe wird doch verlangt, dass die Ausnahmen in der main()-Methode behandelt werden und das würde ja dem ersten Absatz widersprechen, oder?

 

[mrBrown]

Auslösen der Exception und und Behandlen der Exception passiert an unterschiedlichen Stellen (Auslösen ist throw..., Behandeln ist catch).

Aktuell löst die Exception in main() aus, und behandelst sie dafür nirgendwo. Die Aufgabe verlangt aber ein Auslösen in dem Kosntruktor und ein Behandlen in main().

 

[killermuck]

Alles klar, danke für die schnelle Antwort!

 

[killermuck]

So, ich denke jetzt hab ich's endlich gelöst, ich hoffe das ist nicht zu umständlich programmiert.

Wie würdet ihr das jetzt bewerten?

Es besteht jetzt aus 3 Teilen:
Teil1 Main()

package java08d_01_05;

import javax.swing.JOptionPane;

public class Java08d_01_05 {
    public static void main(String[] args) {
        //eine neue Instanz zum Testen
        Wein flasche1 = null;
        try {
            flasche1 = new Wein(1,10);
        }
        catch (AbbruchException e) {
            JOptionPane.showMessageDialog(null, e.getMessage());
        }
            //den Preis ausgeben
            System.out.println("Der Preis pro Flasche beträgt: " + flasche1.getPreisProFlasche());
    }
}

Teil2 class Abbruch Exception

package java08d_01_05;

public class AbbruchException extends Exception{
    //der Standardkonstruktor
    AbbruchException() {
        super();
    }
    //der Konstruktor zur Uebergabe einer Meldung
    //er ruft ueber super den Konstruktor der Basisklasse auf
    AbbruchException(String meldung) {
        super(meldung);
    }
}

Teil3 class Wein

package java08d_01_05;

public class Wein {
    public int alter;
    public double grundpreis;
    private double preisProFlasche;
    
    //der Konstruktor setzt das Alter und den Grundpreis
    public Wein(int alter, double grundpreis) throws AbbruchException {
        if (alter <= 0 | grundpreis < 10)
            throw new IllegalArgumentException("Das 'alter' darf nicht <1 sein und der 'Grundpreis' nicht <10!");
        else {
        this.alter = alter;
        this.grundpreis = grundpreis;
        }
    }   
    //die Methode berechnet den Preis pro Flasche
    public void preisBerechnen() {
        preisProFlasche = alter * grundpreis;
    }
    
    //die Methode liefert den Preis pro Flasche
    public double getPreisProFlasche() {
        preisBerechnen();
        return preisProFlasche;
    }
}

 

[kneitzel]

Ja, das geht in die Richtung, wie die Aufgabe gemeint war.

Ich sehe da nur eine Abweichung von der Aufgabe, denn in der Aufgabe steht: " sondern jeweils eine Ausnahme der Klasse IllegalArgumentException ausgelöst wird."

Deine AbbruchException ist natürlich keine IllegalArgumentException.

 

[killermuck]

Vielen Dank für die Hinweise!
Ich habe jetzt die AbbruchException in Illegal ArgumentException geändert und
in der Klasse Wein() noch die If-Bedingungen folgendermaßen aufgeteilt:

if (alter <= 0)
throw new IllegalArgumentException("Das 'alter' darf nicht <1 sein!");
else if (grundpreis <= 9)
throw new IllegalArgumentException("Der 'grundpreis' darf nicht <10 sein!");

else
this.alter = alter;
this.grundpreis = grundpreis;

Ich denke das kann man so durchgehen lassen, oder? ;-)

 

[killermuck]

Vielen Dank nochmals für die schnelle und effektive Hilfe.
Besser kanns nicht sein!