# Sub- und Superklassen



## Xknight (16. Dez 2019)

Wie kann ich meine Fehler in der Subklasse in meiner Superklasse fixieren, obwohl ich es wie im Lehrbuch gemacht habe?
Da bei meinen Subklassen wird immer ein Fehler angezeigt.

```
public abstract class Milchprodukt implements Produzierbar {
    private double fettgehalt;
    Zutat [] zutat;


    public double getFettgehalt() {
        return fettgehalt;
    }

    public void setFettgehalt(double fettgehalt) {
        this.fettgehalt = fettgehalt;
    }
   
    public class Produkt extends Milchprodukt{
        private String name;
        protected int anzahlVorhanden;
       
    }
   


    public class Zutat extends Milchprodukt{
        private String name;
        protected int anzahlVerfügbarerEinheiten;
    }

    public Milchprodukt(String name,int anzahlVorhanden,int anzahlVerfügbarerEinheiten,Zutat[] zutat, double fettgehalt) {
        super(name,anzahlVorhanden,anzahlVerfügbarerEinheiten);
        this.zutat=zutat;
        this.fettgehalt=fettgehalt;
       
        this.zutat = new Zutat[10];
       
    }


    public boolean produzieren(int anzahl) {
        if(anzahl>=zutat.length) {
            anzahlVorhanden+=anzahl;
            anzahlVerfügbarerEinheiten-=anzahl;
            return true;
        }
        return false;
    }
   
    public boolean addZutat(Zutat anzahladd) {
        for(int i = 0; i<zutat.length;i++) {
            if(zutat[i]==null) {
                zutat[i] = anzahladd;
                return true;
            }
        }
        return false;
       
    }
   
    public boolean removeZutat(Zutat[] zutat) {
        for(int i = 0;i<zutat.length;i++) {
            if(zutat[i] != null) {
                zutat[i]=null;
                return true;
            }
        }
        return false;
    }

}
```


----------



## LimDul (16. Dez 2019)

Erst mal:


> Da bei meinen Subklassen wird immer ein Fehler angezeigt.


Dann poste den Fehler auch bitte, dass macht die Sache einfacher.

Willst du wirklich Produkt & Zutat als Innere Klassen von MilchProdukt haben?. Und das Produkt eine Subklasse von Milchprodukt ist, hört sich falsch an. Genauso das Zutat eine Subklasse von MilchProdukt sein soll.

Weiterhin hat MilchProdukt keinen Parameterlosen Konstruktor - damit musst du in allen Subklassen (Hier: Produkt/Zutat) einen Konstruktor definieren, der den Super-Konstruktor aufruft.

Wie soll deine Klassenhierarchie überhaupt aussehen?


----------



## Xknight (16. Dez 2019)

Bei beiden Subklassen lautet der Fehler: Implicit super constructor Milchprodukt() is undefined for default constructor. Must define an explicit constructor.
Beim super(...) lautet der Fehler: The object (String,int,int) is undefined.


----------



## LimDul (16. Dez 2019)

Was beides auch logisch ist.

MilchProdukt erbt von Objekt - hat damit keinen Super-Konstruktor (bzw. nur den parameterlosen)
Also ist der aufruf von super mit Parametern da falsch.

Und deine Subklassen hingegen müssen mittels super den Konstruktor von Milchprodukt aufrufen, der Parameter erwartet.

Aber wie gesagt - deine Klassenhierarchie sieht falsch aus.


----------



## Xknight (16. Dez 2019)

Warum sollte meine Klassenhierarchie falsch sein wenn dass von mir verlangt wird.
Wie mache ich denn den Superkonstruktor mit einem Parameter und wie kann ich meine Subklassen mittels Superkonstruktor aufrufen?


----------



## mihe7 (16. Dez 2019)

Xknight hat gesagt.:


> Warum sollte meine Klassenhierarchie falsch sein wenn dass von mir verlangt wird


Sie *sieht* falsch aus, weil im Allgemeinen Milchprodukt das speziellere Produkt ist, in Deinem Code es sich aber genau andersrum verhält.


----------



## Xknight (16. Dez 2019)

Okay wie soll ich denn Milchprodukt gestalten dass es der speziellere code wird


----------



## mihe7 (16. Dez 2019)

Dann müsste Milchprodukt von Produkt abgeleitet werden (Milchprodukt extends Produkt).


----------



## kneitzel (16. Dez 2019)

Evtl. hilft bei der Betrachtung auch einfach folgende Aussage:

So eine Ableitung einer Klasse ist eine "ist ein" Beziehung.

Wenn B von A erbt, dann kann man sagen: B ist ein A.

Wenn Produkt von Milchprodukt erbt, dann würde das bedeuten: Ein Produkt ist ein Milchprodukt. Und dem ist doch schlicht nicht so, denn es gibt Produkte, die kein Milchprodukt sind, oder?


----------



## Xknight (16. Dez 2019)

Das Ding ist, dass von mir verlangt wird, das Produkt und Zutat eine Subklasse von der Superklasse Milchprodukt sein soll.


----------



## mihe7 (17. Dez 2019)

Xknight hat gesagt.:


> Das Ding ist, dass von mir verlangt wird, das Produkt und Zutat eine Subklasse von der Superklasse Milchprodukt sein soll.


Und da bist Du Dir 100 %-ig sicher? 

Wenn das so sein soll, dann ist es halt so. Den Konstruktor von Milchprodukt kannst Du aber in der Form vergessen. Dein UML-Diagramm sieht also etwa so aus (^ ist Generalisierung):

```
java.lang.Object
       ^
       |        «implements»
+--Milchprodukt - - - - - - > Produzierbar
|      ^
|      |
|  +---+---+
v* |       |
Zutat     Produkt
```

Richtig?


----------



## Xknight (17. Dez 2019)

Ja ist richtig


----------



## mihe7 (17. Dez 2019)

Sind die Parameter in Deinem Milchprodukt-Konstruktor vorgegeben oder kommen die von Dir?


----------



## Xknight (17. Dez 2019)

Die sind vorgegeben


----------



## Xknight (17. Dez 2019)

Ich habe mich im Internet eingelesen und es sollte eigentlich so klappen.

```
public abstract class Milchprodukt implements Produzierbar {
    protected double fettgehalt;
    Zutat [] zutat;


    public double getFettgehalt() {
        return fettgehalt;
    }

    public void setFettgehalt(double fettgehalt) {
        this.fettgehalt = fettgehalt;
    }
        Milchprodukt(String name,int anzahlVorhanden,int anzahlVerfügbarerEinheiten,Zutat[] zutat, double fettgehalt) {
        super(name,anzahlVorhanden,anzahlVerfügbarerEinheiten);
        this.zutat=zutat;
        this.fettgehalt=fettgehalt;
        
        this.zutat = new Zutat[10];
        
    }
    
    class Produkt extends Milchprodukt{
        protected String name;
        protected int anzahlVorhanden;
        
        Produkt(double fettgehalt) {
        super(fettgehalt);
        }
        
    }
    
    public class Zutat extends Milchprodukt{
        protected String name;
        protected int anzahlVerfügbarerEinheiten;
        
        Zutat(double fettgehalt){
            super(fettgehalt);
        }
        
        
    }


    public boolean produzieren(int anzahl) {
        if(anzahl>=zutat.length) {
            anzahlVorhanden+=anzahl;
            anzahlVerfügbarerEinheiten-=anzahl;
            return true;
        }
        return false;
    }
    
    public boolean addZutat(Zutat anzahladd) {
        for(int i = 0; i<zutat.length;i++) {
            if(zutat[i]==null) {
                zutat[i] = anzahladd;
                return true;
            }
        }
        return false;
        
    }
    
    public boolean removeZutat(Zutat[] zutat) {
        for(int i = 0;i<zutat.length;i++) {
            if(zutat[i] != null) {
                zutat[i]=null;
                return true;
            }
        }
        return false;
    }

}
```


----------



## mihe7 (17. Dez 2019)

Xknight hat gesagt.:


> und es sollte eigentlich so klappen.


Nein, das kann nicht klappen, weil Du mit super einen Konstruktor der Elternklasse aufrufst. Die Elternklasse von Milchprodukt ist java.lang.Object und diese Klasse besitzt keinen Konstruktor mit Parametern.


