Plausibilitätsprüfung in dem Konstruktor mit Ausnahmebehandlung

[En_Ki]

Hallo zusammen,

ich komme bei einer Aufgabe einfach nicht weiter, ich hoffe ihr könnt mir helfen wo mein Fehler ist bzw. was ich besser machen könnte.

Die Aufgabenstellung:

Überarbeiten Sie die Plausibilitätsprüfung in dem Konstruktor der Klasse
Wein aus dem Code 1.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


Klasse Wein:

/* ################################
 * Die Klasse f�r den Wein
 * Jetzt mit Plausibilit�tspr�fung 
 ##################################*/
package java08b_01_05;

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

//   //der StandardkKonstruktor
   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 Standardwert
   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 Standardwert
   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)
   {
  
   try
   {
       //die Plausibilit�tspr�fung f�r das Alter
       if (alter > 0);
       this.alter = alter;
       this.alter = 1;
          
   }
          
           catch (IllegalArgumentException e){
      
               System.out.println("Test1");
           }
      
          
           try
           {
               //und auch f�r den Preis
               if (grundpreis > 9);
      
               this.grundpreis = grundpreis;
              
               this.grundpreis = 10;
           }
      
           catch (IllegalArgumentException e)
           {
              
               System.out.println("Test2");
           }
              
          
      
      
   }

      
  
      
   //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;
      
   }

  
}

Main Methode:

public class Java08b_01_05 {
   public static void main(String[] args)
   {
       Wein flasche1= new Wein();
       Wein flasche2= new Wein();
       try{
        new Wein(-10,20.5);
        new Wein (10,10);
       }  
       catch (IllegalArgumentException e){
          
      
       System.out.println(flasche1.getPreisProFlasche()+" Programm ende Fehler version : "+ e.getMessage() );
       System.out.println(flasche2.getPreisProFlasche() +" Programm ende  Alles Okay version : " + e.getMessage() );
       }
      
   }
      
}

ich danke euch schon mal im vorraus für die Hilfe.

 

[mihe7]

1. Bitte benutze CODE-Tags
2. Du sollst einfach bei ungültigen Werten eine IllegalArgumentException werfen, z. B.

if (alter <= 0) {
    throw new IllegalArgumentException("Alter<=0");
}

 

[Protomelas]

1. Bitte benutze CODE-Tags
2. Du sollst einfach bei ungültigen Werten eine IllegalArgumentException werfen, z. B.

if (alter <= 0) {
    throw new IllegalArgumentException("Alter<=0");
}

Hallöchen, auch wenn das Thema was Älter ist, hänge ich auch derzeit an dieser Aufgabe.

Das mit dem

if (alter <= 0) {
    throw new IllegalArgumentException("Alter<=0");
}

habe ich auch rausbekommen. Was mich stört, das Programm wird bei dem Fehler beendet..
Auch wenn das die korrekte Lösung der Aufgabenstellung ist, würde ich mich für einen besseren Lösungsansatz interessieren.
Try/Catch funktioniert ja nicht in dem Konstruktor.

 

[kneitzel]

Im Augenblick verstehe ich nicht, wo Du das Problem hast. In dem Konstruktor ist ja auch kein try/catch gewollt. Die Ausführung soll ja mit einer Exception an der Stelle abbrechen.

Und wie die im Konstruktor geworfene Exception abgefangen werden kann, das sieht man ja auch im Code:

       try{
        new Wein(-10,20.5);
        new Wein (10,10);
       } 
       catch (IllegalArgumentException e){
           // ...
       }

Sprich: Die Erzeugung des Instanz muss in einem try Block sein und die Exception abgefangen werden.

 

[Protomelas]

Im Augenblick verstehe ich nicht, wo Du das Problem hast.

Ja manchmal sollte ich einfach mal den Monitor ausmachen und ne Nacht drüber Schlafen, dann sehe ich auch den Wald vor lauter Bäumen wieder 😉
Danke für denk Denkanstoß

 

[123neu]

Ich versteh hier das Problem noch nicht ganz... die Plausibilitätsprüfung kann doch nicht so schwer sein...

public class Wein {

    private int alter;
    private double grundpreis;
    private double koeffizient;
    private double preisProFlasche;

    public Wein() {
        this(1, 10.0, 1.0);
    }

    public Wein(int alter) {
        this(alter, 10.0, 1.0);
    }

    public Wein(int alter, double grundpreis) {
        this(alter, grundpreis, 1.0);
    }

