# Klasse Objektbehälter programmieren



## JavaIsTheBest (8. Mai 2016)

Hallo,
ich soll so eine Art Objektbehälter programmieren. Das habe ich auch gemacht und würde gerne wissen, ob alles soweit richtig ist.



Spoiler: Bag





```
public class Bag {
    private int kapazitaet = 1;
    private int kardinalitaet;
    Object[] behaelter;

    public Bag() {
        behaelter = new Object[kapazitaet];
    }

    public Bag(int n) { // Oberen Konstruktor aufrufen? Nein
        if(n<1) n=1;
        this.kapazitaet = n;
        behaelter = new Object[kapazitaet];
    }

    public void add(Object o) {
        if (o != null) {
            if (kapazitaet == kardinalitaet) {
                Object[] tmp = new Object[2 * kapazitaet];
                for (int i = 0; i < kardinalitaet; i++) {
                    tmp[i] = behaelter[i];
                }
                behaelter=tmp; 
                behaelter[kardinalitaet] = o;
                kardinalitaet++;
            }
        }
    }

    public int find(Object o) {
        for (int i = 0; i < kardinalitaet; i++) {
            if (o.equals(behaelter[i]))
                return i + 1;
        }
        return 0;
    }

    public int size() {
        return kardinalitaet;
    }

    public Object elem(int i) {
        if (i > 0 && i <= kardinalitaet)
            return behaelter[i - 1];
        else
            return null;
    }

    public void remove(Object o) {
        int i=find(o);
        if(i==0) return;  //Was macht dieses return?
        behaelter[i-1]=behaelter[kardinalitaet];
        behaelter[kardinalitaet]=null; //Nicht nötig
        kardinalitaet--;
        }
}
```




1. In der Musterlösung ist die tatsächliche Menge der Objekte nicht als private Objektvariable enthalten.
2. Was macht dieses return in der remove Methode?
3.  Warum kann ich tmp an behaelter zuweisen, obwohl behaelter kleiner als tmp ist?
4. Stimmt mein Code soweit (ist ähnlich, wie in der Musterlösung)?


----------



## mrBrown (8. Mai 2016)

1. beides ist möglich, private ist aber schönerer Stil.
2. return beendet die Methode. Wenn i==0, existiert das Objekt ja nicht, also kann auch keins entfernt werden, also wird direkt aus der Methode gesprungen.
3. tmp und behaelter sind nur Zeiger auf das Array, behaelter zeigt erst auf das eine Arrays, tmp aus das andere, und durch behaelter=tmp zeigt behaelter auf das selbe Objekt. das alte Array kann der GC dann aufräumen.

4.Hast du ihn denn mal getestet? Wenn nein, dann tu es mal, dann siehst du es selbst  
(und nein, es gibt noch Fehler, die siehst du dann beim testen)


----------



## JavaIsTheBest (9. Mai 2016)

Ich denke, jetzt müsste das Programm passen.



Spoiler: Bag





```
public class Bag {
    private int kapazitaet = 1;
    private int kardinalitaet;
    Object[] behaelter;

    public Bag() {
        behaelter = new Object[kapazitaet]; 
    }

    public Bag(int n) { // Oberen Konstruktor aufrufen? Nein
        if(n<1) n=1;
        this.kapazitaet = n;
        behaelter = new Object[kapazitaet]; 
    }

    public void add(Object o) {
        if (o != null) {
            if (kapazitaet == kardinalitaet) {
                Object[] tmp = new Object[2 * kapazitaet];
                for (int i = 0; i < kardinalitaet; i++) {
                    tmp[i] = behaelter[i];
                }
                behaelter=tmp; //Warum geht das, obwohl tmp größer behaelter?
            }
            behaelter[kardinalitaet] = o;
            kardinalitaet++;
        }
    }

    public int find(Object o) {
        for (int i = 0; i < kardinalitaet; i++) {
            if (o.equals(behaelter[i]))
                return i + 1;
        }
        return 0;
    }

    public int size() {
        return kardinalitaet;
    }

    public Object elem(int i) {
        if (i > 0 && i <= kardinalitaet)
            return behaelter[i - 1];
        else
            return null;
    }

    public void remove(Object o) {
        int i=find(o);
        if(i==0) return;  //Was macht dieses return?
        behaelter[i-1]=behaelter[kardinalitaet];
        behaelter[kardinalitaet]=null; //Nicht nötig
        kardinalitaet--;
        }
}
```






