Frage zu Exceptions

[Mane123]

Hallo zusammen,

ich habe folgenden Quelltext erstellt:

public class Wein2 {
	
	private int alter;
	private double grundpreis;
	private double preisProFlasche;
	
	
	//der Standard Konstruktor
	
	public Wein2 () throws IllegalArgumentException {
		


		throw new IllegalArgumentException ("Sie haben kein Alter und keinen Grundpreis eingegeben!");
		
	}
	

	//Der Konstruktor, falls kein Grundpreis eingegeben wurde
	public Wein2 (int alter) throws IllegalArgumentException {
		
		
		throw new IllegalArgumentException ("Sie haben keinen Grundpreis eingegeben!");
		
		
	}
	
	
	//der Konstruktor, falls kein Alter eingegeben wurde	
	public Wein2 (double grundpreis) throws IllegalArgumentException {
		
		throw new IllegalArgumentException ("Sie haben kein Alter eingegeben!");
	}
	
	//der Konstruktor setzt das Alter und den Grundpreis
	//und prüft ob alle Werte plausibel sind
	
	public Wein2 (int alter, double grundpreis) throws IllegalArgumentException {
		
		if (alter > 0) {
			
			this.alter = alter;
		}
		
		else 
			throw new IllegalArgumentException ("Sie haben ein ungültiges Alter eingegeben!");
			
		
		if (grundpreis > 9)
			this.grundpreis = grundpreis;
		
		else
			throw new IllegalArgumentException ("Sie haben einen ungültigen Grundpreis eingegeben!");
		
	}
	
	//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;
	}

}

Der Quelltext enthielt ursprünglich keine Exception Behandlung, sondern setzte bei fehlenden bzw. falschen Werten einfach Standardwerte.
Ich habe nun einfach die Konstruktoren abgeändert, sodass bei fehlenden bzw. ungültigen Werten einen IllegalArgumentException erscheint.
Ich denke, das stimmt soweit?
Allerdings denke ich mir, dass es hier bestimmt eine elegantere Möglichkeit gibt?
Ist es möglich, alle Fälle im letzten Konstruktor abzudecken, in dem im Prinzip ja die Plausibilitätsprüfung stattfindet?

Viele Grüße

 

[Final_Striker]

wofür sind denn die ersten 3 konstruktoren, wenn sie sowieso nicht verwendet werden können?

 

[Mane123]

Sie sollen in Erscheinung treten, wenn in der main-Methode z.B. eine Instanz erzeugt wird, in der nur eine Instanzvariable angegeben ist:

mport javax.swing.JOptionPane;


public class Javaß8_5 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//eine neue Instanz mit unsinnigen Werten erzeugen
		try {
			
		Wein2 flasche2 = new Wein2(8);
		
		//den Preis ausgeben
		//er wird aus den Alter und dem Grundpreis berechnet.
		System.out.println("Der Preis pro Flasche beträgt " + flasche2.getPreisProFlasche() + " Euro");
		
		}
		
		catch (IllegalArgumentException e) {
			
			JOptionPane.showMessageDialog(null,e.getMessage());
			
		}
	}

}

Hier wird eben nur das Alter initialisiert und es erscheint die Fehlermeldung, dass der Grundpreis fehlt.

Wisst ihr eine andere Möglichkeit, dies zu lösen?

Das soll jetzt nicht alles ein produktives Programm sein, sonder mehr oder weniger als Beispiel dienen. Darum auch die vielen Möglickeiten mit den Konstruktoren.



Viele Grüße

 

[function]

Wofür soll es denn als Beispiel dienen? Für Exceptions/Exceptionhandling, oder doch was anderes?

 

[Wildcard]

So ist das Blödsinn. Wenn die anderen beiden Konstruktoren kein gültiges Objekt erzeugen können musst du sie entfernen. Wenn default Werte Sinn machen, dann ruf in einem Konstruktor einen anderen auf und übergib den Default:

this(arg1,arg2,"Default")

Bei vielen Parametern im Konstruktor kann auch das Builder Pattern sinnvoll sein.

 

[Mane123]

Das soll eine Übung zu den Exceptions sein.

Die Ausgangsversion sieht so aus:

public class Wein {
	
	private int alter;
	private double grundpreis;
	private double preisProFlasche;
	
	//der Standard Konstrukto
	
	public Wein () {
		
		this.alter = 1;
		this.grundpreis = 10;
	}
	
	//der Konstruktor setzt das Alter
	//der Preis erhält einen Standard - Wert
	
	public Wein (int alter) {
		
		this.alter = alter;
		this.grundpreis = 10;
	}
	