----------



## Xknight (17. Dez 2019)

Das ist ja mein Problem der ganzen Sache. Was genau bewirkt dieses java.lang.Object und wie kann ich es in meiner Klasse  verwenden und wie kann ich meinem Konstruktor mit Parametern versehen?


----------



## temi (17. Dez 2019)

Sollte die Klassen Produkt und Zutat nicht freie Klasse sein? Aktuell stehen sie innerhalb von Michprodukt.


----------



## mihe7 (17. Dez 2019)

Xknight hat gesagt.:


> Was genau bewirkt diese java.lang.Object


Das ist die "Mutter aller Klassen" in Java. Jede Klasse ist direkt oder indirekt von java.lang.Object abgeleitet.



Xknight hat gesagt.:


> und wie kann meinem Konstruktor mit Parametern versehen?


Dein Konstruktor hat ja Parameter. Du darfst nur super nicht mit Parametern aufrufen. 


```
Milchprodukt(String name,int anzahlVorhanden,int anzahlVerfügbarerEinheiten,Zutat[] zutat, double fettgehalt) {
        this.zutat=zutat;
        this.fettgehalt=fettgehalt;
        
        this.zutat = new Zutat[10];
        
    }
```

Das dürfte kompilieren, aber die Mehrzal der Parameter wird nicht genutzt.

Wie lautet denn genau die Aufgabenstellung?


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Was genau bewirkt dieses java.lang.Object



Das ist die "Mutter" aller Objekte in Java. Jede Klasse erbt automatisch von Object.


----------



## Xknight (17. Dez 2019)

Das ist genau die Aufgabenstellung.


----------



## Xknight (17. Dez 2019)

Aber trotzdem erscheint bei den Subklassen Fehlermeldungen obwohl es eigentlich klappen sollte. So habe ich mich auch im Internet eingelesen und dies wurde so im Internet beschrieben.


----------



## temi (17. Dez 2019)

In deinem pdf steht aber ganz unten, das Produkt die Superklasse ist und Milchprodukt die Subklasse.


----------



## mihe7 (17. Dez 2019)

In der Aufgabe steht klar und deutlich: Produkt ist Superklasse von Milchprodukt und Obst.


----------



## temi (17. Dez 2019)

Lesen müsste man können...


----------



## Xknight (17. Dez 2019)

Sorry aber wenn ich das machen würde, dann würde ich trotzdem die selben Fehlermeldung in der Klasse Produkt bekommen und habe auch die selben Fehlermeldungen bei meinen Subklassen.


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Sorry aber wenn ich das machen würde, dann würde ich trotzdem Fehlermeldung in der Klasse Produkt bekommen.



Willst du jetzt wieder mit uns diskutieren, dass du alles richtig gemacht hast?


----------



## mihe7 (17. Dez 2019)

Xknight hat gesagt.:


> Sorry aber wenn ich das machen würde, dann würde ich trotzdem Fehlermeldung in der Klasse Produkt bekommen.


Was heißt "wenn ich das machen würde"? Die Aufgabe verlangt, das so zu machen. Und nein, Du würdest keinen Fehler bekommen, weil Milchprodukt dann einfach den Konstruktor von Produkt verwenden kann.


----------



## mihe7 (17. Dez 2019)

temi hat gesagt.:


> Lesen müsste man können...


Es ist ja nicht so, dass 90 % der Antworten darauf rumgeritten hätten...


----------



## temi (17. Dez 2019)

Ich helfe dir mal auf die Sprünge:


```
public abstract class Produkt implements Produzierbar {
    
}

public abstract class Milchprodukt extends Produkt {
    
}
```

Das ist die Basis.


----------



## Xknight (17. Dez 2019)

temi hat gesagt.:


> Willst du jetzt wieder mit uns diskutieren, dass du alles richtig gemacht hast?


Nein will ich überhaupt nicht, aber dennoch kommen die selben Fehlermeldungen.


----------



## Xknight (17. Dez 2019)

temi hat gesagt.:


> Ich helfe dir mal auf die Sprünge:
> 
> 
> ```
> ...


So habe ich es auch


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Nein will ich überhaupt nicht, aber dennoch kommen die selben Fehlermeldungen.



Und wie sieht dein Code jetzt aus? Sollen wir raten, was du jetzt gemacht hast?


----------



## Xknight (17. Dez 2019)

```
public abstract class Milchprodukt implements Produzierbar {
    protected double fettgehalt;
    Zutat [] zutat;


    public double getFettgehalt() {
        return fettgehalt;
    }

    public void setFettgehalt(double fettgehalt) {
        this.fettgehalt = fettgehalt;
    }
        Milchprodukt(boolean fruchtYoghurt,Zutat[] zutat, double fettgehalt) {
        this.zutat=zutat;
        this.fettgehalt=fettgehalt;
        
        this.zutat = new Zutat[10];
        
    }
    
        public class Kaese extends Milchprodukt{
        protected boolean fruchtYoghurt;
        public Kaese(boolean fruchtYoghurt) {
            super(fruchtYoghurt);
        }
        
    }
    
        public class Yoghurt extends Milchprodukt{
        
        
        
    }


    public boolean produzieren(int anzahl) {
        if(anzahl>=zutat.length) {
            anzahlVorhanden+=anzahl;
            anzahlVerfügbarerEinheiten-=anzahl;
            return true;
        }
        return false;
    }
    
    public boolean addZutat(Zutat anzahladd) {
        for(int i = 0; i<zutat.length;i++) {
            if(zutat[i]==null) {
                zutat[i] = anzahladd;
                return true;
            }
        }
        return false;
        
    }
    
    public boolean removeZutat(Zutat[] zutat) {
        for(int i = 0;i<zutat.length;i++) {
            if(zutat[i] != null) {
                zutat[i]=null;
                return true;
            }
        }
        return false;
    }

}
```


----------



## temi (17. Dez 2019)

Du möchtest sicher keine inneren Klassen, oder?

Das hier *nicht*:


```
class ÄußereKlasse {
    