Spoiler: Main





```
public class Testprogramm {

    public static void main(String[] args) {
        Bag b = new Bag(3);
        // b mit 3 Elementen
        b.add(3);
        b.add(4);
        b.add(5);
        b.add(6);
       
        int n =b.size();
        System.out.println(n);
       
        int f=b.find(4);
        System.out.println(f);
       
        Object o=b.elem(0);
        System.out.println(o);
        Object o2=b.elem(5);
        System.out.println(o2);
        Object o3=b.elem(3);
        System.out.println(o3);
       
        b.remove(o3);
       
       
        int m =b.size();
        System.out.println(m);
       
       

    }

}
```


----------



## BuckRogers (9. Mai 2016)

Hi,

deine Bag erwartet einen komplexen Datentyp und keinen Primitiven. Du solltest deine Zahlen als Integer Objekt (Integer int4 = new Integer(4); usw.) übergeben damit es wenigstens kompiliert.
Ansonsten läuft es.
Deine Ausgabe solltest du etwas aussagekräftiger gestalten. Wenn einfach nur Zahlen und null-Werte ausgegeben werden ist das nicht unbedingt informativ.
Mit fallen noch ein paar Ekelhaftigkeiten am Codestil auf, aber das lernt man mit der Zeit sicherlich noch.


----------



## mrBrown (9. Mai 2016)

BuckRogers hat gesagt.:


> Hi,
> 
> deine Bag erwartet einen komplexen Datentyp und keinen Primitiven. Du solltest deine Zahlen als Integer Objekt (Integer int4 = new Integer(4); usw.) übergeben damit es wenigstens kompiliert.
> Ansonsten läuft es.



Dank Autoboxing völlig egal ^^


Es gibt aber immer noch Fehler zur Laufzeit, adde mal noch weitere Elemente


----------



## BuckRogers (9. Mai 2016)

mrBrown hat gesagt.:


> Dank Autoboxing völlig egal ^^


Ah danke.
Hätte mal die JavaVersion erhöhen sollen xD


----------



## JavaIsTheBest (11. Mai 2016)

mrBrown hat gesagt.:


> Dank Autoboxing völlig egal ^^
> 
> 
> Es gibt aber immer noch Fehler zur Laufzeit, adde mal noch weitere Elemente



Ich hab vergessen die Kapazität zu erhöhen. Jetzt müsste es stimmen.



Spoiler: add





```
public void add(Object o) {
        if (o != null) {
            if (kapazitaet == kardinalitaet) {
                kapazitaet*=2;
                Object[] tmp = new Object[kapazitaet];
                for (int i = 0; i < kardinalitaet; i++) {
                    tmp[i] = behaelter[i];
                }
                behaelter=tmp; //Warum geht das, obwohl tmp größer behaelter?
            }
            behaelter[kardinalitaet] = o;
            kardinalitaet++;
        }
    }
```


----------



## JavaIsTheBest (11. Mai 2016)

Die Erweiterung der Aufgabe ist im Anhang. Ich hab versucht die Klasse Vec zu testen. Entweder ist die Klasse Vec falsch oder mein Testprogramm. Die remove Methode funktioniert z.B. nicht. Mit dem Debugger bin ich auch nicht schlauer geworden.

1. Was an meinem Programm ist noch falsch?
2. Warum brauch ich in der Klasse Vec keine privaten Attribute x1,x2? Ein zweidimensionaler Vektor besteht immerhin aus diesen Koordinaten.



Spoiler: Bag





