Typisierte ArrayList und der Zugriff auf den Typ

[wciibb]

Hallo,

ich habe einmal eine kleine Verständnisfrage, irgendwie sehe ich das Problem nicht.

Ich habe eine Klasse Lebensmittel:

public class Lebensmittel {

    public void setName(String name) {
        this.name = name;
    }

    public void setTyp(String typ) {
        this.typ = typ;
    }

    public void setMenge(double menge) {
        this.menge = menge;
    }

    public void setBeschreibung(String beschreibung) {
        this.beschreibung = beschreibung;
    }

    public void setVpe(VPE vpe) {
        this.vpe = vpe;
    }

    public String getName() {
        return name;
    }

    public String getTyp() {
        return typ;
    }

    public double getMenge() {
        return menge;
    }

    public String getBeschreibung() {
        return beschreibung;
    }

    public VPE getVpe() {
        return vpe;
    }
    
    private String name;
    private String typ;
    private double menge;
    private String beschreibung;
    private VPE vpe;
    
    public Lebensmittel(String name, String typ, double menge, String beschreibung, VPE vpe) {
        this.name = name;
        this.typ = typ;
        this.menge = menge;
        this.beschreibung = beschreibung;
        this.vpe = vpe;
    }
    
    public enum VPE {
        L, ml, cl, kG, g, pfd, stk, bund
    }
        
    @Override public String toString() {
        return name;
    }
    
}

Nun habe ich noch zwei Klassen Menue und Warenkorb die beide ArrayList erweitern:

Menue:

import java.util.ArrayList;

public class Menue<Lebensmittel> extends ArrayList {
    private String name;
    
    public Menue() {
        
    }
    
    public Menue(String name) {
        this.name = name;
    }
    
    public void addZutat(Lebensmittel l) {
        add(l);
    }
    
    public int anzahlZutaten() {
        return size();
    }
    
    public Object[] Einkaufsliste() {
        return toArray();
    }
    
    public ArrayList<Lebensmittel> Ekaufliste() {
        return (ArrayList<Lebensmittel>) this.clone();
    }
    
}