    class InnereKlasse {
        
    }
}
```


----------



## mihe7 (17. Dez 2019)

Xknight hat gesagt.:


> So habe ich es auch


ROFL. Wo?


----------



## temi (17. Dez 2019)

Und was macht Käse mit Fruchtjoghurt?


----------



## LimDul (17. Dez 2019)

Xknight hat gesagt.:


> ```
> public abstract class Milchprodukt implements Produzierbar {
> ```
> Immer noch falsch, Milchprodukt soll Produkt als Superklasse haben


----------



## temi (17. Dez 2019)

Vergleich doch mal mit deinem Code:

Edit: Das Interface wurde von der falschen Klasse implementiert. Danke an @mihe7 für sein UML.


```
public abstract class Produkt {

}

public abstract class Milchprodukt extends Produkt implements Produzierbar {

}

public class Kaese extends Milchprodukt {

}

public class Yoghurt extends Milchprodukt {

}
```


Dein Code, etwas reduziert:

```
public abstract class Milchprodukt implements Produzierbar {

    public class Kaese extends Milchprodukt{
     
    }
 
    public class Yoghurt extends Milchprodukt{
     
    }
}
```


----------



## mihe7 (17. Dez 2019)

Wenn ich nichts übersehen habe, sollte der Spaß so aussehen:


----------



## Xknight (17. Dez 2019)

```
public boolean produzieren(int anzahl) {
        if(anzahl>=zutat.length) {
            anzahlVorhanden+=anzahl;
            anzahlVerfügbarerEinheiten-=anzahl;
            return true;
        }
        return false;
    }
```
Wie kann ich die Variablen anzahlVorhanden und anzahlVerfügbarerEinheiten von den Klassen Produkt und Zutat aansprechen?


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Wie kann ich die Variablen anzahlVorhanden und anzahlVerfügbarerEinheiten von den Klassen Produkt und Zutat aansprechen?


Getter?


----------



## Xknight (17. Dez 2019)

temi hat gesagt.:


> Getter?


Wie rufe ich mit einem getter die Variablen?


----------



## Xknight (17. Dez 2019)

zutat = new Zutat();
            Zutat.getAnzahlVorhanden(anzahlVorhanden);

Soll das ungefähr so sein?


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Wie rufe ich mit einem getter die Variablen?


Ich fürchte, dass wird genauso ein Drama, wie beim letzten Mal.



Xknight hat gesagt.:


> zutat = new Zutat();
> Zutat.getAnzahlVorhanden(anzahlVorhanden);
> 
> Soll das ungefähr so sein?



*Z*utat ist die Klasse und *z*utat die Variable, also zutat.getAnzahlVorhanden();

Getter haben i.d.R. keine Parameter.


----------



## Xknight (17. Dez 2019)

Ja, *zutat , habe es auch gerade gemerkt .


----------



## Xknight (17. Dez 2019)

Sorry  , 

```
public boolean produzieren(int anzahl, anzahlVorhanden) {
        if(anzahl>=zutat.length) {
            zutat = new Zutat();
            zutat.getAnzahlVorhanden();
            
            return true;
        }
        return false;
    }
```
Das Attribut "anzahlVorhanden" aus der Klasse Zutat müsse dann auch als Parameter aufgerufen werden, oder?
Wenn ich es so codiere ist der "anzahlVorhanden" Paramater mit einer Fehlermeldung "Syntax error, insert "... VariableDeclaratorId" to complete FormalParameter" unterstrichen.


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Wenn ich es so codiere ist der "anzahlVorhanden" Paramater mit einer Fehlermeldung


Es fehlt die Typangabe für den Parameter anzahlVorhanden.

Allerdings hat die Methode produzieren() laut Aufgabe nur einen Parameter...


----------



## temi (17. Dez 2019)

Außerdem wird deine bisherige Methode nicht das tun, was sie tun soll:


> 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.


----------



## Xknight (17. Dez 2019)

Ja, deshalb , mit "int anzahlVorhanden" funktioniert es ja auch nicht .  Wie kann ich dann das Attribut anzahlVorhanden aus der Zutatklasse aufrufen?


----------



## Xknight (17. Dez 2019)

Ja, ich weiß das hatte ich nur kurz rauskopiert.


----------



## kneitzel (17. Dez 2019)

temi hat gesagt.:


> Ich fürchte, dass wird genauso ein Drama, wie beim letzten Mal.



Das ist mehr als überdeutlich. Und ich sehe hier auch keinen wirklichen Angriffspunkt zu unterstützen.

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!

Also ganz konkret für @Xknight:
Du hast keine Ahnung, was Getter und Setter sind? Dann schau Dich mal da um:
https://www.google.com/search?q=java+getter+setter+erklärung

Du hast Probleme, das zu verstehen? Dann sind evtl. diese Links sinnvoll:
https://www.google.com/search?q=java+einführung



temi hat gesagt.:


> Es fehlt die Typangabe für den Parameter anzahlVorhanden.
> 
> Allerdings hat die Methode produzieren() laut Aufgabe nur einen Parameter...


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.


----------



## Xknight (17. Dez 2019)

Doch mir ist schon bewusst wozu Getter und Setter dienen.


----------



## temi (17. Dez 2019)

JustNobody hat gesagt.:


> 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!



Das ist tatsächlich ein Problem. Wenn er konkrete Verständnisfragen formulieren könnte, dann wäre dafür auch Hilfe möglich, aber so wird es wirklich schwierig.


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Doch mir ist schon bewusst wozu Getter und Setter dienen.





Xknight hat gesagt.:


> Wie rufe ich mit einem getter die Variablen?


Ja, klar!


----------



## Xknight (17. Dez 2019)

Es geht doch nur darum wie ich mit getter die Variablen aus zwei unterschiedlichen Klassen aufrufen kann?


----------



## temi (17. Dez 2019)

> 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.



Versuch doch erst mal zu verstehen, was hier gefordert ist und es steht ja haarklein alles da.

1. Die Methode bekommt einen int Parameter für die zu produzierenden Einheiten
2. Für *jede* Zutat in Milchprodukt muss geprüft werden, ob die ausreichende Anzahl vorhanden ist (jede = Schleife)
3. Mach mal selbst weiter!


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Es geht doch nur darum wie ich mit getter die Variablen aus zwei unterschiedlichen Klassen aufrufen kann?


Indem du die Getter-Methode auf die gewünschte Instanz der Klasse aufrufst? Wie auch sonst?


----------



## Xknight (17. Dez 2019)

Ja, die Schleife habe ich auch ausversehen mit rauskopiert, um erstmal die 2 Attribute aus zwei anderen Klassen aufzurufen, ohne eine Fehlermeldung zu bekommen, die Schleife hatte mich da gestört. Die habe ich aber, ich hatte ja eben einen Versuch gemacht, es mit dem getter in der Methode zu tun, jedoch darf man ja nur ein Parameter übergeben, weshalb ich jetzt gerade bezüglich dessen nicht weiter weiß. Den Rest(welcher auch nicht so einen hohen Schwierigkeitsgrad hat) habe ich ja schon selbst gemacht, bis auf die Methode "produzieren" um die es ja gerade geht , scheint auch alles zu funktionieren. Es geht doch wirklich nur um diese "Kleinigkeit" die ich durch Grundlagenwissen im Internet auch nicht erlange , da das nicht unbedingt eine allgemeingültige Anwendung des Getters ist, die ich jetzt vornehmen soll, da wir ja auch keine main benutzen sollen ?


----------



## Xknight (17. Dez 2019)

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.


----------



## Xknight (17. Dez 2019)

Mit Deklarierung von anzahlVorhanden außerhalb der produzieren-Methode*


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> 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.


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.

Außerdem kannst du bitte aktuellen Code posten und nicht irgendwelche Experimente.


----------



## Xknight (17. Dez 2019)

```
public boolean produzieren(int anzahl) {
       
        for(int i = 0;i<zutat.length;i++) {
        if(anzahl>=zutat.length) {
            Produkt.getAnzahlVorhanden()+=anzahl;
            Zutat.getAnzahlVerfügbarerEinheiten()-=anzahl;
           
            return true;
        }
    }
        return false;
    }
```


----------



## temi (17. Dez 2019)

anzahl < zutat.length liefert dir die Größe des Zutaten-Arrays (= 10). Hilft dir das an dieser Stelle?

Du brauchst die vorhandene Anzahl der Zutat. Du erinnerst dich vage? Zugriff auf ein Array-Element?

Das ist die *erste Hälfte* der Methode:

```
für jede zutat in zutaten {
    wenn die zutat nicht null ist und die anzahl der zutat < anzahl, dann beende mit false;
}
```
Die Methode produzieren schlägt sofort fehl, sobald eine Zutat nicht in ausreichender Menge vorhanden ist.


----------



## kneitzel (17. Dez 2019)

Zusätzlich zu der Anmerkung von temi fallen natürlich auch zwei Zeilen noch massiv ins Auge:



Xknight hat gesagt.:


> ```
> Produkt.getAnzahlVorhanden()+=anzahl;
> Zutat.getAnzahlVerfügbarerEinheiten()-=anzahl;
> ```



Daher würde ich noch einmal ganz eindringlich empfehlen, Dass Du einmal bei 0 Anfängst und die Grundlagen von Java lernst, ehe Du irgend etwas anderes versuchst. Dabei ist egal, ob Du Vorlesungs-Mitschriften verwendest und danach lernst (und bei Problemen Google nutzt!) oder ob Du irgend eine andere Quelle nutzt. (Es gibt gute Bücher - den Thread kann ich gerne noch einmal raus suchen. Ich meine "Java von Kopf bis Fuß" und "Schrödinger programmiert Java" sind da beide gut weg gekommen.)

Diese ganzen Versuche hier sind unsinnig aus meiner Sicht und führen zu nichts. Die Probleme von der letzten Aufgabe tauchen hier wieder unverändert auf. Zugriffe auf ein Array, ein Array durchlaufen ... das wurde ganz offensichtlich nicht verstanden. Ich würde mit meinem etwas mehr an Abstand in diesem Thread sogar behaupten, dass die Grundlagen so weit fehlen, dass die Aufgabenstellung nicht einmal verstanden werden kann von Dir (Eine Grundvoraussetzung für die Lösung!) ....

@temi: Ich fürchte, dass dies so nichts bringt. Ich schlage einen Kurswechsel hier vor.

@Xnight: Vergiss alles rund um Java. Erledige erst diese Punkte. Und zwar wirklich zu 100% nur diese Punkte - nicht eine einzige Zeile Java will ich sehen!
a) Beschreibe in eigenen Worten etwas ausführlicher, was die Aufgabe verlangt.
b) Beschreibe in eigenen Worten die Grundlage: Was hast Du in welchen Objekten? Und was für Eigenschaften / Inhalte haben diese Objekte.
c) Was musst Du mit dem aus b) machen um a) zu erledigen?

Wie stelle ich mir das vor? Such Dir ein Szenario aus. Fabrik mit Lager, Küche mit Vorratsschrank, was auch immer. Da darfst Du gerne etwas Fantasie walten lassen. (aber nicht zuviel Fantasie. Die Heinzelmännchen, die Nachts kommen und alles erledigen, so dass Deine Lösung einfach ist: "Schlafen gehen, damit die Heinzelmännchen kommen können" soll es bitte nicht geben!)


----------



## Xknight (17. Dez 2019)

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

Da musste ich nur bei Produkt und Zutat was adden steht in der ersten Zeile  mit static

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

}
```


----------



## temi (17. Dez 2019)

Ok. Damit bin ich raus. Viel Spaß noch damit!

Falls du wissen willst warum: In dem gezeigten Code ist null komma nichts umgesetzt von dem, was in den letzten 66 Beiträgen diskutiert wurde. Alles ist falsch, alles ist Scheiße!


----------



## Xknight (17. Dez 2019)

Ich habe jetzt keine Fehlermeldungen. Ich habe die jetzt alle beseitigt. ^^


----------



## temi (17. Dez 2019)

Xknight hat gesagt.:


> Ich habe jetzt keine Fehlermeldungen. Ich habe die jetzt alle beseitigt. ^^


Träum schön weiter!


----------



## kneitzel (17. Dez 2019)

Xknight hat gesagt.:


> 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:


```
public class Loesung {
    public static void main(String[] args) {}
}
```

Keine Fehlermeldung! Also Kriterium erfüllt.

Da gewisse Basics fehlen, möchte ich noch vorsichtshalber erläutern, wie der Code zu verwenden ist:
a) Eine Datei Loesung.java erstellen mit genau dem gegebenen Code.
b) Übersetzen einfach innerhalb des Verzeichnisses mit dieser Datei mit javac Loesung.java
    ==> Keine Fehlermeldung