```
public class Bag {
    protected int kapazitaet = 1;
    private int kardinalitaet;
    protected Object[] behaelter; //protected, damit man in den Unterklassen auf behaelter zugreifen kann.

    public Bag() {
        behaelter = new Object[kapazitaet];  
    }

    public Bag(int n) { // Oberen Konstruktor aufrufen? Nein
        if(n<1) n=1;
        this.kapazitaet = n;
        behaelter = new Object[kapazitaet]; 
    }

    public void add(Object o) {
        if (o != null) {
            if (kapazitaet == kardinalitaet) {
                kapazitaet*=2;
                Object[] tmp = new Object[kapazitaet];
                for (int i = 0; i < kardinalitaet; i++) {
                    tmp[i] = behaelter[i];
                }
                behaelter=tmp; //Warum geht das, obwohl tmp größer behaelter?  tmp und behaelter sind nur Zeiger auf das Array, behaelter zeigt erst auf das eine Arrays, tmp aus das andere, und durch behaelter=tmp zeigt behaelter auf das selbe Objekt. das alte Array kann der GC dann aufräumen.
            }
            behaelter[kardinalitaet] = o;
            kardinalitaet++;
        }
    }

    public int find(Object o) {
        for (int i = 0; i < kardinalitaet; i++) {
            if (o.equals(behaelter[i]))
                return i + 1;
        }
        return 0;
    }

    public int size() {
        return kardinalitaet;
    }

    public Object elem(int i) {
        if (i > 0 && i <= kardinalitaet)
            return behaelter[i - 1];
        else
            return null;
    }

    public void remove(Object o) {
        int i=find(o);
        if(i==0) return;  //Was macht dieses return?
        behaelter[i-1]=behaelter[kardinalitaet];
        behaelter[kardinalitaet]=null; //Nicht nötig
        kardinalitaet--;
        }
}
```






Spoiler: Vec





```
public class Vec extends Bag {
    // Warum benötigt man hier keine privaten Objektvariablen?
    private double x1;
    private double x2;

    public Vec() {
        super(1);
    }

    public Vec(int n) {
        super(n);
    }

    public void remove(Object o) {
        super.remove(o);
        int j=1; //Funktioniert, auch wenn kapazitaet=1
        for(int i=0;i<kapazitaet-1;i++){
            if(behaelter[i]==null){
                behaelter[i]=behaelter[j];
                j++;
            }
        }
        kapazitaet--;
    }
   
    public void remove(int i) {
        if(i<1 || i>super.size()){
            return; // Geht aus der Methode raus
        }
        Object o=super.elem(i-1);
        //behaelter[i-1]=null; Nicht nötig
        remove(o);
       
    }
    /*
    equals ist eine Methode die von Object stammt. Der Sinn von equals ist es, zwei beliebige Objekte miteinander vergleichen zu können, egal von welchem Typ sie tatsächlich sind.
Wenn man equals jetzt so implementieren würde, daß es bereits einen Vec entgegen nimmt, muss derjenige, der die Funktion aufruft ja bereits wissen, daß man gerade zwei Vec-Objekte vergleichen will. Wenn man dann zwei unbekannte Objekte vergleichen wollte, müsste man ja erst ermitteln, von welchem Typ die entsprechenden Objekte sind und dann die jeweilige equals-Methode aufrufen. Da ist es einfacher und flexibler, diese Prüfung einmal in der equals-Funktion zu machen, als jedesmal wenn man equals aufruft.
    
     *Anders gesagt: Jedes Objekt, das der Entwickler selbst erstellt, erbt von der Klasse Object. Das hat diverse vorgegebene Methoden und diese können überschrieben werden.
     */
    public boolean equals(Object o){
        if(!(o instanceof Vec)) return false;
        else{
            Vec v=(Vec) o;
            if(this.size()!=v.size()) return false;
            for(int i=0;i<super.size();i++){
                if(!(v.elem(i).equals(this.elem(i) ))) return false;
            }
        }
        return true;
    }
}
```






Spoiler: Main





