Java - Arrays, Getter und Setter?
Und zwar muss ich in einem Programm zwei Pizzen anlegen, mit jeweils zwei verschiedenen Preisen und Durchmessern: Als Beispiel: sagen wir mal Pizza 0 ist eine Pizza Margherita mit 26cm Durchmesser für 4€ und mit 30cm Durchmesser für 6€, und Pizza 1 ist eine Pizza Salami mit 30cm für 5€ und mit 32cm für 7€.
Das ganze soll über mehrere Klassen und mit Konstruktoren/Gettern und Settern laufen. Ist nicht weiter schwer, jedoch habe ich da ein Problem: Für die Pizzen an sich habe ich ein Array angelegt mit der Länge 2. Für die Durchmesser und Preise jeweils ein Array mit 4 Stellen. Die ersten beiden Stellen dieser Arrays gehören Pizza 0, die letzten beiden Pizza 1.
Um die Werte zu speichern habe ich ganz einfach über den Konstruktor den gesamten Array mit den Durchmessern/Preisen übergeben. Der Durchmesser Array hätte dann in diesem Fall folgende Werte: 26, 28, 30, 32.
Um die Werte auszugeben, habe ich dann sowas geschrieben wie pizza[0].getDurchmesser(0 und 1) und pizza[1].getDurchmesser(2 und 3). Die Ziffern in den Klammern sind die jeweilige Stelle im Durchmesser-/Preis Array.
Mein Problem ist nun, dass das Array, das Durchmesser/Preise speichert, 4 Stellen lang ist. Man könnte problemlos als Ausgabe pizza[0].getDurchmesser(2) schreiben, womit die Margherita einen Durchmesser von 30cm hätte, obwohl sie nur 26 oder 28 haben darf. Ich frage mich, ob mein Lösungsweg dennoch so passt und man einfach falsche Ausgaben im Code vermeiden soll, oder ob es eine bessere Lösung gibt, mit der sowas nicht vorkommen kann. Ein anderer Weg fällt mir allerdings leider nicht ein (bin nicht wirklich der erfahrenste Programmierer).
Ich hoffe, dass mir jemand helfen kann!
Zu den Klassen: ich habe eine Klasse, in der die Pizza-Attribute stehen mit den jeweiligen Gettern und Settern, in der Main wird dann der Rest bearbeitet
Was ich vergessen habe zu erwähnen, zwei verschiedene Durchmesser usw. war nur ein Beispiel, es sollen beliebig viele möglich sein!
3 Antworten
Ich würde einfach eine generelle Pizza Klasse machen, und dann subklassen für die unterschiedlichen arten Pizza und dann Entweder einen Parameter für die Größe und Preis, oder aber nochmal subklassen für die Größen.
Ich würde es so machen, dass alle möglichen Beläge in einer Liste oder evtl. auch in einer Hashmap stehen und du pro Pizza dann nochmal eine Hashmap mit den Größen und Preisen erstellst.
Etwa so:
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Pizza {
private final String topping;
private final Map<Integer, Double> diameterPrice = new HashMap<>();
public static void main(String[] args) {
Map<String, Pizza> allPizzas = new HashMap<>();
Pizza margherita = new Pizza("Margherita");
margherita.addDiameterPrice(26, 4.0);
margherita.addDiameterPrice(30, 6.0);
allPizzas.put("Margherita", margherita);
Pizza salami = new Pizza("Salami");
salami.addDiameterPrice(30, 5.0);
salami.addDiameterPrice(32, 7.0);
allPizzas.put("Salami", salami);
// Kleines Beispiel, was man mit den Pizza-Objekten anfangen kann:
for (Entry<String, Pizza> entry:allPizzas.entrySet()) {
System.out.println("Pizza Sorte: " + entry.getValue().topping);
entry.getValue().getDiametersAndPrices().forEach((diameter, price)->{
double squareCm = Math.pow(diameter/2.0, 2)*Math.PI;
double pricePerSquareCm = price/squareCm;
System.out.printf("\tDurchmesser %dcm: Preis pro cm²: %.2f cent%n", diameter, pricePerSquareCm*100);
});
System.out.println();
}
}
public Pizza(String topping) {
this.topping = topping;
}
public String getTopping() {
return topping;
}
public void addDiameterPrice(int diameter, double price) {
this.diameterPrice.put(diameter, price);
}
public Set<Integer> getDiameters() {
return diameterPrice.keySet();
}
public Map<Integer, Double> getDiametersAndPrices() {
return new HashMap<>(diameterPrice);
}
public double getPrice(int diameter) {
return diameterPrice.get(diameter);
}
}
Arrays sind in den wenigsten Fällen empfehlenswert und darüber, einzelne Eigenschaften von mehreren Objekten in einem Array abzulegen, solltest du gar nicht erst nachdenken.
Du musst eine Klasse für Pizzen machen, welche Durchmesser und Preis als Attribute hat. Getter/Setter halte ich hier für unnötig, könntest du aber theoretisch auch machen.
Dann machst du einen Array mit Objekten der Pizza-Klasse und alles ist wundervoll.
Da es sich hier eher um ein struct, also eine Gruppierung von Attributen handelt, kann man sich gerne Getter/Setter schenken. Die Klasse hat ja außer den Gettern/Settern sowieso keine Methoden, in denen etwas schief laufen könnte.
Aber wenn es dein Gewissen beruhigt, dann kann man die Attribute auch gerne final machen.
Bei einer festgelegten Anzahl bekomme ich das locker hin, habe allerdings Schwierigkeiten, das für eine beliebige Anzahl an Durchmessern usw. zu lösen. Und mit einer gescheiten Zuweisung klappts irgendwie auch nicht richtig. 🤔
Ja klar, allerdings kann eine Sorte verschiedene Durchmesser haben, man kann diese mit 26 cm Durchmesser, 28 cm Durchmesser... usw. bestellen
Dann füg einfach ein String-Attribut zur Klasse Pizza hinzu, in dem die Sorte steht.
Ein Beispiel mit Hunden:
public enum Race { Bulldog, Eskimo, Shepherd, Terrier, /* ... */ }
public class Dog {
private String name;
private Race race;
/* constructor, getters, setters, ... */
}
// main:
Dog yock = new Dog();
yock.setName("Yock");
yock.setRace(Race.Terrier);
Die Rassetypen werden in einem Enum zusammengefasst. So kann man Rechtschreibfehlern entgehen.
da hat einer noch nicht wirklich begriffen warum es OOP gibt . oh man , jetzt weiss ich warum die meiste software so buggi ist , weil sie alle zu faul sind und einfach die dinge nicht beachten wollen die im paradigma festgelegt worden sind . einfach mal strict denken und nicht irgendeinen faulheits quatsch machen . solche mitarbeiter mag ich ganz besondern , "ja geht doch auch so" und ich darf monate später dann die folge probleme lösen , weil der faule mitarbeiter ständig abkürzungen nimmt . wofür gibts kapselung , dann kann man OOP doch gleich ganz lassen . warum überhaupt private variablen , wird schon nichts passieren . *kopf auf tisch*