c) Testen, ob zur Laufzeit Fehler kommen: Wieder in diesem Verzeichnis ein einfaches: java Loesung
    ==> Keine Fehlermeldung

Also ich hoffe, dass niemand böse ist, dass ich jetzt eine Musterlösung erstellt habe. Aber so habe ich es evtl. etwas abkürzen können.

@Xknight: Mein Hinweis bezüglich Java Basics solltest Du befolgen. Und wenn Du da Zeit investiert hast: Dann bitte einfach #65 die Punkte a), b) und c) von mir beherzigen und damit dann als erstes die Aufgabe und den Lösungsweg verstehen.
Und bis zu dem Zeitpunkt ist die Musterlösung oben eine super Sache - vor allem habe ich die Hoffnung, dass Du den Code verstanden hast. (Den Code würde ich zur Not aber auch noch erläutern, so es daran scheitern sollte.)


----------



## jono (17. Dez 2019)

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.


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> Was ist denn daran alles scheiße?



So ziemlich alles, bis auf die automatisch erzeugten Getter und Setter.

Klingt hart, ist es auch. Schon der Hinweis in Beitrag #2 ist trotz mehrmaliger Erwähnung im weiteren Verlauf nicht verbessert worden. Sorry, da gibt es nicht viel mehr zu sagen und ihr geht weder auf Hinweise ein, noch fragt ihr, was ihr nicht verstanden habt.

Du hast ja vermutlich die gleiche Aufgabe und bist vermutlich ebenso überzeugt, dass alles ganz toll ist: Fang bei #2 an und arbeite dich durch. Falls du eine Frage dazu hast, dann stell sie.


----------



## kneitzel (17. Dez 2019)

jono hat 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.


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 hoffe, ihr wollt mir nicht erzählen, dass ihr jetzt erst angefangen habt und der böse Prof. euch gleich so eine Aufgabe gegeben hat. Ihr habt nicht eine Vorlesung oder Übung zum Thema Java gehabt .... Auch an der Uni wird Stoff erst vorgetragen, in Übungen vertieft und dann in Aufgaben muss man dann das Erlernte praktisch umsetzen.

Wenn man Hinweise gibt ... und sich immer wieder wiederholt ... und dann bekommt man Code wie in 66 gezeigt mit einem tollen "Ich habe alle Fehlermeldungen beseitigt", dann fühle ich mich schlicht etwas verarscht. Und so hart es auch klingen mag: Versucht erst einmal die Grundlagen zu beherrschen. Ihr scheint euch massiv zu überschätzen. Schon im letzten Thread aber auch hier. Angeblich habt ihr Getter und Setter verstanden und dann kommen gewisse Dinge, die das Gegenteil beweisen.

Fang ganz am Anfang an! Was für Typen kennt Java, was sind Geltungsbereiche von Variablen, und und und. Nutzt dazu ein Lehrbuch das Kapitel für Kapitel auch eine Lernkontrolle hat. Wenn ihr da auch Probleme stößt: Fragt nach. Wir helfen gerne - auch wenn ihr hier nicht unbedingt den Eindruck habt. Und Grundlagen werden auch sehr ausdauernd erläutert, bis es verstanden wurde....

Aber Threads sind kein "wir lehren euch alles von Grund auf am Beispiel einer Aufgabe".

Ja, an dem Code hätte man einfach Dinge hinterfragen können. So wäre dies denkbar:
Was macht denn der Code hier:
`public static int getAnzahlVerfügbarerEinheiten;`
in Zutat oder eben der Code:
`public static int getAnzahlVorhanden;`
aus Produkt.
Also bitte erst erläutern, was der Code genau macht und dann bitte erläutern, wozu der in der Aufgabe genau gut sein soll (außer irgendwie Fehlermeldungen zu beseitigen).

ABER: Das ist nicht zielführend. Ihr macht etwas (ich unterstelle euch, dass ihr nicht versteht, was ihr da überhaupt macht), bekommt Fehlermeldungen (die ihr nicht versteht) und versucht dann irgendwie irgendwas, nur um die Fehlermeldung los zu werden. Das bringt nichts und so kommt man generell nicht zum Ziel.

Bei jeder Aufgabe ist das Vorgehen immer gleich:
a) Aufgabe im Detail verstehen! Was ist gegeben? Was wird verlangt?
b) Lösungsweg finden -> Da ist noch nichts mit Java oder so. Überlegt euch erst einmal, wie alles zusammenhängen soll und wo was gemacht werden muss.
c) Die Lösungswege, die man sich in b) überlegt hat kann man dann umsetzen. Erst hier kommt dann Java ins Spiel.

Wenn ihr a) und b) habt, dann kann man immer noch überlegen, ob und wie man euch leitet. Da kann man das, was ihr konkret braucht, zur Not ja in "Java ist auch eine Insel" aufzeigen, so dass ihr da dann das notwendige Wissen anlest.


----------



## jono (17. Dez 2019)

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

}
```
Ja, @JustNobody, du hast schon Recht.
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.


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> 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.



Das ist nun also die Antwort auf die oben gestellt Frage:

```
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();
    }
}
```


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> 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.



Nicht korrekt. Schau dir auf der zweiten Seite des Themas das Klassendiagramm von @mihe7 an. Ihr habt lauter freie Klassen. Warum gibt es in deinem Code innere Klassen? Lies dazu auch die Beiträge auf Seite 1 und 2.

Fang mal damit an und korrigier das.


----------



## kneitzel (17. Dez 2019)

jono hat gesagt.:


> ```
> public class Milchprodukt implements Produzierbar {
> private double fettgehalt;
> Zutat[] zutaten = null;
> ...


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).