```
public class Testprogramm {

    public static void main(String[] args) {
        /*Bag b = new Bag(3);
        // b mit 3 Elementen
        b.add(3);
        b.add(4);
        b.add(5);
        b.add(6);
        b.add(6);
        b.add(10);
        b.add(61);
        b.add(34);
       
        int n =b.size();
        System.out.println(n);
       
        int f=b.find(4);
        System.out.println(f);
       
        Object o=b.elem(0);
        System.out.println(o);
        Object o2=b.elem(5);
        System.out.println(o2);
        Object o3=b.elem(3);
        System.out.println(o3);
       
        //b.remove(o3);
       
       
        int m =b.size();
        System.out.println(m);*/
       
        Vec v1=new Vec(10);
        //Vec v2=new Vec(5);
        //Vec v3=new Vec(10);
       
        v1.add(3);
        v1.add(4);
        v1.add(5);
       
        int f= v1.find(5);
        //System.out.println(f);
       
        v1.remove(3);
        System.out.println(f);
       
       
       
       

    }

}
```


----------



## Flown (11. Mai 2016)

Du hast in deinen Übungsblättern immer so schöne Lösungen anbei. Warum versuchst du nicht diese zu verstehen was gemacht wird?


----------



## JavaIsTheBest (11. Mai 2016)

Ich versuch das auf meine Art zu lernen. Sicherlich ist meine Lösung nicht immer so gut, wie in der Musterlösung.


----------



## Flown (11. Mai 2016)

Programmieren ist Abläufe verstehen und eine eigene Weise ist schon in Ordnung aber bei ein paar Ansätze von dir hab ich keinen Plan was das soll.


----------



## JavaIsTheBest (11. Mai 2016)

Z.B.?
Welche Methoden sind falsch? Oder was für Methoden "vefstehst du nicht"?
Dann kann ich erklären, was ich mir gedacht habe.


----------



## mrBrown (11. Mai 2016)

Du rufst zb in #remove(Object) super.remove(Object) auf, das removen von Vec soll aber anders funktionieren, als super.remove

warum sollte ein Vector zwei double-Werte besitzen? 
Ein Vector ist nur ein Tupel beliebig vieler Objekte, ein Vektor mit zwei double-Werten ist ein Spezialfall davon, nämlich ein 2-dim. Vektor in R^2, du sollst aber den Allgemeinen Fall programmieren (den man dann auch als 2-dim R^2 benutzen kann).


----------



## Flown (11. Mai 2016)

Zum Beispiel in der Klasse `Vec` die Methode: `public void remove(Object o)`
Warum überprüfst du auf `null`-Elemente?
Warum hast du ein j definiert obwohl du nur immer eins vorschieben müsstest?


----------



## JavaIsTheBest (11. Mai 2016)

mrBrown hat gesagt.:


> Du rufst zb in #remove(Object) super.remove(Object) auf, das removen von Vec soll aber anders funktionieren, als super.remove



Da hast du schon Recht, bei dem remove in Vec muss noch auf die Reihenfolge geachtet werden. Ich mach das aber so, dass ich die Methode public void remove(Object o) in Vec mit super.remove(Object o) überschreibe. Dann ist erstmal das Element weg. Jetzt steht, da wo das Objekt war ein "null". die Elemente rechts von null, will ich nach links verschieben (siehe Anhang).


----------



## mrBrown (11. Mai 2016)

JavaIsTheBest hat gesagt.:


> Da hast du schon Recht, bei dem remove in Vec muss noch auf die Reihenfolge geachtet werden. Ich mach das aber so, dass ich die Methode public void remove(Object o) in Vec mit super.remove(Object o) überschreibe. Dann ist erstmal das Element weg. Jetzt steht, da wo das Objekt war ein "null". die Elemente rechts von null, will ich nach links verschieben (siehe Anhang).



Da steht eben keine null, sondern das vorher letzte Element wird an die Stelle verschoben, damit ist deine Ordnung hinüber.


----------



## JavaIsTheBest (12. Mai 2016)

Ich denke, es müsste jetzt alles richtig sein (ich weiß nicht ob ein paar Bugs drin sind). Jedenfalls haben die Tests geklappt.
1. Die equals Methode funktioniert auch und stimmt es so, wie ich es gemacht habe, dass in der Schleife bei    1 gezählt werden muss?
2. Ich habe die Attribute in der Klasse Bag alle auf protected gesetzt. Ist das schlechter Programmierstil oder in Ordnung?




Spoiler: Bag





