✔ Klasse ohne feste Anzahl an Argumenten? und "unsave operations" vermeiden.

[Nobody]

Hallo nochmal, ich würd gern ne Klasse erstellen welche eigentlich nur als "Container" für verschiedene datenTypen (eigene Klassen) dienen soll.

Das "Träger-Object" stellt hier eine ArrayList dar wo ich einfach nur am Ende des Indexes eine Instanz einer von mir erstellten Klasse anhängen möchte, daher auch ArrayList (laut mehreren aussagen die ich las dafür wohl am besten geignet)

Nun hab ich hierzu zwei Fragen:

1) kann ich eine Klasse ohne "feste Anzahl" an Argumenten die ich im new myClass(args) mitliefere erstellen? ich hab schon öfters gesehen das eine Klasse mehrere Constructor hat mit Unterschiedlicher Anzahl an Argumenten aber noch nichts ohne "feste Anzahl" an Args.

2) die ArrayList soll ja Instanzen unterschiedlicher Klassen enthalten, (es sind 4 selbst erstellte Klassen sowie ein String und eine int), da ich schonmal das Spielchen hatte das mein Source zwar compiliert wurde aber ich die Meldung "contains unchecked or unsave...." hatte (was daran lag das ich die Key und Value pairs nicht typisiert hatte), nun die Frage wie vermeide ich bei unterschiedlichen datenTypen diese Fehlermeldung?

mfg

 

[zeja]

Wenn du eine Variable Anzahl an Argumenten zulassen willst kannst du varargs verwenden:

public MyClass(Object ... myArguments)

Dafür stehen die ...

Damit du keine Fehlermeldungen erhälst kannst du entweder
ArrayList<?> verwenden und damit sagen dass du nicht weißt was reinkommt oder du erstellt dir schöner einen Wrapper für deinen Datentypen die von einem gemeinsamen Interface erben welches du dann in der Liste angibst.

 

[Nobody]

Vielen Dank.

Das mit dem Interface hört sich schonmal recht Interessant an.

Ich nehme mal an, das ich dann alle Methoden der Klassen mit in das Interface Packe , also ohne den programatischen Inhalt der Methoden ansich nur die methoden definition mit ";" dahinter(ich weiss nicht wie sich das nennt) und das Interface dann einfach in den Klassen mittels "Implements" im constructor implementiere?

mfg

 

[Tim Bureck]

Es reicht bereits vollkommen das Interface zu erstellen, einen schönen Namen zu geben (Carryable für tragbar? ) und deine Klassen dies dann impelementieren zu lassen.

Da du allerdings String und Integer auch unterbringen willst, solltest du die Variante mit dem ? benutzen, da du von String und Integer keine Subklassen mehr ableiten kannst, um das Interface zu implementieren, weil sie final sind.

 

[zeja]

Sowas in der Art:

public interface MyWrapper {

    Object getMyObject();
    //Eventuell noch andere Operationen die du benötigst
}

public class MyStringWrapper {

    private final String theString;

   public MyStringWrapper(final String strg) {
       this.theString = strg;
   }

   public String getMyObject() {
       return this.theString;
   }

}

public class MyIntegerWrapper {

    private final int i;

   public MyIntegerWrapper (final int i) {
       this.i= i;
   }

   public String getMyObject() {
       return this.i;
   }

}

List<MyWrapper> lst = new ArrayList<MyWrapper>();
lst.put(new MyStringWrapper("einString"));
lst.put(new MyIntegerWrapper (5));

 

[Oliver Gierke]

Imho macht es Sinn, solche Wrapper zu typisieren, dann kann man sich mit einer generischen Factorymethode einfach typsichere Wrapper bauen ohne jedes Mal eine extra Subklasse bauen zu müssen.

public class Wrapper<T> {

  private T target;

  protected Wrapper(T target) {
    this.target = target;
  }

  public static <T> Wrapper<T> create(T target) {
    return new Wrapper<T>(target);
  }

  public T getTarget() {
    return target;
  }
}

Dann geht sowas:

Wrapper<String> wrapper = Wrapper.create("MyString");
String target = wrapper.getTarget();

// Geht nicht:
Wrapper<Integer> wrapper = Wrapper.create("MyString");

Die statische Methode sorgt quasi dafür, dass der Compiler den Methodenparameter mit dem Typ abgleicht, den der Rückgabewert zugewiesen wird. Sonst müsstest du immer folgendes schreiben:

Wrapper<String> wrapper = new Wrapper<String>("MyString");

3x String ist halt n bissl viel . In Java 7 wird es wohl eine verkürzte Form geben, die sowas ermöglicht:

Wrapper<String> wrapper = new Wrapper<>("MyString");

Gruß
Ollie

 

[Nobody]

Klasse,
vielen dank für die Code und Erklärung an Alle

mfg