	//der Konstruktor setzt den Preis
	//das Alter erhält einen Standard-Wert
	
	public Wein (double grundpreis) {
		
		this.alter = 1;
		this.grundpreis = grundpreis;
	}
	
	
	//der Konstruktor seztz das Alter und den Grundpreis
	
	public Wein (int alter, double grundpreis) {
		
		this.alter = alter;
		this.grundpreis = grundpreis;
	}
	
	//die Mehode berechnet den Preis pro Flasche
	
	public void preisBerechnen () {
		
		preisProFlasche = alter * grundpreis;
	}
	
	//die Methode liefert den Preis pro Flasche
	public double getPreisProFlasche () {
		
		preisBerechnen ();
		return preisProFlasche;
		
		
	}

Diese habe ich umgearbeitet, sodass in den anderen Konstruktoren z.B. nur folgendes steht:

	public Wein (double grundpreis) {
		
		
		
		this(1,grundpreis);
	}

So wurde der Konstruktor Wein (int alter, double grundpreis) aufgerufen, wo hier die Plausibilitätsprüfung erfolgte.

Nun habe ich folgende Aufgabe:

Überarbeiten Sie die Plausibilitätsprüfung in dem Konstruktor der Klasse Wein2 so, dass bei ungültigen Werten nicht mehr "stillschweigend" Standardwerte gesetzt werden, sondern eine Ausnahem der Klasse IllegalArgumentException.

Meine Lösung habe ich im Ersten Posting aufgezeigt.
Wie würdet ihr das dann lösen?

Viele Grüße

 

[Wildcard]

Überarbeiten Sie die Plausibilitätsprüfung in dem Konstruktor der Klasse Wein2 so, dass bei ungültigen Werten nicht mehr "stillschweigend" Standardwerte gesetzt werden, sondern eine Ausnahem der Klasse IllegalArgumentException.

Du hast in deinem Beispiel nicht 'dem Konstruktor', du hast mehrere Konstruktoren und da macht dein Vorgehen keinen Sinn.

 

[Mane123]

Mit "dem Konstruktor" ist der Konstruktor public Wein2 (int alter, double grundpreis) throws IllegalArgumentException gemeint.
Allerdinds sollen die anderen Konstruktoren auch nocht vorhanden bleiben und nicht irgendwie gelöscht werden.
Passt mein Vorschlag dann so, oder würdet ihr das ändern?

Viele Grüße

 

[Wildcard]

Mit "dem Konstruktor" ist der Konstruktor public Wein2 (int alter, double grundpreis) throws IllegalArgumentException gemeint.

Dieser Konstruktor ist ok (auch wenn fraglich ist warum der Grundpreis ausgerechnet größer als 9 sein muss...

Die anderen hingegen:

    public Wein2 () throws IllegalArgumentException {
        
 
 
        throw new IllegalArgumentException ("Sie haben kein Alter und keinen Grundpreis eingegeben!");
        
    }
    
 
    //Der Konstruktor, falls kein Grundpreis eingegeben wurde
    public Wein2 (int alter) throws IllegalArgumentException {
        
        
        throw new IllegalArgumentException ("Sie haben keinen Grundpreis eingegeben!");
        
        
    }
    
    
    //der Konstruktor, falls kein Alter eingegeben wurde    
    public Wein2 (double grundpreis) throws IllegalArgumentException {
        
        throw new IllegalArgumentException ("Sie haben kein Alter eingegeben!");
    }

Sind falsch. Entweder du löschst sie, oder du entfernst die throw statements.

 

[Painii]

Unabhängig vom Aufgabensteller:
Macht es für dich als Aufgabenlöser viel Sinn, dem Anwender 3 Konstruktoren zu geben, wovon 2 nur in einer Exception sagen dass man doch den letzten Konstruktor benutzen soll?

Dein letzter Konstruktor ist da schon sinniger, denn es kann ja gut sein dass ein Benutzer eben null angibt, dann kannst du mit der Exception sagen dass du einen echten, gültigen Wert brauchst.
Bei einem Konstruktor wo man gesagt bekommt dass man den Preis angeben soll obwohl der Konstruktor nie danach gefragt hat (es gibt ja nur ein Argument was man übergeben kann), ist dann doch ziemlich... bescheuert.

 

[Mane123]

Danke für die Hilfe.

Löschen kann ich sie nicht. Da sie zum ursprünglichen Listing gehören.

Mal angenommen, ich lösche die anderen Konstruktoren und erzeuge eine Instanz

Wein2 flasche2 = new Wein2(8);

Dann kann ich ja keine Instanz erstellen?

Und wenn ich die Throw statements entferne, was bringt das denn dann? Dann muss ich ja mit Standard werten arbeiten?

Ich soll nur eine Instanz erstellen können, wenn die Instanz mit zwei gültigen Instanzvariablen initialisiert wurde.

Der Preis >9 wurde willkürlich vom Autor gewählt.

Viele Grüße

 

[Wildcard]

Wenn die anderen Konstruktoren bleiben sollen, dann müssen sie den Konstruktor mit den meisten Argumenten aufrufen und Default Werte übergeben. Exceptions werfen ist an dieser Stelle völlig daneben.

 

[Mane123]

Also das mit den Default-Werten hatte ich schon mal ausprobiert:

public class Wein2 {
	
	private int alter;
	private double grundpreis;
	private double preisProFlasche;
	
	
	//der Standard Konstruktor
	
	public Wein2 () {
		
		this (0,0);

		//throw new IllegalArgumentException ("Sie haben kein Alter und keinen Grundpreis eingegeben!");
		
	}
	

	//Der Konstruktor, falls kein Grundpreis eingegeben wurde
	public Wein2 (int alter) throws IllegalArgumentException {
		
		this (alter, 0);
		//throw new IllegalArgumentException ("Sie haben keinen Grundpreis eingegeben!");
		
		
	}
	
	
	//der Konstruktor, falls kein Alter eingegeben wurde	
	public Wein2 (double grundpreis) throws IllegalArgumentException {
		
		this (0,grundpreis);
		//throw new IllegalArgumentException ("Sie haben kein Alter eingegeben!");
	}
	
	//der Konstruktor setzt das Alter und den Grundpreis
	//und prüft ob alle Werte plausibel sind
	
	public Wein2 (int alter, double grundpreis) throws IllegalArgumentException {
		
		if (alter > 0) {
			
			this.alter = alter;
		}
		
		else 
			throw new IllegalArgumentException ("Sie haben ein ungültiges Alter eingegeben!");
			
		
		if (grundpreis > 9)
			this.grundpreis = grundpreis;
		
		else
			throw new IllegalArgumentException ("Sie haben einen ungültigen Grundpreis eingegeben!");
		
	}
	
	//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;
	}

}

So müsste es zwar klappen, aber ich wollte eigentlich Meldungen wie "Sie haben keinen Grundpreis" oder "Sie haben kein Alter und keinen Grundpreis eingegeben" bei den Exceptions erscheinen lassen.

Stattdessen habe ich nur zwei Meldungen.

Kann ich meine gewünschten Meldungen auch irgendwie einbringen, oder ist das nur mit viel Programmieraufwand möglich?

Viele Grüße

 

[Wildcard]

Nein, dein Programm gibt dem Benutzer keine Möglichkeit keinen Grundpreis anzugeben, also kannst du diese Meldung auch nirgendwo sinnig unterbringen da dieser Zustand nicht auftritt.

 

[Mane123]

Okay, danke!

Im Prinzip kann ich mir ja die ganzen anderen Konsturktoren sparen, da dies alles irgendwie sinnlos ist?

Der Anwender soll z.B. durch grafische Eingabedialoge gezwungen sein, zwei Instanzvariablen zu erfassen, und dann würde man sich das alles ersparen...?

Viele Grüße

 

[Wildcard]

Mehrere Konstruktoren die dann Default Werte setzen können schon Sinn machen. Nur Konstruktoren die nichts anderes tun als eine Exception zu werfen sollte man sich sparen

 

[Mane123]

Hallo,

noch mal eine Frage zu den unsinnigen Konstruktoren:

Warum soll man das denn nicht machen, dass Konstruktoren mit einer Eception enden?

Macht das dann einen Unterschied, zu den Konstruktoren, die mit einer Exception enden, oder zu den Konstrutkoren, welche einen ungültigen Standard-Wert setzen und diesen dann an den Konstruktor weitergeben, welcher dann die Plausibilitätsprüfung durchführt?

Viele Grüße

 

[Wildcard]

Ungültige Defaultwerte sind genauso falsch. Ein Konstruktor der per Design überhaupt nicht funktionieren kann, hat keine Daseinsberechtigung.

 

[Mane123]

Danke für die Antwort.

Ich verstehe das schon, aber wie kann ich denn das sonst lösen, ohne die anderen Konstruktoren, welche in der jetzigen Form sinnlos sind, zu löschen?

Ich wüsste da jetzt keine Lösung, außer das Programm zu ändern. Aber das ist in dem Fall nicht der Sinn und Zweck der Aufgabe.

Viele Grüße

 

[Wildcard]

Übergib sinnvolle Defaults die nicht zu einem Fehler führen, sonst macht es einfach keinen Sinn