```
public class Bag {
    protected int kapazitaet = 1;
    protected int kardinalitaet;
    protected Object[] behaelter; //protected, damit man in den Unterklassen auf behaelter zugreifen kann.

    public Bag() {
        behaelter = new Object[kapazitaet]; 
    }

    public Bag(int n) { // Oberen Konstruktor aufrufen? Nein
        if(n<1) n=1;
        this.kapazitaet = n;
        behaelter = new Object[kapazitaet]; 
    }

    public void add(Object o) {
        if (o != null) {
            if (kapazitaet == kardinalitaet) {
                kapazitaet*=2;
                Object[] tmp = new Object[kapazitaet];
                for (int i = 0; i < kardinalitaet; i++) {
                    tmp[i] = behaelter[i];
                }
                behaelter=tmp; //Warum geht das, obwohl tmp größer behaelter?  tmp und behaelter sind nur Zeiger auf das Array, behaelter zeigt erst auf das eine Arrays, tmp aus das andere, und durch behaelter=tmp zeigt behaelter auf das selbe Objekt. das alte Array kann der GC dann aufräumen.
            }
            behaelter[kardinalitaet] = o;
            kardinalitaet++;
        }
    }

    public int find(Object o) {
        for (int i = 0; i < kardinalitaet; i++) {
            if (o.equals(behaelter[i]))
                return i + 1;
        }
        return 0;
    }

    public int size() {
        return kardinalitaet;
    }

    public Object elem(int i) {
        if (i > 0 && i <= kardinalitaet)
            return behaelter[i - 1];
        else
            return null;
    }

    public void remove(Object o) {
        int i=find(o);
        if(i==0) return;  //Was macht dieses return?
        behaelter[i-1]=behaelter[kardinalitaet];
        behaelter[kardinalitaet]=null; //Nicht nötig
        kardinalitaet--;
        }
}
```







Spoiler: Vect





```
public class Vec extends Bag {
    // Warum benötigt man hier keine privaten Objektvariablen? warum sollte ein Vector zwei double-Werte besitzen?
    //Ein Vector ist nur ein Tupel beliebig vieler Objekte, ein Vektor mit zwei double-Werten ist ein Spezialfall davon, nämlich ein 2-dim. Vektor in R^2, du sollst aber den Allgemeinen Fall programmieren (den man dann auch als 2-dim R^2 benutzen kann).
    //private double x1;
    //private double x2;

    public Vec() {
        super(1);
    }

    public Vec(int n) {
        super(n);
    }
    public void remove(int i) {
        if(i<1||i>kapazitaet) return;
        Object o=elem(i);
        remove(o);
       
       
    }
    public void remove(Object o) {
        int index=super.find(o);
        behaelter[index]=null;
        for(int i=index;i<kapazitaet-1;i++){
            if(behaelter[i]==null){
                behaelter[i]=behaelter[i+1];
                behaelter[i+1]=null;
            }
        }
        kardinalitaet--;
    }
   
    /*
    equals ist eine Methode die von Object stammt. Der Sinn von equals ist es, zwei beliebige Objekte miteinander vergleichen zu können, egal von welchem Typ sie tatsächlich sind.
Wenn man equals jetzt so implementieren würde, daß es bereits einen Vec entgegen nimmt, muss derjenige, der die Funktion aufruft ja bereits wissen, daß man gerade zwei Vec-Objekte vergleichen will. Wenn man dann zwei unbekannte Objekte vergleichen wollte, müsste man ja erst ermitteln, von welchem Typ die entsprechenden Objekte sind und dann die jeweilige equals-Methode aufrufen. Da ist es einfacher und flexibler, diese Prüfung einmal in der equals-Funktion zu machen, als jedesmal wenn man equals aufruft.
    
     *Anders gesagt: Jedes Objekt, das der Entwickler selbst erstellt, erbt von der Klasse Object. Das hat diverse vorgegebene Methoden und diese können überschrieben werden.
     */
    public boolean equals(Object o){
        if(!(o instanceof Vec)) return false;
        else{
            Vec v=(Vec) o;
            if(this.size()!=v.size()) return false;
            for(int i=1;i<=super.size();i++){
                if(!(v.elem(i).equals(this.elem(i) ))) return false;
            }
        }
        return true;
    }
}
```






