Aufgabe: Pizza Konstruktor mit mehreren beliebigen Durchmesser/Preiskombinationen

[nirane]

Hallihallo Welt,

Erstes Semester Programmieren, einfache Übungaufgabe aber Blackout seit Stunden :|

Ich habe bereits folgende Klasse:

public class Pizza {
    String name;
    int durchmesser;
    float preis;
    public Pizza(String name, float preis, int durchmesser)
    {
        this.name = name;
        this.durchmesser = durchmesser;
        this.preis = preis;
    }

//sowie alle get und set-Methoden

Nun soll die Klasse so erweitert werden, so dass eine Pizza mehrere beliebige Durchmesser/Preiskombinationen haben kann (Bspw zum Anlegen von Kinderpizzen, Familienpizzen, etc.).
Dafür soll dann auch ein passender Konstruktor erstellt werden. In einer anderen Klasse Speisekarte sollen dann die Pizza-Objekte angelegt werden.

Bsp:
Name 25cm 35cm 50cm
Salami 4,50 5,50 9,50
Schinken 4,50 5,00 9,00

Ich steh nur grade völlig auf dem Schlauch. Meine erste Idee war die Variablen durchmesser und preis als Array anzulegen. Allerdings komm ich auf keine Lösung wie ich das im Konstruktor anständig umsetzen kann.

Google hat mir leider nicht weitergeholfen.
Deshalb hoffe ich hier auf Anregungen. Bin ich mit meiner Array Idee in der richtigen Richtung?
Alternativ Vorschläge?

Danke schonmal vorab!

 

[Tobse]

In einer anderen Klasse Speisekarte sollen dann die Pizza-Objekte angelegt werden.

Das ist ziemlich schwammig formuliert. Dashier müsste okey gehen:

class Speisekarte
    public static final Pizza SalamiKlein = new Pizza("Salami", 4.5f, 25);
    public static final Pizza SalamiMittel = new Pizza("Salami", 5.5f, 35);
    public static final Pizza SalamiGroß = new Pizza("Salami", 9.5f, 50);

    public static final Pizza SchinkenKlein = new Pizza("Schinken", 4.5f, 25);
    public static final Pizza SchinkenMittel = new Pizza("Schinken", 5f, 35);
    public static final Pizza SchinkenGroß = new Pizza("Schinken", 9f, 50);
}

 

[kneitzel]

Also Du kannst im Kontruktor ja auch Arrays übergeben, so dass die Übergabe ja kein Problem sein sollte.

Ich finde es nur unschön, dass Du hier Dinge, die zusammen gehören, getrennt verwaltest. Durchmesser und Preis und was sonst noch dazu gehört, gehören ja zusammen.

Ich richte mich gerne immer etwas nach der Realität, denn das macht es ja doch am einfachsten wenn es um das Verstehen des Codes geht. Und sorry - eine Pizza hat einen Durchmesser und einen Preis. Das was Du dann auf der Karte siehst ist ja nur eine Gruppierung von Daten, aber angeboten wird Salami 25 cm, Salami 35 cm und Salami 50 cm. Man muss sich dann nur für eine Auswahl entscheiden.

Du kannst ja evtl. eine PizzaSorte haben - und da hat dann die Salami die drei Pizzen drin.

Konrad

 

[Tobse]

Das was @kneitzel vorschlägt wäre dann der nicht-schlampige Ansatz (meiner ist schlampig ) +1 dafür

 

[nirane]

Danke für eure Hilfe! Die ganze Aufgabe war leider so schwammig formuliert..

Ich habe mir jetzt einfach eine weitere Klasse Variationen geschrieben:

public class Variation {
    int durchmesser;
    float preis;
  
    public Variation(int durchmesser, float preis) {
        this.durchmesser = durchmesser;
        this.preis = preis;
    }
}

public class Pizza {
    String name;
    Variation[] variationen;
    public Pizza(String name, Variation... var) {
        this.name = name;
        this.variationen = var;
    }
}

