Ich habe eine ArrayListe mit
public class Getraenk(){
String name;
int menge;
und eine ArrayListe wo die Getränke gespeichert werden
ArrayList<Getranke> lager = new ArrayList<Getraenk>();
eine Methode soll das hinzufügen ermöglichen.
public void add(Getraenk getraenk){
if (lager.contains(getrank){
// nun soll nur die Menge hinzugefügt werden
}
kann mir jemand helfen das umzusetzen?
Danke schon mal
Warum willst du denn sowas machen? Das ist doch völlig sinnlos ^^
Die Klassen werden sich ohnehin NIE gleichen, wenn der Wert einer Variablen anders ist.
wenn ich ein neues Getränk hinzufüge möchte ich ja kein neues erstellen sondern nur die Menge des bereits vorhandenen erhöhens…
und dass will ich in der Methode umsetzen können
Du benötigst Zugriffsmethoden in Getränk.
private String name;
private int menge;
public Getraenk(String name) {
this.name = name;
this.menge = 0;
}
public void setMenge(int menge) {
this.menge = menge;
}
public int getMenge() {
return menge;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}```
Um nun ein Getränk in deiner Liste in seiner Lagermenge zu erhöhen, machst du nun folgendes in deiner Klasse Lager, die die ArrayList hält:
```public void kaufen(String name, int menge) {
for(int i = 0, j = lager.size(); i < j; i++) {
Getraenk g = lager.get(i);
if(g.getName().equals(name)) {
int m = g.getMenge();
g.setMenge(m += menge);
break;
}
}
}```kannst du sagen wie die for schleife funktioniert.
ich hab versucht das so umzusetzen, allerdings hab ich probleme mit dem i und j.
j wird ja nicht mal deklariert?!
Danke
Im Prinzip ist das sowas wie:
int x = 0, y = 1;
Ich habe das gemacht, damit nicht immer wieder bei jedem Schleifendurchlauf
die size()-Methode für den Vergleich aufgerufen wird.
ah okay, raffiniert 
ein Problem hab ich noch
bei dem Code Teil
g.setMenge(g.getMenge() += menge);
kommt die Fehlermeldung
„The left hand side of an assigment must be a variable“
kann damit leider nicht viel anfangen…
Zeige mal bitte deinen Code.
Ich habe oben noch mal die setMenge()-Methode berichtigt.
tmp.setQutntiy(tmp.getQuantity() += quantity);
eigentlich genau gleich. er kommt wohl mit der “Gleichung” bzw der Zuweisung nichtg klar
Kannst du mir mal etwas posten, was ich kompilieren kann, ich bin mir im Moment nicht im Klaren, wo da mein Fehler liegen soll.
Habe den Code aus dem Kopf ohne Test gepostet.
public void add(Getraenk getraenk, int quantity){
for (int i = 0, j = list.size(); i < j; i++){
Getraenk Tmp = list.get(i);
if(Tmp.getName().equals(getraenk)){
Tmp.setQuantiy(Temp.getQuantity() += quantity);
break;
}
}
also das ist meine Methode
Sorry, das war jetzt mein Fehler. Die berichtigte Klasse Getraenk findest du oben.
Teste bitte nochmal.
also du hast sie Setter Methoden und den Konstruktor geändert?!
Allerdings besteht bei mir immer noch das gleiche Problem…
OK, probiere bitte mal die berichtigte kaufen()-Methode. ^^
und
else{
list.add(getraenk);
dann wäre es komplett?
Also schön, mal ganz schnell zusammengeschrieben eine lauffähige, ausbaufähige Variante:
Ein Getränk:
private String name;
private int menge;
public Getraenk(String name) {
this.name = name;
this.menge = 0;
}
public void setMenge(int menge) {
this.menge = menge;
}
public int getMenge() {
return menge;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}```
Ein Getränkelager:
```import java.util.*;
public class Getraenke {
private List<Getraenk> lager;
public Getraenke() {
lager = new ArrayList<Getraenk>();
}
public void anlegen(String name) {
for(int i = 0, j = lager.size(); i < j; i++) {
Getraenk g = lager.get(i);
if(g.getName().equalsIgnoreCase(name)) {
return;
}
}
lager.add(new Getraenk(name));
}
public Getraenk suche(String name) {
for(int i = 0, j = lager.size(); i < j; i++) {
Getraenk g = lager.get(i);
if(g.getName().equals(name)) {
return g;
}
}
return null;
}
public void kaufen(String name, int menge) {
for(int i = 0, j = lager.size(); i < j; i++) {
Getraenk g = lager.get(i);
if(g.getName().equals(name)) {
int m = g.getMenge();
g.setMenge(m += menge);
break;
}
}
}
public void verkaufen(String name, int menge) {
for(int i = 0, j = lager.size(); i < j; i++) {
Getraenk g = lager.get(i);
if(g.getName().equals(name)) {
int m = g.getMenge();
if((m - menge) > 0) {
g.setMenge(m -= menge);
break;
}
}
}
}
public void zeigeBestand() {
System.out.println("Lagerbestand
");
for(int i = 0, j = lager.size(); i < j; i++) {
Getraenk g = lager.get(i);
System.out.println(g.getName()+": "+g.getMenge()+" Stück");
}
}
}```
Und eine Klasse, die eine Demo ausführt:
```public class GetraenkeTest {
public static void main(String[] args) {
Getraenke lager = new Getraenke();
lager.anlegen("Cola");
lager.anlegen("Bier");
lager.anlegen("Sekt");
lager.anlegen("Fanta");
lager.kaufen("Cola", 10);
lager.kaufen("Bier", 15);
lager.kaufen("Sekt", 8);
lager.zeigeBestand();
lager.verkaufen("Bier", 9);
lager.zeigeBestand();
}
}```
Kann noch beliebig erweitert werden.
Möglicherweise eignet sich ein anderer Collection-Typ besser für die Datenverwaltung /-haltungVielen Dank für die Hilfe.
Eine Frage bleibt für mich noch übrig. Wo kann ich meine Eingaben Validieren ?
bspw. dass keine Getraenk einen leeren String als namen hat …?
kann ich das in den getter und setter methoden einbauen? oder macht man sowas besser noch in den Methoden?
Getraenk ist eine reine Datenklasse (POJO), die nichts über Manipulation wissen braucht. Ob ein neues Getränk auch mit einem Leerstring angelegt werden darf, ist eine Frage der Verwaltung. Dementsprechend wäre diese Funktion in Getraenke zu implementieren. Entweder legst du eine weitere Methode an, die Eingaben überprüft, oder baust es mit in anlegen() ein.
Bspw. so:
//Maßnahmen bei Versuch, einen leeren Namen zu speichern.
}```