Dann fällt auf:
Ihr vergleicht Zutaten mit ==. Das ist etwas, das in euren Tests evtl. funktioniert, aber das liegt einfach nur daran, dass ihr Zutaten einmal erzeugt und das war es. Referenztypen werden mit equals verglichen. Oder  - so ihr equals in Zutat nicht überschrieben habt - ggf. über die getName() Eigenschaft.

Über die Vererbungshirarchie wurde viel gesprochen. Milchprodukt ist doch ein Produkt....
Wenn das korrekt wäre, dann würde man wohl auch nicht auf solche Ideen kommen:
`Produkt.getAnzahlVorhanden += anzahl;`
a) getAnzahlVorhanden in Produkt? Soll Produkt ein solches, statisches Element haben? Dann ist es ein Attribut - wieso fängt das mit einem Verb an? Mit Verben fangen nur Methoden an!
b) Getter / Setter nutzen. Wenn ich ein Attribut per Getter auslesen und per Setter setzen kann: Wie kann ich denn dann einen Wert auslesen, etwas dazu addieren und dann wieder setzen? Tipp: mit += geht das nicht!

Das reicht hoffentlich für den Anfang ...


----------



## jono (17. Dez 2019)

@temi ,Was genau meinst du mit freien Klassen?


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> @temi ,Was genau meinst du mit freien Klassen?



Damit sind ganz normale Klassen gemeint. Das "Gegenstück" dazu sind sogenannte innere Klassen oder nested classes oder verschachtelte Klassen. Ihr habt eine Anzahl von ganz normalen Klassen, die wie @JustNobody geschrieben hat, jede in ihre eigene Datei kommen. Siehe auch #35 und #39, sowie #40

Bis auf die Klasse Milchprodukte handelt es sich dabei um ganz simple Klassen mit einem oder mehreren Attributen, einem Konstruktor und Getter/Setter Methoden. Mehr oder weniger kann euch eine gute IDE fast die komplette Klasse automatisch erstellen.

Nur bei Milchprodukte sind drei Methoden zu implementieren, die etwas mehr Nachdenken erfordern.


----------



## jono (17. Dez 2019)

Wie meide ich die inneren Klassen?

```
z.B.:
public class Kaese extends Milchprodukt {

}

statt:
public class Milchprodukt extends Produkt implements Produzierbar {

public class Kaese extends Milchprodukt {
}
}
```


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> Wie meide ich die inneren Klassen?
> 
> ```
> z.B.:
> ...


Ja. In dem "statt:"-Teil ist Kaese eine innere Klasse von Milchprodukt.


JustNobody hat gesagt.:


> 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


----------



## jono (17. Dez 2019)

Ich habe doch für jede Klasse eine eigene Datei angelegt mit dem Namen Kaese.java, Produkt.java,Produzierbar.java,... .


----------



## temi (17. Dez 2019)

Implementier jetzt alle Klassen soweit. Die Hauptarbeit liegt in den drei Methoden von Milchprodukt.


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> Ich habe doch für jede Klasse eine eigene Datei angelegt mit dem Namen Kaese.java, Produkt.java,Produzierbar.java,... .


Gut, aber warum ist dann die Klasse Kaese in deiner Klasse Milchprodukt?


----------



## jono (17. Dez 2019)

```
public class Kaese extends Milchprodukt {

}
```
 Das wäre dann also die Klasse Kaese in Klasse Milchprodukt?


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> ```
> public class Kaese extends Milchprodukt {
> 
> }
> ...


Wenn dass innerhalb der Klasse Milchprodukt steht, ja. Die Klasse Kaese in der Datei Kaese.java sieht ja genauso aus.

Warum steht das da drin? Was hast du damit bezweckt?


----------



## jono (17. Dez 2019)

Das steht nicht in der Klasse Milchprodukt sondern das ist die Klasse Kaese.
Damit bezweckt man, dass die Klasse Milchprodukt von Kaese überschrieben wird?


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> Das steht nicht in der Klasse Milchprodukt sondern das ist die Klasse Kaese.
> Damit bezweckt man, dass die Klasse Milchprodukt von Kaese überschrieben wird?


In dem Code aus #74 steht genau das *in* der Klasse Milchprodukt. Warum?


----------



## jono (17. Dez 2019)

Weiß nicht, das ist falsch ?


----------



## jono (17. Dez 2019)

Also es wurde ja jetzt gesagt, dass es falsch ist das so wie in #74 zu tun.


----------



## temi (17. Dez 2019)

jono hat gesagt.:


> Weiß nicht, das ist falsch ?


Hmpf. Wir reden jetzt seit #75 darüber, dass das falsch ist.


jono hat gesagt.:


> Also es wurde ja jetzt gesagt, dass es falsch ist das so wie in #74 zu tun.


Nein, nicht erst jetzt. Fast seit 15 Beiträgen. Da kann man echt die Lust verlieren.


----------



## jono (17. Dez 2019)

Habe die ganze Zeit versucht, darauf zu kommen, was jetzt genau mit innerer Klasse gemeint war, das Problem war aber, dass ich nicht präzise genug auf mich gehört habe, konkrete Überlegungen anzustellen und bei Verständnisproblemen einfach mal nachzufragen. Oder einfach , ich habe mich dumm gestellt ? Vielleicht kann man es so nennen...


----------



## temi (17. Dez 2019)

Was ist daran so schwer zu verstehen?

```
class ÄußereKlasse {
    
    class InnereKlasse {
        
    }
    
}
```



jono hat gesagt.:


> Oder einfach , ich habe mich dumm gestellt ?


Damit solltest du dann dringend und sofort aufhören, sonst wird die weitere Hilfsbereitschaft hier gegen Null gehen.


----------



## Rahza (17. Dez 2019)

Ganz ehrlich Leute: Beherzigt einfach, was temi und JustNobody euch empfohlen haben, dass ihr die Grundlagen aufarbeiten solltet. Ich bin im selben Modul wie ihr und ich weiß, dass man einfach nur die Lösung will um die Punkte zu kriegen, aber damit werden ihr auf die Nase fallen. Arbeitet einfach die Folien vom Tutorium nochmals durch und schaut euch ganz einfache Tutorials nochmals an. Für den Einstieg fand ich panjutorials auf Youtube nicht schlecht, auch wenn er nur die absoluten Grundlagen erklärt. 

Ich habe selbst die Erfahrung gemacht, dass es bei der Klausur überhaupt nichts bringt, wenn ihr zwar die Punkte während den Übungen zusammengekratzt habt, aber es dann doch an Grundlagen hakt.


----------



## Rahza (17. Dez 2019)

Was die innere Klasse betrifft: Schaut euch mal an, wie der Prof. die Abgabe verlangt. Es werden explizit 7 verschiedene Klassen verlangt. Da sollte es schon klar sein, dass ihr 7 verschiedene Dateien erzeugen sollt. 
Also am besten genauso wie in der Aufgabenstellung beschrieben entsprechend verschiedene Klassen und Interface anlegen, dann für jede Klasse die Attribute gemäß Beschreibung rein, automatisch Getter und Setter generieren. Anschließend vielleicht die Verebungs- und Schnittstellenbeziehungen setzen, sowie Aggregationsbeziehung. Dann habt ihr den Wirrwarr schonmal entschlüsselt, obwohl ein User hier sogar das UML dazu gepostet hat. Und danach könnt ihr euch an die Methoden ranmachen.


----------



## jono (17. Dez 2019)

Ja bis jetzt schaut es ganz gut aus, ich probiere es jetzt mal alleine und melde mich gleich nochmal, falls etwas wirklich nicht klappen sollte.


----------



## jono (17. Dez 2019)

```
public class abstract Milchprodukt extends Produkt implements Produzierbar {
```

Warum wird bei mir "abstract" rot unterstrichen?
Angezeigt wird: Syntax error on token "abstract", delete this token.


----------



## jono (17. Dez 2019)

Klasse Milchprodukt als Code schicken?


----------



## kneitzel (17. Dez 2019)

Java Syntax für eine Klasse;
VOR das Schlüsselwort class kommen Kennzeichnungen für die Klasse wie public, abstract, ....
Also public abstract class Milchprodukt ......


----------



## jono (17. Dez 2019)

```
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();
    }
}
```


----------



## jono (17. Dez 2019)

Ich habe jetzt zu #75, welches ich gerade kopiert habe, 