Spoiler: Main





```
public class Testprogramm {

    public static void main(String[] args) {
        /*Bag b = new Bag(3);
        // b mit 3 Elementen
        b.add(3);
        b.add(4);
        b.add(5);
        b.add(6);
        b.add(6);
        b.add(10);
        b.add(61);
        b.add(34);
       
        int n =b.size();
        System.out.println(n);
       
        int f=b.find(4);
        System.out.println(f);
       
        Object o=b.elem(0);
        System.out.println(o);
        Object o2=b.elem(5);
        System.out.println(o2);
        Object o3=b.elem(3);
        System.out.println(o3);
       
        //b.remove(o3);
       
       
        int m =b.size();
        System.out.println(m);*/
       
        Vec v1=new Vec(10);
        Vec v2=new Vec(10);
        Vec v3=new Vec(5);
       
       
       
   
       
        Object o=3;
       
        v1.add(3);
        v1.add(o);
        v1.add(5);
       
        v2.add(3);
        v2.add(o);
        v2.add(5);
       
        v3.add(3);
        v3.add(o);
        //v3.add(10);
       
       
        //v1.remove(o);
        //v1.remove(2);
        //System.out.println(v1.elem(1));
       
        System.out.println(v1.equals(v2));
        System.out.println(v1.equals(v3));
       
       
       
       
       
       
       
       

    }

}
```


----------



## Flown (12. Mai 2016)

Dein `Vec::remove(Object)` stimmt noch immer nicht.

```
public void remove(Object o) {
        int index=super.find(o); //ok
        behaelter[index]=null; // ist obsolet
        for(int i=index;i<kapazitaet-1;i++){ // brauchst nur bis zur Größe laufen: index <= i <= kardinalitaet
            if(behaelter[i]==null){ // null checks brauchst du nur im Bag::add
                behaelter[i]=behaelter[i+1]; // behaelter[i-1] = behaelter[i];
                behaelter[i+1]=null; // braucht man nicht
            }
        }
        kardinalitaet--;
                                    //Hier noch möglich behaelter[kardinalitaet] = null;
    }
```


----------



## JavaIsTheBest (12. Mai 2016)

Was ist daran falsch?


----------



## Flown (12. Mai 2016)

Angenommen du hast in deinem Vec `[0, 1, 2, 3]` Elemente. Was passiert wenn ich `2` rauslösche?
Also den Code `v.remove((Integer) 2);` aufrufe?


----------



## JavaIsTheBest (12. Mai 2016)

Ich habe das jetzt so umgeändert.


Spoiler: remove





```
public void remove(Object o) {
        int index=super.find(o)-1;
        behaelter[index]=null;
        for(int i=index;i<size()-1;i++){
            //if(behaelter[i]==null) Unnötig!!!!
                behaelter[i]=behaelter[i+1];
                behaelter[i+1]=null;
           
        }
        kardinalitaet--;
    }
```




1. Warum benötige ich diese Zeile nicht? behaelter[i+1]=null; Ohne diese Zeile steht das Objekt doppelt drin.
2. Ich habe die Attribute in der Klasse Bag alle auf protected gesetzt. Ist das schlechter Programmierstil oder in Ordnung?


----------



## Joose (12. Mai 2016)

JavaIsTheBest hat gesagt.:


> 1. Warum benötige ich diese Zeile nicht? behaelter[i+1]=null; Ohne diese Zeile steht das Objekt doppelt drin.


Ja diese Zeile wird benötigt, da du sonst wie du schon erkannt hast das letzte Element 2x drinnen stehen hast (sofern dieses != null ist).
Es reicht aber aus 1x nach der Schleife das letzte Element auf null zu setzen.



JavaIsTheBest hat gesagt.:


> 2. Ich habe die Attribute in der Klasse Bag alle auf protected gesetzt. Ist das schlechter Programmierstil oder in Ordnung?


Die Attribute sollten die Sichtbarkeit bekommen, welche gebraucht wird. Hier kommt es dann eben auf den Kontext an ob etwas public, private, protected oder package private ist.


----------



## JavaIsTheBest (12. Mai 2016)

Bei der Aufgabe im Anhang sind mir ein paar Sachen nicht klar.