public class Speisekarte {
    public static void main(String[] args) {
            final int ANZAHL_PIZZEN = 5;
            Pizza[] pizzas = new Pizza[ANZAHL_PIZZEN];
            pizzas[0]= new Pizza("Salami", new Variation(26, 4.5f), new Variation(32, 6));
            pizzas[1]= new Pizza("Schinken", new Variation(26, 4.5f), new Variation(32, 6));
            pizzas[2]= new Pizza("Margarita", new Variation(26, 4), new Variation(32, 5.5f));
            pizzas[3]= new Pizza("Vegetaria", new Variation(26, 5), new Variation(32, 6.5f));
            pizzas[4]= new Pizza("Hawaii", new Variation(26, 5), new Variation(32, 6.5f));
        }

Ich denke so hat es sich @kneitzel mit der Pizzasorte auch gedacht?

 

[Tobse]

Nein, das hat er nicht. Stell dir vor du hast eine Pizza vor dir, eine die man essen kann. Weiss diese Pizza, welche Variationen es von ihr gibt? Ich denke nicht.

Hier mal die Version, die ich genommen hätte, wenn ich diese Aufgabenstellung für einen Kunden hätte umsetzen müssen. Ist sehr detailiert und daher als Anhang. Die Wichtigsten Klassen trotzdem hier im Thread:

public interface PizzaSorte {
    public String name();
    public float preis();
    public int durchmesser();
    public Set<ZutatArt> zutatenArten();
}

class SalamiPizzaSorte implements PizzaSorte {
    private static final Set<ZutatArt> ZUTATEN_ARTEN = new HashSet<>(Arrays.asList(
        Emmentaler.INSTANCE, Tomate.INSTANCE, Salami.INSTANCE
    ));          
 
    private int durchmesser;
    private float preis;
 
    public SalamiPizzaSorte(int durchmesser, float preis)
    {
        this.durchmesser = durchmesser;
        this.preis = preis;
    }

    @Override
    public String name() {
        return "Salami";
    }

    @Override
    public float preis()
    {
        return preis;
    }

    @Override
    public int durchmesser()
    {
        return durchmesser;
    }

    @Override
    public Set<ZutatArt> zutatenArten() {
        return ZUTATEN_ARTEN;
    }
}

public class JavaForumPizzeria implements Pizzeria {

    private static JavaForumPizzeria singleton;
 
    public synchronized static Pizzeria getInstance() {      
        if (singleton == null) {
            // Speisekarte aus der Konfigurationsdatei lesen
            Speisekarte speisekarte = new SpeisekarteImpl(
                new SalamiPizzaSorte(25, 4.5f),
                new SalamiPizzaSorte(35, 5.5f),
                new SalamiPizzaSorte(50, 9.5f)
            );
          
            // Zutatenlager instantiieren
            ZutatenLager lager = new EinfachesZutatenLager();
          
            singleton = new JavaForumPizzeria(speisekarte, Tobse.getInstance(), lager);
        }
      
        return singleton;
    }
 
    private Speisekarte speisekarte;
    private PizzaBäcker bäcker;
    private ZutatenLager lager;
 
    private JavaForumPizzeria(Speisekarte speisekarte, PizzaBäcker bäcker, ZutatenLager lager)
    {
        this.speisekarte = speisekarte;
        this.bäcker = bäcker;
        this.lager = lager;
    }
 
    @Override
    public Speisekarte speisekarte() {
        return this.speisekarte;
    }

    @Override
    public Pizza pizzaBestellen(PizzaSorte sorte)
        throws PizzaSorteNichtVerfügbarException
    {
        if (this.speisekarte().enthaelt(sorte))
        {
            try {
                return bäcker.backePizza(sorte, lager);
            }
            catch (ZutatenLager.ZutatNichtVorrätigException ex)
            {
                throw new PizzaSorteNichtVerfügbarException(ex.getMessage(), ex);
            }
        }
        else
        {
            throw new PizzaSorteNichtVerfügbarException("Die Pizzasorte " + sorte.name() + " steht leider nicht auf unserer Speisekarte");
        }
    }
}

public class Pizza {
    private int durchmesser;
    private Collection<Zutat> zutaten;

    public Pizza(int durchmesser, Collection<Zutat> zutaten) {
        this.zutaten = zutaten;
        this.durchmesser = durchmesser;
    }

    public int durchmesser() {
        return this.durchmesser;
    }

    public Collection<Zutat> zutaten() {
        return this.zutaten;
    }
 