```
private Produkt produkt = new Produkt(); Meldung: Cannot instantiate the type Produkt
    private Zutat zutat1 = new Zutat(); Meldung: The constructor Zutat() is undefined
```
das Problem.

```
public void doSomething() {
        int value = foo.getValue();
    }
}
```
Das ist schon fertig.


----------



## jono (17. Dez 2019)

```
/root/autocorrectormRPQPudir/PublicTests.java:9: error: constructor Kaese in class Kaese cannot be applied to given types;
        Milchprodukt k = new Kaese();
                         ^
  required: String,int,double,Zutat[]
  found: no arguments
  reason: actual and formal argument lists differ in length
/root/autocorrectormRPQPudir/PublicTests.java:13: error: constructor Zutat in class Zutat cannot be applied to given types;
        Zutat z1 = new Zutat();
                   ^
  required: String,int
  found: no arguments
  reason: actual and formal argument lists differ in length
/root/autocorrectormRPQPudir/PublicTests.java:26: error: constructor Zutat in class Zutat cannot be applied to given types;
        Zutat z2 = new Zutat();
                   ^
  required: String,int
  found: no arguments
  reason: actual and formal argument lists differ in length
/root/autocorrectormRPQPudir/PublicTests.java:30: error: constructor Zutat in class Zutat cannot be applied to given types;
        Zutat z3 = new Zutat();
                   ^
  required: String,int
  found: no arguments
  reason: actual and formal argument lists differ in length
/root/autocorrectormRPQPudir/PublicTests.java:35: error: cannot find symbol
        assertFalse(contains(k.getZutaten(),z1));
                              ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/PublicTests.java:36: error: cannot find symbol
        assertFalse(contains(k.getZutaten(),z2));
                              ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/PublicTests.java:37: error: cannot find symbol
        assertFalse(contains(k.getZutaten(),z3));
                              ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/PublicTests.java:41: error: cannot find symbol
        assertTrue(contains(k.getZutaten(),z1));
                             ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/PublicTests.java:42: error: cannot find symbol
        assertTrue(contains(k.getZutaten(),z2));
                             ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/PublicTests.java:43: error: cannot find symbol
        assertTrue(contains(k.getZutaten(),z3));
                             ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/PublicTests.java:45: error: cannot find symbol
        assertFalse(contains(k.getZutaten(),z3));
                              ^
  symbol:   method getZutaten()
  location: variable k of type Milchprodukt
/root/autocorrectormRPQPudir/Milchprodukt.java:6: error: Produkt is abstract; cannot be instantiated
    private Produkt produkt = new Produkt();
                              ^
/root/autocorrectormRPQPudir/Milchprodukt.java:7: error: constructor Zutat in class Zutat cannot be applied to given types;
    private Zutat zutat1 = new Zutat();
                           ^
  required: String,int
  found: no arguments
  reason: actual and formal argument lists differ in length
```

Woran liegt es, habe es wirklich gewissenhaft bearbeitet, bitte um einen netten Hinweis .


----------



## kneitzel (17. Dez 2019)

Du versuchst Instanzen der Klassen zu erzeugen, aber Du hast nur Konstruktoren mit Parametern. Und das sagt er dir dann. Die Meldung sieht dann z.B. so aus:

```
/root/autocorrectormRPQPudir/PublicTests.java:9: error: constructor Kaese in class Kaese cannot be applied to given types;
        Milchprodukt k = new Kaese();
                         ^
  required: String,int,double,Zutat[]
  found: no arguments
  reason: actual and formal argument lists differ in length
```
Übersetzt: Fehler: Der Konstruktor Kaese in der Klasse Kaaese kann nicht mit den angegebenen Typen verwendet werden.
Dann zeigt er die Codestelle mit dem new Kaese();
Dann sagt er Dir: Er erwartet 4 Parameter: Ein String, ein int, ein double und dann ein Array von Zutat
Du hast: Keine Argumente angegeben.
Ursache: Aktuelle und formale Argumentenliste unterscheiden sich in der Länge.

Oder in anderen Worten: Schau Dir immer die Konstruktoren an. (Hinweis: Wenn es keinen Konstruktor im Code gibt, dann erstellt Java einen Standard Konstruktor ohne Parameter). Die Paramter, die da gefordert werden, musst du dann auch immer mit angeben.


----------



## jono (17. Dez 2019)

Es sind überall Konstruktoren vorhanden außer in der Klasse Produzierbar.


----------



## jono (17. Dez 2019)

```
private Produkt produkt = new Produkt();
    private Zutat zutat1 = new Zutat();
```
Was soll ich das jetzt machen ??


----------



## Rahza (17. Dez 2019)

Ich glaube in der Aufgabenstellung steht garnichts speziell über Konstruktoren. Dann nimm einfach nur Default Konstruktoren (ohne Parameter).


----------



## jono (17. Dez 2019)

```
public abstract class Milchprodukt extends Produkt implements Produzierbar {
   
    private double fettgehalt;
    private Zutat[] zutaten = null;
    private Produkt produkt = new Produkt();
    private Zutat zutat1 = new Zutat();

   

    public Zutat getZutat1() {
        return zutat1;
    }

    public void setZutat1(Zutat zutat1) {
        this.zutat1 = zutat1;
    }

    public double getFettgehalt() {
        return fettgehalt;
    }

    public void setFettgehalt(double fettgehalt) {
        this.fettgehalt = fettgehalt;
    }

    Milchprodukt(String name, int anzahlVorhanden, double fettgehalt, Zutat[] zutaten, Produkt produkt, Zutat zutat1) {
        super(name, anzahlVorhanden);
        this.zutaten = zutaten;
        this.fettgehalt = fettgehalt;
        this.produkt = produkt;
        this.zutat1 = zutat1;
        this.zutaten = new Zutat[10];

    }
   
    public boolean produzieren(int anzahl) {
       
        if (anzahl <= zutaten.length) {
            int anzahlVorhanden = produkt.getAnzahlVorhanden();
            int anzahlVerfuegbarerEinheiten = zutat1.getAnzahlVerfuegbarerEinheiten();
            anzahlVorhanden +=anzahl;
            anzahlVerfuegbarerEinheiten -=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;
    }

}
```


----------



## jono (17. Dez 2019)

Also ohne Parameter und ohne die dazugehörigen this...?


----------



## jono (17. Dez 2019)

Was will der blöde Test von mir ... Ich habe alle Konstruktoren, mit dem was required ist , versehen , bevor diese Fehlermeldung auftrat. Obwohl diese Parameter enthalten sind tritt die Meldung auf


----------



## jono (17. Dez 2019)

Mit dem interface wird das eigentlich nichts zu tun haben können?


----------



## jono (17. Dez 2019)

Mir geht es um das und auch um #101.


----------



## jono (18. Dez 2019)

Bitte um Hilfe. Das ist wirklich etwas, was sich als Anfänger auch mit Grundlagenwissen evtl. bearbeiten lässt, aber ich finde es nicht unbedingt sehr einleuchtend, vor allem weil die Fehlermeldung auftritt trotz korrekt übergebener Parameter.


----------



## kneitzel (18. Dez 2019)

Rahza hat gesagt.:


> Ich glaube in der Aufgabenstellung steht garnichts speziell über Konstruktoren. Dann nimm einfach nur Default Konstruktoren (ohne Parameter).


Also nur um das noch einmal zu erläutern:

Default Konstruktoren erzeugt Java, wenn es keinen Konstruktor im Source Code gibt. Sobald man einen Konstruktor geschrieben hat in einer Klasse, dann gibt es in der Klasse keinen Default Konstruktor mehr.

Aber man kann jeder Klasse natürlich noch einen Default Konstruktor manuell hinzufügen. Wenn Du also die Klasse Kaese hast, dann kannst Du noch einen Konstruktor in der Klasse einfügen, der wie folgt aussieht:

```
public Kaese() {}
```

Beachte: Ein Konstruktor hat einen Rückgabewert! Da darf also kein "void" oder so stehen. Sobald Du `public void Kaese()` schreibst, ist es kein Konstruktor mehr sondern eine einfache Methode!