a) Bag als Oberklasse
equals muss wie in Vec überschrieben werden.
Warum muss hier equals überschrieben werden? equals existiert doch gar nicht in der Klasse Bag also müsste die Methode doch HINZUGEFÜGT werden?

b) Set als Oberklasse
remove(o) muss wie in Vec überschrieben werden.
Hier analog zu a). remove(o) Methode existiert in der Klasse set nicht also muss Sie HINZUGEFÜGT werden?

c) Vec als Oberklasse
add muss wie in Set überschrieben werden.
Hier genauso wie a) und b).


----------



## mrBrown (12. Mai 2016)

equals und remove werden von der Oberklasse geerbt.
Entweder du überschreibst sie dann in der erbenden Klasse, oder es wird die Methode der Oberklasse benutzt


----------



## JavaIsTheBest (12. Mai 2016)

Ist mit Oberklasse Bag bzw. Set gemeint? Oder meinst du die Oberklasse Object?


----------



## mrBrown (13. Mai 2016)

JavaIsTheBest hat gesagt.:


> Ist mit Oberklasse Bag bzw. Set gemeint? Oder meinst du die Oberklasse Object?


Beides. equals kommt ursprünglich aus Object, remove aus Bag/Set


----------



## JavaIsTheBest (13. Mai 2016)

Ich stehe gerade auf dem Schlauch. Kann ich mir die Klassenhierarchie, wie im Anhang vorstellen?


----------



## BuckRogers (13. Mai 2016)

Na ab in die Tasten gehauen!

Du brauchst drei neue Klassen die einmal von Bag, Set und Vec erben. Dann erfüllst du in allen dieser Klassen die 4 Punkte(Eigenschaften)...

Auf dem Weg dahin werden dir einige Dinge auffallen und du kannst dann alle Fragen unten beantworten 

Programmieren ist 'learning by doing'! Aus dem Kopf kann ich dir das auch nicht ad hoc beantworten.


----------



## JavaIsTheBest (13. Mai 2016)

BuckRogers hat gesagt.:


> Na ab in die Tasten gehauen!
> 
> Du brauchst drei neue Klassen die einmal von Bag, Set und Vec erben. Dann erfüllst du in allen dieser Klassen die 4 Punkte(Eigenschaften)...
> 
> ...




Das hab ich doch dargestellt?
Ich hab die drei neuen Klasen einfach Subklasse genannt. Oder ist die Darstellung falsch?


----------



## BuckRogers (13. Mai 2016)

Naja,

nur kannst du mit der Darstellung die Fragen nicht beantworten. 

Du solltest dir etwas anlegen was in etwa so aussieht:
_
"Wenn Sie als Oberklasse dieser Klasse a) Bag b) Set c) Vec verwenden würden:
Welche Methoden müssten Sie in dieser Klasse *jeweils *hinzufügen oder überschreiben und wie?"_

```
public class VecEx extends Vec {
...
}

public class BagEx extends Bag {
...
}

public class SetEx extends Set {
...
}
```

Dann musst du entweder die Methoden überschreiben oder super aufrufen, je nachdem wie es der Anforderung nach funktionieren würde.


----------



## JavaIsTheBest (14. Mai 2016)

JavaIsTheBest hat gesagt.:


> Bei der Aufgabe im Anhang sind mir ein paar Sachen nicht klar.
> 
> a) Bag als Oberklasse
> equals muss wie in Vec überschrieben werden.
> ...




1. Ich verstehe die genannten Punkte immer noch nicht.
2. Und wird in Vec in der Methode String ein inhaltlicher Vergleich gemacht?


----------



## mrBrown (14. Mai 2016)

1. Was verstehst du daran nicht?

2. warum sollte in toString() irgendwas vergleichen werden? Es wird einfach nur ein String erstellt.


----------



## JavaIsTheBest (14. Mai 2016)

Also jetzt ist es mir klar geworden. Ich habe nur noch eine Frage um sicherzugehen.
Die Methode equals wird in der Klasse Bag überschrieben, weil man zwei Bag Objekte vergleichen will und nicht Objekte vom Typ Object?


----------