und Warenkorb (ich weiß ist noch nicht fertig - genau hier liegt das Problem 🙂:

import java.util.ArrayList;

public class Warenkorb<Lebensmittel> extends ArrayList {
    
    // gibt den Inhalt des Warenkorbs zurück
    public ArrayList<Lebensmittel> Inhalt() {
        return (ArrayList<Lebensmittel>) this.clone();
    }
    
    // gibt eine Liste der Lebensmitteltypen zurück
    // ein Lebensmittel hat das Attribut String Typ zB. mit dem Wert "Milch"
    public ArrayList<String> getTypes() {
        ArrayList<String> distinctTypes = new ArrayList<>();
        for (Lebensmittel l : this.Inhalt()) {
            // Problem hier beim Zugriff auf Lebensmittel.Methoden
            l.
            
        }
        return distinctTypes;
    }
}

Nun hatte ich bevor ich die Klasse Warenkorb schrieb mir eine Testklasse Essen gemacht in der ich die folgenden Anweisungen in die main-Methode schrieb:

        Menue<Lebensmittel> Lasagne = new Menue<>("Lasagne");
        Lasagne.addZutat(new Lebensmittel("Bratfett","Oel",0.2,"Bratfett fluessig",Lebensmittel.VPE.L));
        Lasagne.addZutat(new Lebensmittel("Zwiebeln","Gemuese",0.3,"Zwiebeln weiss", Lebensmittel.VPE.g));
        Lasagne.addZutat(new Lebensmittel("Gehacktes gemischt","Fleisch",0.5,"Gehacktes gemischt Schwein Rind",Lebensmittel.VPE.kG));
        Lasagne.addZutat(new Lebensmittel("Tomaten","Gemuese",3,"rote Tomaten",Lebensmittel.VPE.stk));
        Lasagne.addZutat(new Lebensmittel("Lasagne Gewürz","Gewuerz",2,"Lasagnegewuerz",Lebensmittel.VPE.stk));
        Lasagne.addZutat(new Lebensmittel("Mehl","Mehl",0.3,"Weizenmehl Typ 405", Lebensmittel.VPE.g));
        Lasagne.addZutat(new Lebensmittel("Milch","Milch",0.5,"Vollmilch 3,8%",Lebensmittel.VPE.L));
        Lasagne.addZutat(new Lebensmittel("Lasagneplatten","Nudeln",0.4,"Lasagneplatten",Lebensmittel.VPE.g));
        for (Lebensmittel l : Lasagne.Ekaufliste()) {
            System.out.println(l.getMenge());
        }

Nun habe ich ein Problem mit meiner unvollendeten Methode

public ArrayList<String> getTypes()

in meiner Klasse Warenkorb.

In der Mainmethode habe ich eine "Lasagne" erstellt und anschließend mir mit der Methode Lasagne.Ekaufliste eine auf ArrayList<Lebensmittel> gecastete Kopie der ArrayList besorgt die ich in der for-Schleife durchlaufe, das funktioniert auch gut und ich bekomme eine Liste der Mengen der in der Lasagne verwendeten Lebensmittel.

Anschliessend habe ich die oben gezeigte Klasse Warenkorb geschrieben und wollte nun innerhalb dieser die gleiche Technik verwenden um eine Liste der in dem Warenkorb enthaltenen Lebensmittel-Typen auszugeben. Hierzu verwende ich eine ArrayList<String> die ich mit den Typen befüllen möchte.
Also habe ich mir innerhalb der Klasse Warenkorb wieder eine Methode Inhalt() gebaut die mir - analog zur Methode Menue.Ekaufliste() eine auf ArrayList<Lebensmittel> gecastete Kopie der ArrayList zurück geben soll, die ich aber im Unterschied zur vorher direkt innerhalb der gleichen Klasse innerhalb der Methode getTypes() verarbeiten möchte, analog zur for-Schleife in der Klasse Essen.

Nun habe ich das Problem das mir der Editor hier scheinbar nicht akzeptiert das die Variable l ein Objekt des Typs Lebensmittel darstellt, da er mir nicht die Lebensmittel.Methoden bei der Vervollständigung anzeigt sondern nur allgemeine Object.Methoden wie zum Beispiel toString. Aber als Beispiel nicht die Instanzmethode Lebensmittel.getTyp().

Ich verstehe nicht wo hier das Problem liegt, nur weil ich einmal die for-Schliefe ausserhalb der Klasse Menue und einmal dasselbe Prinzip innerhalb der Klasse Warenkorb anwenden möchte, wobei sich Menue und Warenkorb im Prinzip ja nicht unterscheiden. In beiden Fällen gibt die jeweilige Methode doch ein ArrayList<Lebensmittel> zurück und der Compiler sollte wissen das die Objekte vom Typ Lebensmittel sind, oder nicht?

Ich habe den selben Code einmal im NetBeans und auch einmal in Eclipse gecoded um auszuschliessen das es irgendetwas - code unabhängiges ist, aber Fehlanzeige. Weder NetBeans noch Eclipse scheinen wie ich der Meinung zu sein das es sich bei "l" um ein Lebensmittel handelt.

Zwei Fragen:
1. Wo liegt mein Fehler?
und
2. Vielleicht habt ihr einen Tip wie sich die Sache eleganter programmieren lässt? (Aber die Antwort auf Frage 1 würde mich trotzallem interessieren ;-)

Gruß
Heiko

 

[Barista]

Nun habe ich noch zwei Klassen Menue und Warenkorb die beide ArrayList erweitern

Schlechte Idee, ich würde delegieren statt erweitern,
bei der Erweiterung sind alle ursprünglichen Methoden von ArrayList noch vorhanden und können Dein Modell unterlaufen.

public class Warenkorb<Lebensmittel> extends ArrayList

Wenn schon, dann so

public class Warenkorb extends ArrayList<Lebensmittel>

Eine Klasse, welche über Vererbung einen Type-Parameter bindet,
sollte final sein.

Der Grund liegt im Type-Erasure, ich suche morgen mal den entsprechenden Blog-Beitrag raus.

 

[Barista]

Eine Klasse, welche über Vererbung einen Type-Parameter bindet, sollte final sein.
Der Grund liegt im Type-Erasure, ich suche morgen mal den entsprechenden Blog-Beitrag raus.

Ich habs gefunden:

The Dangers of Correlating Subtype Polymorphism with Generic Polymorphism LukasEder at dzone

 

[wciibb]

Danke Barista,

super das ist die Lösung.

Kaum ersetze ich

public class Warenkorb<Lebensmittel> extends ArrayList

durch

public class Warenkorb extends ArrayList<Lebensmittel>

und schon funktioniert es.

"Type erasure" scheint ja genau mein "Phänomen" zu beschreiben, da der Typ von l ja scheinbar "gelöscht" war was erklärt das ich nur noch Objekt-Methoden sehe.

final: Ich sollte also am besten

public final class Warenkorb extends ArrayList<Lebensmittel>

verwenden?

Delegates: Falls ein - schematisch - kurzes Beispiel möglich wäre würd' mich die Variante auch mal interessieren.

Danke noch mal für die Lösung des Phänomens 🙂 Den Blog-Eintrag nehme ich mir mal zum Frühstück vor.

Gruß, Heiko

 

[Barista]

"Type erasure" scheint ja genau mein "Phänomen" zu beschreiben, da der Typ von l ja scheinbar "gelöscht" war was erklärt das ich nur noch Objekt-Methoden sehe.

Nein, Type erasure ist eine Laufzeit-Angelegenheit, insofern muss ich mich auch bezüglich des Blog-Eintrages korrigieren,
dort geht es um ein anderes Problem.

Alles was Du beschrieben hast, passierte zur Compile-Zeit.

Ich staune, dass dein erster Warenkorb-Beispiel-Code überhaupt kompilierbar war, ist aber so.

Der gebundene Typ-Parameter (konkrete Klasse, kein Name) bewirkt an dieser Stelle rein gar nichts.

Delegates: Falls ein - schematisch - kurzes Beispiel möglich wäre würd' mich die Variante auch mal interessieren.

Du benutzt die ArrayList als Member, nicht als Oberklasse:

public class Warenkorb
{
    /**
     * innere ArrayList (Delegation).
     */
    private ArrayList<Lebensmittel> innerList = new ArrayList<>();
    
    // gibt den Inhalt des Warenkorbs zurück
    public ArrayList<Lebensmittel> Inhalt() {
        return (ArrayList<Lebensmittel>) this.innerList.clone();
    }

Jetzt stehen zwar die vorhandenen Methoden wie add nicht zur Verfügung,
die musst Du delegieren:

    /**
     * @param e
     * @return
     * @see java.util.ArrayList#add(java.lang.Object)
     */
    public boolean add( Lebensmittel e )
    {
        return this.innerList.add( e );
    }

aber dafür hast Du diese Methoden auch voll unter Kontrolle und keiner kann eine ursprüngliche Methode der ArrayList unkontrolliert aufrufen.

 

[wciibb]

Ja das wundert mich auch das der ursprüngliche Code in der main Methode überhaupt lief.

Danke für das Beispiel mit der inneren ArrayList. Dies gefällt mir dahin gehend auch besser, da ich auf diesem Wege mehr Kontrolle über die ArrayList-Methoden habe und so zB. niemand einfach so die clear()-Methode verwenden könnte.

Danke noch mal für des Rätsels Lösung.