Somit bedeutet der Ratschlag von Rahza, dass Du bei allen Klassen noch sicherstellst, dass so ein Konstruktor vorhanden ist bzw. dass Du andere Konstruktoren einfach löschst (Evtl. ist letzteres aber ungünstig, da die evtl. irgendwo verwendet werden! Daher würde ich weitere Konstruktoren hinzufügen!)


----------



## jono (18. Dez 2019)

Okay, ich probiere es jetzt aus.


----------



## jono (18. Dez 2019)

Implicit super constructor Produkt() is undefined. Must explicitly invoke another constructor
-> tritt auf wenn ich in Milchproduktklasse Milchprodukt() {] als Defaultkonstruktor einfüge.


----------



## Rahza (18. Dez 2019)

Im Grunde hast du doch bei Milchprodukt nur das Attribut fettgehalt und dann noch wegen der Aggregation das Array zutaten. Das new produkt und new zutat braucht man doch garnicht oder? Vor allem solltest du in der Aufgabestellung schauen, wie die genaue Bezeichnung der Aggregationsbeziehung ist. Darauf legt der Prof ja immer Wert dass alles genauso übernommen wird wie in der Aufgabenstellung. Was die Komstruktoren angeht: Dort wo man Komstruktoren brauchte wurde in den vergangenen Wochen ja konkret angegeben mit welchern Parametern wir die erstellen sollen. Da das diesmal nicht der Fall ist gehe ich mal von aus, dass der Default Konstruktor reicht


----------



## jono (18. Dez 2019)

Sprich die ganzen Parameter entfernen?


----------



## jono (18. Dez 2019)

Ja auf die Bezeichungen habe ich genau geachtet.


----------



## jono (18. Dez 2019)

```
public abstract class Milchprodukt extends Produkt implements Produzierbar {
    
    private double fettgehalt;
    private Zutat[] zutaten = null;
    private Produkt produkt = new Produkt();
    private Zutat zutat1 = new Zutat();

    public Zutat getZutat1() {
        return zutat1;
    }

    public void setZutat1(Zutat zutat1) {
        this.zutat1 = zutat1;
    }

    public double getFettgehalt() {
        return fettgehalt;
    }

    public void setFettgehalt(double fettgehalt) {
        this.fettgehalt = fettgehalt;
    }

    public Milchprodukt() {
    
        this.zutaten = new Zutat[10];

    }
    
    public boolean produzieren(int anzahl) {
        
        if (anzahl <= zutaten.length) {
            int anzahlVorhanden = produkt.getAnzahlVorhanden();
            int anzahlVerfuegbarerEinheiten = zutat1.getAnzahlVerfuegbarerEinheiten();
            anzahlVorhanden +=anzahl;
            anzahlVerfuegbarerEinheiten -=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;
    }

}
```

?


----------



## jono (18. Dez 2019)

```
public Milchprodukt(String name, int anzahlVorhanden) {
        super(name, anzahlVorhanden);
        this.zutaten = new Zutat[10];

    }
```
das brauche ich doch, da Produkt mit den dortigen Parametern die Elternklasse darstellt?


----------



## albanhu (18. Dez 2019)

jono hat gesagt.:


> ```
> public Milchprodukt(String name, int anzahlVorhanden) {
> super(name, anzahlVorhanden);
> this.zutaten = new Zutat[10];
> ...


----------



## albanhu (18. Dez 2019)

public Milchprodukt(String name, int anzahlVorhanden, double fettgehalt,Zutat[] zutaten) {
  super(name, anzahlVorhanden);
  this.fettgehalt = fettgehalt;
  this.zutaten = new Zutat [10];
}

so sieht meins aus habe noch die werte die wir in Milchprodukt brauchen reingepackt …. #selbstNichtsicher ...


----------



## kneitzel (18. Dez 2019)

Du übergibst ein Array mit Zutaten ... das solltest du dann für Zutaten verwenden und kein neues Array erzeugen ...
Sorry, bin jetzt weg vom Computer und schreibe auf dem Handy, daher nicht mehr ausführlich .... morgen erläutere ich noch einmal was bezüglich dem letzten Problem ... Nur kurz so viel: wenn du komplett so default Konstruktoren haben willst, dann darfst du den nicht in der Super Klasse vergessen!


----------



## jono (18. Dez 2019)

Okay, bis heute ^^ . Stelle mir mal einen Wecker für 7 Uhr


----------



## temi (18. Dez 2019)

Leute, arbeitet mal an eurem Textverständnis und lest die Aufgabe noch mal durch!

Ihr braucht *keine* leeren Standardkonstruktoren! Nirgends!

Produkt hat als Attribute: name und anzahlVorhanden.

Milchprodukt erbt von Produkt und hat als Attribut: fettgehalt. Hier ist als Besonderheit noch die Aggregation von zehn Zutaten. Die werden allerdings *nicht* über den Konstruktor zugewiesen, sondern über die darunter beschriebene Methode addZutat(). In der Aufgabe steht hierzu nur *"zu Beginn sollen alle Elemente null sein"*. Außerdem implementiert es die Schnittstelle Produzierbar.

Kaese erbt von Milchprodukt und hat keine weiteren Attribute.

Yoghurt erbt von Milchprodukt und hat als Attribut: fruchtYoghurt

Zutat hat als Attribute: name und anzahlVerfuegbareEinheiten, sowie eine zusätzliche Methode nachkaufen().

Es wird nicht explizit erwähnt, aber man kann davon ausgehen, dass *nur* die *angegebenen* *Attribute* über den Konstruktor gesetzt werden.

Wie geht das also:

1. Klassenrumpf hinschreiben
2. extends oder implements entsprechend ergänzen
3. Attribute mit den entsprechenden Typen hinschreiben.
4. Konstruktor von der IDE erzeugen lassen. IntelliJ kann das komplett mit dem Aufruf von super() und allen geerbten Attributen. Notfalls halt händisch.
5. Getter/Setter von der IDE erzeugen lassen.

Jetzt sind ca. 20 Minuten vorbei und es stehen *alle Klassen bis auf zwei komplett* da.

6. Die fehlenden Methoden von Milchprodukt und Zutat implementieren. Fertig!


----------



## temi (18. Dez 2019)

albanhu hat gesagt.:


> public Milchprodukt(String name, int anzahlVorhanden, double fettgehalt,Zutat[] zutaten) {
> super(name, anzahlVorhanden);
> this.fettgehalt = fettgehalt;
> this.zutaten = new Zutat [10];
> ...



Bis auf die zutaten im Konstruktor in den Parametern richtig. Und, schau mal genau hin, du verwendest den Parameter auch nicht im Code.


----------



## mihe7 (18. Dez 2019)

jono hat 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 ?



@jono, @Xknight Hier geht es nicht um Profis oder darum, dass Ihr Euch erst seit "kurzem" damit beschäftigt. Keiner erwartet, dass Ihr schlagartig Java könnt, aber absolute Grundlagen werden vorausgesetzt - vor allem nach Wochen.

Die Reaktionen hier brauchen Euch nicht wirklich zu wundern. Man gewinnt den Eindruck, dass Ihr nicht einmal gewillt seid, wenigstens die Aufgabenstellung richtig zu lesen. Man kann in Hunderten Beiträgen was erklären, das scheint auf der einen Seite rein und auf der anderen raus zu gehen. Hauptsache, Ihr habt am Ende was, das Ihr abgeben könnt. Die Woche drauf fängt das Drama von vorne an.

Ich kann Euch nur _dringend_ raten, an Eurer Einstellung zu arbeiten. Schule ist vorbei. Es gibt keinen Lehrer mehr, der Euch alles hinterher trägt, Euch Aufgaben gibt, damit Ihr beschäftigt seid oder Euch abfragt, weil er seine Noten machen und sich gegenüber Schulleitung und Eltern verantworten muss, wenn das arme Kind schlechte Noten hat.

Die Aufgaben sind in erster Linie dazu gedacht, dass Ihr das Erlernte vertiefen und überprüfen könnt (das setzt voraus, dass man etwas erlernt hat), ein Gefühl dafür bekommt, wo es hakt - und es hakt bei Euch an allen Ecken und Enden. 

Wenn Euch das Verständnis in den Vorlesungen oder Skripten nicht vermittelt werden konnte, dann nehmt Euren Bibliotheksausweis, besorgt Euch entsprechende Bücher und arbeitet(!) damit, d. h. lesen, und praktisch(!) anwenden. Programmieren lernt man nur (und nur) by doing.

Dem entsprechend würde man erwarten, dass ihr vielleicht auch mal unabhängig von den Aufgaben Fragen habt, entweder zu Code, den Ihr selbst probiert oder allgemein zum Verständnis. Diesbezüglich kann ich mich an nichts erinnern. 

Nicht falsch verstehen: das ist nicht böse gemeint. Es ist einfach ein Tritt in den Allerwertesten, damit Ihr endlich aufwacht und "in die Pötte" kommt.


----------



## Rahza (18. Dez 2019)

Ich habe das mit dem Standardkonstruktor geschrieben, da in den vergangenen Aufgaben bei den Konstruktoren konkret angegeben war, welche Paramater übergeben werden sollen. Auf Nachfrage wurde nur eine schwammige Antwort vom Übungsleiter gegeben, dass man einfach mal die Default Konstruktoren reinpacken sollte.


----------



## temi (18. Dez 2019)

Rahza hat gesagt.:


> Ich habe das mit dem Standardkonstruktor geschrieben, da in den vergangenen Aufgaben bei den Konstruktoren konkret angegeben war, welche Paramater übergeben werden sollen. Auf Nachfrage wurde nur eine schwammige Antwort vom Übungsleiter gegeben, dass man einfach mal die Default Konstruktoren reinpacken sollte.


In der Regel ist das allerdings keine gute Idee, denn der leere Standardkonstruktor erzeugt sozusagen ein "hohles" Objekt und ein Objekt sollte nach der Erzeugung seine Funktion voll erfüllen können. Dazu gehört auch, dass es konsistent initialisiert ist.

Es gibt natürlich Fälle, wo viele Parameter vorliegen, die evtl. auch nicht alle benötigt werden. Da bieten sich dann Lösungen, wie z.B. das Builder Pattern an. Das führt hier allerdings zu weit.


----------



## mihe7 (18. Dez 2019)

Allerdings würde ich bei solch Aufgaben empfehlen, sich peinlichst genau an die Vorgabe zu halten - ich habe z. B. im Klassendiagramm (Kommentar #40) auch extra den Tippfehler beim Obst übernommen


----------



## temi (18. Dez 2019)

mihe7 hat gesagt.:


> Allerdings würde ich bei solch Aufgaben empfehlen, sich peinlichst genau an die Vorgabe zu halten - ich habe z. B. im Klassendiagramm (Kommentar #40) auch extra den Tippfehler beim Obst übernommen


Meinst du das jetzt Pro oder Contra Standardkonstruktor?

Im Text der Aufgabe wird er nicht erwähnt. Für die geforderte Klassenstruktur wird er nicht benötigt. Ich würde ihn erst mal weglassen und erst wenn die (uns nicht bekannten) Tests fehlschlagen notfalls noch ergänzen.


----------



## mihe7 (18. Dez 2019)

temi hat gesagt.:


> Meinst du das jetzt Pro oder Contra Standardkonstruktor?


Ich meine das so:


temi hat gesagt.:


> Im Text der Aufgabe wird er nicht erwähnt. Für die geforderte Klassenstruktur wird er nicht benötigt. Ich würde ihn erst mal weglassen und erst wenn die (uns nicht bekannten) Tests fehlschlagen notfalls noch ergänzen.


----------



## Rahza (18. Dez 2019)

temi hat gesagt.:


> In der Regel ist das allerdings keine gute Idee, denn der leere Standardkonstruktor erzeugt sozusagen ein "hohles" Objekt und ein Objekt sollte nach der Erzeugung seine Funktion voll erfüllen können. Dazu gehört auch, dass es konsistent initialisiert ist.
> 
> Es gibt natürlich Fälle, wo viele Parameter vorliegen, die evtl. auch nicht alle benötigt werden. Da bieten sich dann Lösungen, wie z.B. das Builder Pattern an. Das führt hier allerdings zu weit.


Ja mir ging es auch eher darum was genau die Profs gesagt haben. Aus Programmierersicht hast du natürlich Recht bzw. kannst das besser einschätzen als ich. Hier wurde ja auch in irgendeinem Thread auch schon die vorletzte Aufgabe diskutiert wo auch explizit Komstruktoren genannt wurden. Bei dem Übungsleiter weiß man aver nie so wirklich. Kann auch sein, dass meine Abgabe jetzt falsch war, da ich nur die Default Konstruktoren genommen hab


----------



## temi (18. Dez 2019)

Rahza hat gesagt.:


> Kann auch sein, dass meine Abgabe jetzt falsch war, da ich nur die Default Konstruktoren genommen hab


Nein, vermutlich liegst du richtig. Ich hab mir mal die Ausschnitte aus den fehlgeschlagenen Tests einige Seiten weiter vorne angeschaut und offenbar werden alle Objekte mit Standardkonstruktor + Setteraufrufe erzeugt. Eigentlich nicht sehr gut gelöst und vermutlich den Tests geschuldet (hoffe ich mal).

Insofern gilt dieses, weil es technisch die saubere Lösung ist:


temi hat gesagt.:


> Im Text der Aufgabe wird er nicht erwähnt. Für die geforderte Klassenstruktur wird er nicht benötigt. Ich würde ihn erst mal weglassen


aber in Verbindung mit diesem:


temi hat gesagt.:


> und erst wenn die (uns nicht bekannten) Tests fehlschlagen notfalls noch ergänzen



Weil wir gerade bei technisch sauberen Lösungen sind, noch eine Ergänzung für dich @Rahza, weil du offenbar Interesse an der Sache hast: Auch die automatisch erzeugten Getter/Setter für alle Attribute sind nicht ganz zum objektorientierten Gedanken konform. Eine Klasse sollte soviele Implementationsdetails verbergen wir möglich und nur nach außen geben was unbedingt notwendig ist.


----------



## mihe7 (18. Dez 2019)

@Rahza kann es sein, dass Ihr noch keine super-Aufrufe hattet?


----------



## Rahza (18. Dez 2019)

mihe7 hat gesagt.:


> @Rahza kann es sein, dass Ihr noch keine super-Aufrufe hattet?


Grundsätzlich wurde das schon in der Vorlesung erklärt, weil es ja eben zum Vererbungs-Thema gehört. Ich meine auch die super-Aufrufe schon in den Präsenzaufgaben gesehen zu haben, aber das wurde wirklich nur angerissen. Übrigens unsere neue Aufgabe ist schon raus. Ich versuche das mal am Wochenende zu lösen. Sieht nicht wirklich schwierig aus. Notfalls weiß ich ja wo ich Hilfe bekomme?

Ich habe das Forum auch im Grunde erst letzte Woche gefunden bzw. mich angemeldet. Hätte ich das noch eine Woche vorher gefunden, hätte ich die Compiler-Fehler beheben können, denn für die gibt es 0 Punkte. Am Ende hat es sehr wahrscheinlich daran gelegen, dass ich auf Teufel komm raus eine public-static Methode machen wollte, aber die Methode nur public sein sollte.


----------



## Rahza (18. Dez 2019)

temi hat gesagt.:


> Nein, vermutlich liegst du richtig. Ich hab mir mal die Ausschnitte aus den fehlgeschlagenen Tests einige Seiten weiter vorne angeschaut und offenbar werden alle Objekte mit Standardkonstruktor + Setteraufrufe erzeugt. Eigentlich nicht sehr gut gelöst und vermutlich den Tests geschuldet (hoffe ich mal).
> 
> Insofern gilt dieses, weil es technisch die saubere Lösung ist:
> 
> ...


Was genau meinst du mit Implementationsdetails? Also dass man durch die Getter und Setter Zugriff auf gewisse Attribute bekommt und man versuchen sollte nicht überall Zugriff zu gewähren?


----------



## mihe7 (18. Dez 2019)

Rahza hat gesagt.:


> Was genau meinst du mit Implementationsdetails? Also dass man durch die Getter und Setter Zugriff auf gewisse Attribute bekommt und man versuchen sollte nicht überall Zugriff zu gewähren?


Ja, so in etwa. Man versucht, die konkrete Implementierung zu verstecken.


----------

