Generische Typen

[Deamon1337]

Hallo ich soll für die uni ein Klassengerüst erstellen:
Zuerst sollte ich eine abstrakte classe Tier und dann eine abstrakte extension Säugetier erstellen. Dann die interfaces giftig, schwimmend und kinderfreundlich erstellen.
Danach sollte ich eine generische Klasse Gehege und Aquarium erstellen um anhand der Interfaces die Tiere zu filtern, die nicht schwimmen können. Habe das über <T> versucht.

  abstract class Tier{
    
   }
   abstract class Säugetier extends Tier{
   }  
   }
  
   public interface giftig <G>
   }
   public interface schwimmend <T>{
   }
   public interface kinderfreundlich <G>{
   }
   public class Aquarium <T>{
     private T object;
     public void setObject(T object){
       this.object =object;
     }
     public T getObject(){
       return object;
     }
   }
   public class Gehege <G>{
     private G object;
     public void setObject(G object){
       this.object =object;
     }
     public G getObject(){
       return object;
     }
    

   }

Wäre das so ok?
Als nächstes soll ich eine statische Methode public static <T … > Gehege<T> entferneGiftigesSaeugetierAusStreichelZoo(T tier) erstellen, mit der man die nicht kinderfreundlichen Säugetiere, wie den giftigen Schlitzrüssler (Wikipedia: Schlitzrüssler) und die giftigen Schnabeltiere (Wikipedia: Schnabeltier) aus dem Streichelzoo entfernen kann. Dabei muss beachtet werden, dass Schlitzrüssler nicht schwimmen können und in ein Gehege gebracht werden müssen. Schnabeltiere können sowohl in ein Gehege als auch in ein Aquarium gebracht werden.

Kann mir bei der Aufgabe jemand helfen oder nen paar tipps geben?

Vielen dank für jede Hilfe,

Gruß Deamon1337

 

[Saheeda]

Dein Aquarium kann bisher nur ein Tier aufnehmen. Außerdem darf momentan noch jedes Tier hinein, egal ob schwimmfähig oder nicht.

 

[Deamon1337]

Dein Aquarium kann bisher nur ein Tier aufnehmen. Außerdem darf momentan noch jedes Tier hinein, egal ob schwimmfähig oder nicht.

ist das nicht durch den typ <T> ausgeschlossen? Und wie kann ich denn mehrere Tiere aufnehmen?

 

[Saheeda]

Deine Klasse ist zwar durch <T> getypt, hat aber keinerlei Einschränkungen (z.B. <T extends schwimmend>), womit T im Grunde alles sein kann.
Mehrere Tiere kannst du durch eine Liste oder ein Set realisieren. Wobei ich mir ehrlich gesagt nicht sicher bin, wie die Aufgabenstellung geplant ist. Soll der Zoo viele Gehege mit je einem Tier besitzen oder zwei Gehege mit jeweils ganz vielen Tieren? (Zwei Gehege wären bei nem normalen Zoo sinnfrei, ich weiß, aber trotzdem könnte es so gefordert sein).

Könntest du bitte die komplette Aufgabenstellung posten? (Screenshot reicht auch).

 

[Deamon1337]

Hier die komplette Aufgabenstellung

 

[Christopher25]

probier mal folgendes.

public class Aquarium {
public List<ISchwimmend> list;

public addAnimal(ISchwimmend animal) {
list.add(animal);
}
}

public class Gehege{
public List<ILandAnimal> list;

// Sorry für diese Bezeichnung, mir ist im moment nichts besseres eingefallen
// Jedoch sollte man ja keine schwimmende Tiere in ein Gehege nehmen dürfen
// deswegen muss man diese ja ausgrenzen.
public addAnimal(ILandAnimal animal) {
list.add(animal);
}
}

PS:
Die listen sollten im Konstruktor instanziiert werden.

 

[Tarrew]

@Christopher25
Die Klassen Aquarium und Gehege sind nicht generisch wie in der Aufgabe gefordert.
Vorteil der Generics sind, dass man ein Gehege erstellen kann, das nur kinderfreundliche Tiere enthält und ein zweites Gehege, das nur giftige Tiere enthält. In deinem Vorschlag ist diese Trennung nicht wirklich möglich, da man kinderfreundliche und giftige Tiere mischen kann.

 