    public Wein(int alter, double grundpreis, double koeffizient) {
        if (alter <= 0) {
            throw new IllegalArgumentException("alter <= 0");
        }
        if (grundpreis < 10.0) {
            throw new IllegalArgumentException("grundpreis < 10.0");
        }
        if (koeffizient <= 0.1) {
            throw new IllegalArgumentException("koeffizient <= 0.1");
        }
        this.alter = alter;
        this.grundpreis = grundpreis;
        this.koeffizient = koeffizient;
        berechnePreisProFlasche();
    }

    private void berechnePreisProFlasche() {
        preisProFlasche = alter * koeffizient * grundpreis;
    }

    /**
     * @return the alter
     */
    public int getAlter() {
        return alter;
    }

    /**
     * @return the grundpreis
     */
    public double getGrundpreis() {
        return grundpreis;
    }

    /**
     * @return the koeffizient
     */
    public double getKoeffizient() {
        return koeffizient;
    }

    /**
     * @return the preisProFlasche
     */
    public double getPreisProFlasche() {
        return preisProFlasche;
    }

    @Override
    public String toString() {
        return String.format("Wein [alter=%s, grundpreis=%s, koeffizient=%s, preisProFlasche=%s]", alter, grundpreis, koeffizient, preisProFlasche);
    }

    public static void main(String[] args) {
        Wein standard = new Wein();
        Wein gehoben = new Wein(5);
        Wein extravagant = new Wein(25, 15);
        Wein fuerCheater = new Wein(25, 15, 0.8);
        try {
            Wein ungeniessbar = new Wein(0);
            System.out.println(ungeniessbar);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        System.out.println("Standard: " + standard);
        System.out.println("Gehoben: " + gehoben);
        System.out.println("Extravagant: " + extravagant);
        System.out.println("20 % off: " + fuerCheater);
    }

}

 

[Protomelas]

Also ich hab das nun so gelöst:

[CODE lang="java" title="main"] // Ungültiges int (Negative) / Gültiges double
try {
Wein Rot = new Wein(-5, 20.5);
System.out.println("Rot: " + Rot.getPreisProFlasche());

} catch (IllegalArgumentException e) {
System.out.println("Rot: " + e.getLocalizedMessage());
}[/CODE]
HIer rufe ich nun einen von den zahlreichen Konstruktoren auf:

[CODE lang="java" title="Konstruktor"]// Beide Werte werden übergeben
public Wein(int alter, double grundpreis) {
this.grundpreis = grundpreis;
this.alter = alter;
PlausiCheck();
}[/CODE]

und den Plausibilitätscheck habe ich in einer eigenen Methode gepackt:

[CODE lang="java" title="Plausibilitätsprüfung"]// Plausibilitätsprüfung ausgelagert in einer eigenen Methode

private void PlausiCheck() {
if (alter <= 0 && grundpreis <= 0) {
throw new IllegalArgumentException("Beide Werte sind ungültig!");
}
if (alter <= 0) {
throw new IllegalArgumentException("Alter muss größer als 0 sein!");
}
if (grundpreis <= 0) {
throw new IllegalArgumentException("Grundpreis muss größer als 0 sein!");
}

}[/CODE]

Hoffe das ist so alles in Ordnung, funktionieren tut es auf jedenfall.

 

[mrBrown]

Was mich stört, das Programm wird bei dem Fehler beendet..

Generell ist es in dem Fall auch sinnvoll, das Programm mit einem Fehler zu beenden.

Die Exception (bzw, allgemeiner RuntimeExceptions) bedeutet ja im Prinzip „der Programmierer hat einen Fehler gemacht“, und das Programm befindet sich danach in einem ungültigen Zustand (da ja irgendwas, was eigentlich ausgeführt werden sollte, nicht ausgeführt werden konnte). Da kann man im Allgemeinen nicht anders drauf reagieren, als das Programm zu beenden (oder zumindest den aktuellen Teil des Programms, der betroffen ist).

Wenn du als Programmierer sinnvollere Möglichkeiten siehst, als mit einer Fehlermeldung und Beenden auf solche Fehler (RuntimeExceptions) zu reagieren, dann solltest du die natürlich einbauen. Aber, dann nicht als Reaktion auf den schon ausgelösten Fehler, sondern proaktiv in dem du prüfst, ob zB die Argumente, die du übergeben willst, gültig sind.

 

[123neu]

mrBrown meint damit, dass Ausnahmen nicht den Programmfluss steuern sollten.

Bastle dir einen Verifier!