    public String toString() {
        final StringBuilder res = new StringBuilder();
        res.append("Pizza mit Durchmesser ");
        res.append(Integer.toString(durchmesser));
        res.append("cm und diesem Belag:");
     
        zutaten().forEach((zutat) -> res.append(" " + zutat.name()));
     
        return res.toString();
    }
}

P.S.: Ja, ich weiß, das Produziert so momentan eine PizzaSorteNichtVerfügbarException weil das Lager nicht gefüllt ist.
P.P.S.: Ja, JavaDocs fehlen auch. Hier gehts aber um die Architektur, nicht um hochwertigen Code.

 

[kneitzel]

Nunja - er hat mich prinzipiell schon richtig verstanden. Nur eben bei der Umsetzung gibt es einen kleines Problem bei der Namensgebung.

Deine Klasse heisst Pizza aber du schreibst im Text, dass es eine PizzaSorte ist.

Bei der objektorientierten Entwicklung ist es in meinen Augen immer sehr wichtig, klare Namen zu wählen, die genau das Ausdrücken, was es ist. Wenn da also eine Pizza definiert wird, dann sollte es das sein, was man so als Pizza kennt. Also in diesem Fall eine Pizza einer bestimmten Größe die evtl. für einen bestimmten Preis verkauft wird.

Aber evtl. hilft es, hier von einem PizzaAngebot zu sprechen. Da kann das PizzaAngebot für Salami-Pizza unterschiedliche Variationen enthalten. Ansonsten muss man sehr genau aufpassen, was man wie macht.

Die Implementation von Tobse finde ich interessant, aber ich hätte dies nicht so gemacht. PizzaSorte ist ja kein wirkliches Interface sondern eher eine Klasse. Und Salami Pizza ist eher eine Instanz als eine eigene Implementation. Es müsste ja eine Lösung sein, bei der man ein neues Angebot erstellen kann, ohne dass man da eine neue Klasse erstellen muss. Aber das ist eine Interpretation der Aufgabe und was hier das eigentliche Ziel ist!

Also wenn ich da etwas aufteilen müsste, dann hätte ich:
- PizzaAngebot (Das passt evtl. besser, denn in der Speisekarte sind dann ja Angebote enthalten)
-> PizzaRezept (Also was ist drauf, kann aber auch mehr enthalten. Dann evtl. auch noch anderer Name. PizzaBeschreibung oder so. Dann ist da der Werbespruch mit drin oder ein Bild oder ...)
-> Durchmesser mit Preis

- Pizza wäre dann die konkrete Pizza Bestellung. Die bezieht sich dann auf ein bestimmtes PizzaAngebot, aber erweitert das noch durch weitere Zutaten (also Exta Käse und noch Schinken bitte!)

- Bestellung wäre dann mehrere Pizzen, hätte einen Gesamtpreis, ggf. Lieferadresse, ggf. Zuschlag, ...

Wichtig ist, dass ich kein Sammelsurium von Durchmessern mit Preis habe. Und wenn ich das doch irgendwie bräuchte, dann würde ich dafür einen Namen finden und hätte dann eine Instanz mit Durchmesser und Preis. Das gehört ja zusammen! Wieso etwas trennen, das zusammen gehört?

Generell ist das ähnlich wie bei der Strukturierung von Code. Wenn ich doppelten Code habe, dann ziehe ich den in eine Methode und rufe die auf. Wenn ich hier etwas doppelt habe, dann ziehe ich das raus in eine eigene Instanz.

Also mein Pizza Angebot hat
- Name ("Salami")
- Zutaten ("Salami, Tomatensoße, Mozarella")
- Werbespruch ("Die leckere, preiswerte Pizza - stillt jeden Hunger für kleines Geld! Bla bla bla ...")
- Durchmesser
- Preis

Nun bekomme ich mehrere Salami Pizzen bei denen Name, Zutaten und Werbspruch gleich ist: Dann fasse ich die in eine eigene Klasse. So halte ich die Daten nur einmal vor und alle Stellen, die es brauchen, referenzieren es.

Wäre eine mögliche Sichtweise, die das etwas erklären könnte. Hier hakt es nur etwas, denn ich kann hier durchaus Daten mehrfach vorhalten. Bei Code ist das eigentlich immer ein Grund etwas anzupassen aber bei der Datensicht stimmt das nicht immer und kann daher nur als Hilfestellung bei der Klassenfindung dienen.

Konrad

 

[Jardcore]

Hier gehts aber um die Architektur, nicht um hochwertigen Code

Man kann hochwertigen Code auch komplett ohne Docs schreiben -> Clean Code

 

[Tobse]

PizzaSorte ist ja kein wirkliches Interface sondern eher eine Klasse. Und Salami Pizza ist eher eine Instanz als eine eigene Implementation. Es müsste ja eine Lösung sein, bei der man ein neues Angebot erstellen kann, ohne dass man da eine neue Klasse erstellen muss.

Richtig - an dieser Stelle war ich mir sehr unsicher, was die bessere Möglichkeit ist. Ich denke letzten Endes ist es egal.

Man kann hochwertigen Code auch komplett ohne Docs schreiben -> Clean Code

Da bin ich anderer Meinung - aber das führt hier zu weit.