[thecain]

Ich behaupte mal, generische Interfaces sind für diese Aufgabe nicht nötig.
dafür jedoch die Klassen generisch.

Dafür aber ein generisches Gehege public class Gehege<T>

 

[Deamon1337]

Also müsste das ganze dann so aussehen?

  abstract class Tier{
    
   }
   abstract class Säugetier extends Tier{
   }  
   }
  
   public interface giftig <ILandAnimal>{
    
    
   }
   public interface schwimmend <ISchwimmend>{
    
   }
   public interface kinderfreundlich <ILandAnimal>{
    
   }
   public class Aquarium {
   public List<ISchwimmend> list;

   public addAnimal(ISchwimmend animal) {
   list.add(animal);
   }
   }
   public class Gehege{
   public List<ILandAnimal> list;


   public addAnimal(ILandAnimal animal) {
   list.add(animal);
   }
   }

Soweit so gut.

 

[Flown]

Verwende bitte Code-Tags: [code=java]//Java Code HERE [/code]

 

[Christopher25]

@Christopher25
Die Klassen Aquarium und Gehege sind nicht generisch wie in der Aufgabe gefordert.
Vorteil der Generics sind, dass man ein Gehege erstellen kann, das nur kinderfreundliche Tiere enthält und ein zweites Gehege, das nur giftige Tiere enthält. In deinem Vorschlag ist diese Trennung nicht wirklich möglich, da man kinderfreundliche und giftige Tiere mischen kann.

Wenn diese Trennung wie du es sagst von statten ginge, wäre die Komplette Aufgabe C und D für die Katz.

Hier nochmal ein korregierter/erweiterter Vorschlag von mir:

probier mal folgendes.

public class Aquarium {
public List<ISchwimmend> list;

public addAnimal(ISchwimmend animal) {
list.add(animal);
}
}

public class Gehege{
public List<ILandAnimal> list;

// Sorry für diese Bezeichnung, mir ist im moment nichts besseres eingefallen
// Jedoch sollte man ja keine schwimmende Tiere in ein Gehege nehmen dürfen
// deswegen muss man diese ja ausgrenzen.
public void addAnimal(ILandAnimal animal) {
list.add(animal);
}

public void removeAnimal(ILandAnime animel) {
list.remove(animal);
}
}

PS:
Die listen sollten im Konstruktor instanziiert werden.

public static Gehege<Tier> entferneGiftigesSaeugetierAusStreichelZoo(Gehege oldGehege, IGiftig giftigesTier) {

oldGehege.removeAnimal(giftigesTier);

Gehege<Tier> g = new Gehege();
g.add(giftigesTier);

return g;
}

 

[Deamon1337]

public static Gehege<Tier> entferneGiftigesSaeugetierAusStreichelZoo(Gehege oldGehege, IGiftig giftigesTier) {

oldGehege.removeAnimal(giftigesTier);

Gehege<Säugetier> g = new Gehege();
g.add(giftigesTier);

return g;
}

Hab mal Tier durch Säugetier ersetzt.
Dann könnte d ja vielleicht so aussehen:

public static Gehege<Tier> entferneGiftigesSchwimmendesSaeugetierAusStreichelZoo(Gehege oldGehege, IGiftig giftigesTier) {

oldGehege.removeAnimal(giftigesTier);

Aquarium<[B]Säugetier[/B]> a = new Aquarium();
a.add(giftigesTier);

return a;
}

 

[Christopher25]

Hab mal Tier durch Säugetier ersetzt.
Dann könnte d ja vielleicht so aussehen:

public static Gehege<Tier> entferneGiftigesSchwimmendesSaeugetierAusStreichelZoo(Gehege oldGehege, IGiftig giftigesTier) {

oldGehege.removeAnimal(giftigesTier);

Aquarium<[B]Säugetier[/B]> a = new Aquarium();
a.add(giftigesTier);

return a;
}

Das Aquarium darf doch nur schwimmende Tiere aufnehmen, warum also dann alle Säugetiere??

 

