# extends array[]



## eisenhauer (7. Jul 2009)

Hallo, 

möchte euch wieder mal um Hilfe bitte:

Ich habe eine Klasse namens flasche die, die Werte Füllmenge, Kosten,... speichert.
Die verschiedenen Flaschen sollen in einer Liste verwaltet werden, also mach ich eine neue Klasse die extends List<flasche> und eine ArrayList<flasche> beinhaltet der ich dann halt Flaschen hinzufuegen kann.

So weit so klar. Jetzt hab ich aber den spezial Fall, dass ich in einer Liste immer nur 5 Flaschen speichern möchte => hab mir gedacht in diesem Fall vl ein Array mit der Größe 4 vom Datentyp flasche zu erzeugen.

Meine Frage ist jetzt: wie lautet nun mein extends ?? extends flasche[] ??
Hab schon einiges probiert, aber noch nichts passendes gefunden.

Danke schon jetzt für eure Antworten!

martin


----------



## Schandro (7. Jul 2009)

> also mach ich eine neue Klasse die extends List<flasche> und eine ArrayList<flasche> beinhaltet der ich dann halt Flaschen hinzufuegen kann.


Das heisst, deine Klasse HAT eine ArrayList als Membervariable und IST eine List. Also gibts zwei Listen wenn du ne Instanz dieser Klasse erstellst...



> Meine Frage ist jetzt: wie lautet nun mein extends ?? extends flasche[] ??


Nein.

Entweder du überschreibst alle add-Methoden der Liste (wenn deine Klasse eine (Array-)List IST), oder du stellst ein paar Proxy-Methoden zur Kommunikation von außerhalb mit der Liste des Objectes bereit (wenn deine Klasse eine List HAT). In diesen Proxy-Methoden kannste dann auch ein paar if-Abfragen reinpacken.
(Natürlich könntest du statt der Liste auch nen Array benutzen, da es ja anscheinend eine feste Anzahl an maximalen Elementen hat)

PS: Welche List ist mit "extends  List<flasche>" gemeint? Die java.util.List ist ein Interface, und die java.awt.List nimmt keine generics an.


----------



## eisenhauer (9. Jul 2009)

Hallo, also ich werde zum allgemeinen Verständnis mal bisschen Quellcode dazugeben (hoffe damit von meiner Unwissenheit abzulenken, die ich benötigen würde um die obere Antwort zu verstehen  ):

Classe Schueler (statt Flasche):
[JAVA=42]
public class Schueler
{
  int knr;
  String nachname;
  public Schueler(int knr, String nachname)  {    
    this.knr = knr;
    this.nachname = nachname;
  }
  public int getKnr()  {
    return knr;
  }
  public String getNachname()  {
    return nachname;
  }
}
[/code]
ist natürlich keine Hexerei, und jetzt die Classe die die Schüler in einer Liste verwaltet:
Classe SchuelerClasse:
[JAVA=42]
public class Schulklasse extends AbstractListModel
{
  private final LinkedList<Schueler> schuelerListe =    new ArrayList<Schueler>();

  public Schulklasse()  {  }

  public boolean add(Schueler e)  {
     schuelerListe.add(e);
  }

  public Schueler remove(int index)  {
    schuelerListe.remove(index);
  }

  public Schueler get(int index)  {
    return schueler.get(index);
  }
}
[/code]

Alles keine große Sache... Hätte von euch jetzt gern gewusst ob ich meinem Fall, wo ich maximal 4 Eintragungen in meiner Liste haben möchte, besser:
a) bei der Liste bleibe und bei jedem Eintrag eine Kontrolle machen ob wohl nichts überschritten wird
b) ein Feld von Datentyp Schueler nehme und es von vornherein mit Laenge 3 deklariere. Wie würde in diesem Fall mein extends auschaunen??


----------



## SchonWiederFred (10. Jul 2009)

eisenhauer hat gesagt.:


> b) ein Feld von Datentyp Schueler nehme und es von vornherein mit Laenge 3 deklariere.


Wieso auf einemal 3 statt 4?


----------



## Michael... (10. Jul 2009)

eisenhauer hat gesagt.:


> [JAVA=42]
> public class Schulklasse extends AbstractListModel[/code]


Wieso extends AbstractModel? Du nutzt doch garnichts von dieser Klasse



eisenhauer hat gesagt.:


> Alles keine große Sache... Hätte von euch jetzt gern gewusst ob ich meinem Fall, wo ich maximal 4 Eintragungen in meiner Liste haben möchte, besser:
> a) bei der Liste bleibe und bei jedem Eintrag eine Kontrolle machen ob wohl nichts überschritten wird
> b) ein Feld von Datentyp Schueler nehme und es von vornherein mit Laenge 3 deklariere. Wie würde in diesem Fall mein extends auschaunen??


Ich würde Variante a bevorzugen und erweitern brauchst Du gar nichts, da Du ja von der erweiterten Klasse nichts nutzt (s.o)


----------



## Civilazi (10. Jul 2009)

SchonWiederFred hat gesagt.:


> Wieso auf einemal 3 statt 4?



Weder bei einer Länge von 3, noch von 4 passen 5 Schüler in deine Liste :autsch:

Zur Sache: Deine Schulklasse braucht keine Liste zu sein (eine Klasse ist ja auch nicht nur eine Liste von Schülern oder?), sie kann gern eine haben und ein paar Methoden zum Hinzufügen / Entfernen / ... eines Schülers anbieten. So würde ich das machen.


----------



## khaputt (10. Jul 2009)

```
public class MyList<E> extends ArrayList<E> {

  @Override
  public boolean add(E aO) {
    if (size() < 3) {
      return super.add(aO);
    }
    System.out.println("Max Anzahl erreicht..." + aO);
    return false;
  }

  public static void main(String[] args) {
    List<String> list = new MyList<String>();
    list.add("Nummer 1");
    list.add("Nummer 2");
    list.add("Nummer 3");
    list.add("Nummer 4");
  }
}
```


----------



## ARadauer (10. Jul 2009)

hab mir den Thread jetzt nicht durchgelesen... aber meine meinung: Vererbung wird überbewertet.. Aggregation und Komposition ist Vererbung oft vorzuziehen...

Wenn ich zb eine Klasse habe die eine menge von Objekten darstellt, Schulklasse hat Schüler... ich würde nie die Schulklasse von List erben lassen damit ich die Schüler drin verwalten kann, sondern ich würde einfach einen Liste mit Schülern der Schulklasse als Member geben...


----------



## Ark (10. Jul 2009)

Ich sehe das genauso wie ARadauer (und habe den Thread genausowenig gelesen ). Wenn ich schon Vererbung einsetze, dann mit ausschließlich abstrakten Superklassen. Praktisch alle konkreten Klassen (mit oder ohne viel Vererbung) sind bei mir final, und bisher hat dies auch nicht zu Problemen geführt.

Ark


----------

