Ich fürchte, dass wird genauso ein Drama, wie beim letzten Mal.
Und der Code macht wenig Sinn. Getter so aufrufen soll was bringen? Wenn er eine neue Zutat Instanz erzeugt, dann geht es wohl auch mehr um das Setzen von Werten und nicht um das Abfragen eines Wertes. Ich finde es toll, wie Du hier heran gehst, aber ich sehe da ehrlich gesagt keinen Sinn. Grundlagen muss er sich erarbeiten wollen und dazu gibt es genug Möglichkeiten. Würde zeitlich sogar schneller gehen als die Scharade hier und der Erfolg wäre ein Verständnis und nicht nur ein herumraten ohne irgendwas verstanden zu haben.Es fehlt die Typangabe für den Parameter anzahlVorhanden.
Allerdings hat die Methode produzieren() laut Aufgabe nur einen Parameter...
Aus meiner Sicht ist es existenziell, dass Xknight eigenständig fehlende Grundlagen erarbeitet. Wir können bei Verständnisproblemen aushelfen, aber wir können keine Java Grundlagen für den TE erarbeiten!
Doch mir ist schon bewusst wozu Getter und Setter dienen.
Ja, klar!Wie rufe ich mit einem getter die Variablen?
Die Methode produzieren bekommt die Anzahl der zu produzierenden Einheiten als int Parameter. Wenn bei jeder einzelnen Zutat mindestens genauso viele Einheiten verfügbar sind, dann kann die anzahlVorhanden um die produzierte Anzahl erhöht und die anzahlVerfuegbarerEinheiten bei den Zutaten um die produzierte Anzahl erniedrigt werden. Wenn es erfolgreich war, soll true, andernfalls falls, zurückgegeben werden.
Indem du die Getter-Methode auf die gewünschte Instanz der Klasse aufrufst? Wie auch sonst?Es geht doch nur darum wie ich mit getter die Variablen aus zwei unterschiedlichen Klassen aufrufen kann?
Das war nur eine generelle Antwort auf die Frage, wie man einen Getter aufruft. Die Antwort passt nicht genau zu deinem Problem. Du musst die Getter für jede einzelne Zutat in Milchprodukte aufrufen.Ja, aber den Getter kann ich nicht aufrufen in der produzieren Methode, laut Aufgabe. Außerhalb der Methode bekommt man auch eine Fehlermeldung wenn ich es so mache wie @temi eben sagte in #45.
für jede zutat in zutaten {
wenn die zutat nicht null ist und die anzahl der zutat < anzahl, dann beende mit false;
}
Java:Produkt.getAnzahlVorhanden()+=anzahl; Zutat.getAnzahlVerfügbarerEinheiten()-=anzahl;
public boolean produzieren(int anzahl) {
for(int i = 0;anzahl<zutat.length;i++) {
if(anzahl>=zutat.length) {
Produkt.getAnzahlVorhanden+=anzahl;
Zutat.getAnzahlVerfügbarerEinheiten-=anzahl;
return true;
}
}
return false;
}
public abstract class Produkt{
public static int getAnzahlVorhanden;
private String name;
private int anzahlVorhanden;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAnzahlVorhanden() {
return anzahlVorhanden;
}
public void setAnzahlVorhanden(int anzahlVorhanden) {
this.anzahlVorhanden = anzahlVorhanden;
}
Produkt(String name, int anzahlVorhanden) {
this.name=name;
this.anzahlVorhanden=anzahlVorhanden;
}
public abstract class Milchprodukt extends Produkt{
Milchprodukt(String name, int anzahlVorhanden) {
super(name,anzahlVorhanden);
}
}
public class Obst extends Produkt{
Obst(String name, int anzahlVorhanden){
super(name,anzahlVorhanden);
}
}
}
public class Zutat {
public static int getAnzahlVerfügbarerEinheiten;
private String name;
private int anzahlVerfügbarerEinheiten;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAnzahlVerfügbarerEinheiten() {
return anzahlVerfügbarerEinheiten;
}
public void setAnzahlVerfügbarerEinheiten(int anzahlVerfügbarerEinheiten) {
this.anzahlVerfügbarerEinheiten = anzahlVerfügbarerEinheiten;
}
Zutat(String name, int anzahlVerfügbarerEinheiten){
this.name=name;
this.anzahlVerfügbarerEinheiten=anzahlVerfügbarerEinheiten;
}
public int nachkaufen(int einheiten) {
anzahlVerfügbarerEinheiten+=einheiten;
return anzahlVerfügbarerEinheiten;
}
}
Träum schön weiter!Ich habe jetzt keine Fehlermeldungen. Ich habe die jetzt alle beseitigt. ^^
Ja, das mit den keine Fehlermeldungen bekommen ist ein ganz wichtiges Kriterium. Da dies offensichtlich das wichtigste Kriterium für Dich ist, möchte ich einfach eine Musterlösung teilen:Ich habe jetzt keine Fehlermeldungen. Ich habe die jetzt alle beseitigt. ^^
public class Loesung {
public static void main(String[] args) {}
}
Was ist denn daran alles scheiße?
Sorry, aber der erste Thread mit euch war schon recht extrem. Vieles wurde mehrfach gesagt. Und Lerneffekt war - wie man hier dann erkennt - annähernd null. Und im Internet findet sich extrem viel. Erste Links habe ich schon gebracht. Für die Abgabe sehe ich schwarz - das war schon beim letzten Thread mehr als grenzwertig und da wurde euch auch schon ein "Vergesst es" gesagt.Ich verstehe nicht wieso ihr so antwortet, man kann das doch normal klären, ohne sich so zu äußern(auch wenn es schwer fällt für euch als Profis). Wir beschäftigen uns nun mal erst seit kurzem damit. @temi Was ist denn daran alles scheiße ? Wäre sehr nett von dir wenn du sagst wo genau da ein Fehler liegt , es ging hier letztendlich nur darum, wie man die Attribute einer anderen Klasse in der Methode einer wieder anderen Klasse auruft. Wenn du sonst noch einen Fehler siehst, wäre es lieb wenn du diesen einfach konkret benennst.
@JustNobody Ich weiß nicht was du mit deinem letzten Beitrag forderst? Was daran ist eine Musterlösung, zur Lösung des Problems (die Attribute in einer Klasse in einer anderen aufrufen) trägt es nichts bei?
Ich finde es auch sehr sinnvoll, auch wenn ihr das anders seht, aber es ist doch verständlich, dass man fragt, wie das funktioniert , wenn man im Internet nichts Hilfreiches dazu findet wie genau man das jetzt macht? Dass man dann hier mal fragt, ist dann die letzte Option, die man (was ich euch nicht unterstellen will!!!) nicht mit Füßen treten sollte. Mit der Zeit sollte man merken, dass es immer besser wird und zu sagen die Grundlagen sind in keiner Hinsicht vorhanden stimmt doch überhaupt nicht. Ich bitte da einfach um Verständnis bei dem Text hier.
public static int getAnzahlVerfügbarerEinheiten;
public static int getAnzahlVorhanden;
public class Milchprodukt implements Produzierbar {
private double fettgehalt;
Zutat[] zutaten = null;
public double getFettgehalt() {
return fettgehalt;
}
public void setFettgehalt(double fettgehalt) {
this.fettgehalt = fettgehalt;
}
Milchprodukt(double fettgehalt, Zutat[] zutaten) {
this.zutaten = zutaten;
this.fettgehalt = fettgehalt;
this.zutaten = new Zutat[10];
}
public class Kaese extends Milchprodukt {
public Kaese(double fettgehalt, Zutat[] zutaten) {
super(fettgehalt, zutaten);
}
}
public class Yoghurt extends Milchprodukt {
public Yoghurt(double fettgehalt, Zutat[] zutaten) {
super(fettgehalt, zutaten);
}
}
public boolean produzieren(int anzahl) {
if (anzahl <= zutaten.length) {
Produkt.getAnzahlVorhanden += anzahl;
Zutat.getAnzahlVerfuegbarerEinheiten -= anzahl;
return true;
}
return false;
}
public boolean addZutat(Zutat zutat) {
for (int i = 0; i < zutaten.length; i++) {
if (zutaten[i] == null) {
zutaten[i] = zutat;
return true;
}
}
return false;
}
public boolean removeZutat(Zutat zutat) {
for (int i = 0; i < zutaten.length; i++) {
if (zutaten[i] == zutat) {
zutaten[i] = null;
return true;
}
}
return false;
}
}
Wäre sehr nett von dir wenn du sagst wo genau da ein Fehler liegt , es ging hier letztendlich nur darum, wie man die Attribute einer anderen Klasse in der Methode einer wieder anderen Klasse auruft.
class Foo {
private int value = 42;
public int getValue(){
return value;
}
}
class Bar {
private Foo foo = new Foo();
public void doSomething() {
int value = foo.getValue();
}
}
Ich habe es mal gemacht, wie ich es meine korrekt gemacht zu haben. Mir geht es darum, ist das korrekt, wenn nein dann bitte nur sagen, was genau nicht und ich versuche es selbst zu analysieren.
Also da ist schon einiges gesagt worden. Was direkt auffällt ist, dass da verschachtelte Klassen sind. So ihr nicht wirklich spezielle Anforderungen habt, dann gewöhnt euch immer an: Jede Klasse kommt in eine eigene Datei die genau so heißt, wie die Klasse (nur mit .java dran).Ja, @JustNobody, du hast schon Recht.Java:public class Milchprodukt implements Produzierbar { private double fettgehalt; Zutat[] zutaten = null; public double getFettgehalt() { return fettgehalt; } public void setFettgehalt(double fettgehalt) { this.fettgehalt = fettgehalt; } Milchprodukt(double fettgehalt, Zutat[] zutaten) { this.zutaten = zutaten; this.fettgehalt = fettgehalt; this.zutaten = new Zutat[10]; } public class Kaese extends Milchprodukt { public Kaese(double fettgehalt, Zutat[] zutaten) { super(fettgehalt, zutaten); } } public class Yoghurt extends Milchprodukt { public Yoghurt(double fettgehalt, Zutat[] zutaten) { super(fettgehalt, zutaten); } } public boolean produzieren(int anzahl) { if (anzahl <= zutaten.length) { Produkt.getAnzahlVorhanden += anzahl; Zutat.getAnzahlVerfuegbarerEinheiten -= anzahl; return true; } return false; } public boolean addZutat(Zutat zutat) { for (int i = 0; i < zutaten.length; i++) { if (zutaten[i] == null) { zutaten[i] = zutat; return true; } } return false; } public boolean removeZutat(Zutat zutat) { for (int i = 0; i < zutaten.length; i++) { if (zutaten[i] == zutat) { zutaten[i] = null; return true; } } return false; } }
Den Code auf der ersten seite von @Xknight hatte ich nicht durchgeschaut. Ich habe es mal gemacht, wie ich es meine korrekt gemacht zu haben. Mir geht es darum, ist das korrekt, wenn nein dann bitte nur sagen, was genau nicht und ich versuche es selbst zu analysieren. Ich will nicht nach schon besagter Strategie "Mal Raten und Herumprobieren" vorgehen, sondern ernsthaft darüber Gedanken machen und nicht ständig irgendeinen Code posten und wieder fragen: Ist dieser korrekt? Sondern ich werde konkrete Fragen stellen.
Produkt.getAnzahlVorhanden += anzahl;
@temi ,Was genau meinst du mit freien Klassen?
Ja. In dem "statt:"-Teil ist Kaese eine innere Klasse von Milchprodukt.Wie meide ich die inneren Klassen?
Java:z.B.: public class Kaese extends Milchprodukt { } statt: public class Milchprodukt extends Produkt implements Produzierbar { public class Kaese extends Milchprodukt { } }
So ihr nicht wirklich spezielle Anforderungen habt, dann gewöhnt euch immer an: Jede Klasse kommt in eine eigene Datei die genau so heißt, wie die Klasse
Gut, aber warum ist dann die Klasse Kaese in deiner Klasse Milchprodukt?Ich habe doch für jede Klasse eine eigene Datei angelegt mit dem Namen Kaese.java, Produkt.java,Produzierbar.java,... .
Wenn dass innerhalb der Klasse Milchprodukt steht, ja. Die Klasse Kaese in der Datei Kaese.java sieht ja genauso aus.Das wäre dann also die Klasse Kaese in Klasse Milchprodukt?Java:public class Kaese extends Milchprodukt { }
In dem Code aus #74 steht genau das in der Klasse Milchprodukt. Warum?Das steht nicht in der Klasse Milchprodukt sondern das ist die Klasse Kaese.
Damit bezweckt man, dass die Klasse Milchprodukt von Kaese überschrieben wird?
Hmpf. Wir reden jetzt seit #75 darüber, dass das falsch ist.Weiß nicht, das ist falsch ?![]()
Nein, nicht erst jetzt. Fast seit 15 Beiträgen. Da kann man echt die Lust verlieren.Also es wurde ja jetzt gesagt, dass es falsch ist das so wie in #74 zu tun.
class ÄußereKlasse {
class InnereKlasse {
}
}
Damit solltest du dann dringend und sofort aufhören, sonst wird die weitere Hilfsbereitschaft hier gegen Null gehen.Oder einfach , ich habe mich dumm gestellt ?