[Deamon1337]

Oh mist das hab ich von der verbesserung von der Methode davor übernommen. Was ich eigentlich meinte war, ich hab in der Methode davor Tier durch Säugetier ersetzt, bei dieser Methode habe ich die änderung einfach versehendlich übernommen ^^

public static Gehege<Tier> entferneGiftigesSchwimmendesSaeugetierAusStreichelZoo(Gehege oldGehege, IGiftig giftigesTier) {

oldGehege.removeAnimal(giftigesTier);

Aquarium<ISchwimmend> a = new Aquarium();
a.add(giftigesTier);

return a;
}

 

[Christopher25]

Oh mist das hab ich von der verbesserung von der Methode davor übernommen.

public static Gehege<Tier> entferneGiftigesSchwimmendesSaeugetierAusStreichelZoo(Gehege oldGehege, IGiftig giftigesTier) {

oldGehege.removeAnimal(giftigesTier);

Aquarium<ISchwimmend> a = new Aquarium();
a.add(giftigesTier);

return a;
}

Das Aquarium braucht keinen Generic da das Aquarium nur die List besitzt, welche schon den Generic ISchwimmend besitzt.
Das Gleiche auch mit dem Gehege =)

 

[Deamon1337]

Das Aquarium braucht keinen Generic da das Aquarium nur die List besitzt, welche schon den Generic ISchwimmend besitzt.
Das Gleiche auch mit dem Gehege =)
Wenn du das unbedingt mit Generics machen möchtest, dann mach folgendes.

public class Aquarium<ISchwimmend> extends ArrayList<ISchwimmend> {}

In der Aufgabe steht ja es sollen generic Klassen sein daher denke ich ich hab da keine Wahl

 

[thecain]

Was macht ihr denn da?

public class Gehege <T> {

    private List<T> tiere;
    public Gehege() {
        this.tiere = new ArrayList<>();
    }

    public void add(T tier) {
        tiere.add(tier);
    }

    public static <T extends Giftig> Gehege<T> entferneGiftigesTierAusStreichelzoo(T tier) {
        Gehege<T> gehege = new Gehege<>();
        gehege.add(tier);
        return gehege;
    }
}

public class Aquarium<T extends Schwimmend> {
    public Aquarium () {
        List<T> list = new ArrayList<>();
    }

    public void add(T tier) {
        list.add(tier);
    }
}

Sorry für soviel Lösung vorwegnehmen, aber da oben steht zuviel komischer Code...

Die Interfaces Schwimmend und Giftig kann man sich dazudenken.

 

[Deamon1337]

Wie würde denn da der Test für aussehen in aufgabenteil "e"? Das is alles so abstrakt ohne das mal mit ERgebnis zu sehen

 

[thecain]

Ein neues Gehege Objekt anlegen.
Ein neues Tier Objekt anlegen.
Das Tier zum Gehege hinzufügen

 

[Deamon1337]

 abstract class Tier{
           
        }
        abstract class Säugetier extends Tier{
           
        }
        interface Giftig {
           
        }
        interface Schwimmend {
           
        }
        interface Kinderfreundlich {
           
        }
        public class Gehege <T> {

           private List<T> tiere;

           public Gehege() {
               this.tiere = new ArrayList<>();
           }

           public void add(T tier) {
               tiere.add(tier);
           }

        }
       public static <T extends Giftig> Gehege<T> entferneGiftigesTierAusStreichelzoo(T tier) {
           Gehege<T> gehege = new Gehege<>();
           gehege.add(tier);
           return gehege;
       } 

        public class Aquarium<T extends Schwimmend> {
            private List<T> list;
           public Aquarium () {
               this.list = new ArrayList<>();
           }

           public void add(T tier) {
               list.add(tier);
           }
        }

So hab das ganze jetzt mal so zusammen gebaut, allerdings sagt er mir da, dass "new Gehege<>();" keine enclosing instance of type ArrayIterator verfügbar ist. Was fehlt denn da noch?

 

[InfectedBytes]

Du hast die Klasse Gehege innerhalb der Klasse Tier geschrieben.
Entweder Gehege in eine eigene Datei legen oder:

public static class Gehege { ...