Beliebig viele Typen bei Generics

[Marco13]

Hi

Ich bräuchte eine Möglichkeit, einer Klasse beliebig viele Typen mitzugeben. Die sollten leicht erweiterbar sein, aber (trotzdem) zur Compilezeit überprüft werden können. Sinngemäß also sowas wie

class Foo<Type1, Type2 ... TypeN>
{
    Type1 getType1() { ... }
    Type2 getType2() { ... }
    ...
    TypeN getTypeN() { ... }
}

Eben mal mit einem Type, oder mal mit 5 Typen...


In meiner schier unendlichen Kreativität (sprich: Verzweiflung :? ) bin ich da bisher nur auf sowas gekommen wie

// This actually works, but ... well...
interface TypeSequence<Type, TypeSequenceType extends TypeSequence>
{
    Type getType();
    TypeSequenceType getSubTypes();
}

class TypeSequence1 implements TypeSequence<String, TypeSequence<Integer, TypeSequence<Boolean, TypeSequence>>>
{
    public String getType() { return "foo"; }
    public TypeSequence<Integer, TypeSequence<Boolean, TypeSequence>> getSubTypes() { return new TypeSequence2(); }
}

class TypeSequence2 implements TypeSequence<Integer, TypeSequence<Boolean, TypeSequence>>
{
    public Integer getType() { return new Integer(123); }
    public TypeSequence<Boolean, TypeSequence> getSubTypes() { return new TypeSequence3(); }
}

class TypeSequence3 implements TypeSequence<Boolean, TypeSequence>
{
    public Boolean getType() { return new Boolean(true); }
    public TypeSequence<Type, TypeSequence> getSubTypes() { return null; }
}

Rekursiv getypte Generics Yo. Das funktioniert zwar, aber ... :roll: ja.... Hab ich gerade ein Brett vorm Kopf, oder ist das wirklich nicht so einfach? Hat jemand eine Idee dazu?

bye

 

[tuxedo]

Vielleicht ist das deshalb nicht so einfach, weil es nach einem "von hinten durch den Brustkorb mit dem Finger ins Auge"-Programmierstil aussieht und man sowas einfach anders lösen sollte??

- Alex

 

[Evil-Devil]

Warum sollte man sowas haben wollen? Das einzige was Generics vermissen lassen sind die Primären Datentypen als Typ anzugeben.

 

[Marco13]

Gerne. Wie?

Die Anforderung ist (nochmal genauer) : Ich habe eine Klasse, die der Verwaltung von verschiedenen Objekten dienen soll. Die Typen der Objekte und die Anzahl der Objekte ist mir nicht bekannt. Trotzdem soll das ganze typsicher sein. Es soll also jemand eine Implementierung dieser Klasse erstellen können, die z.B. so aussieht

class MyContainer implements Container<String>
{
    String getElement(...) { ... }
}

Jemand anderes soll eine implementierung erstellen können, die so aussieht

class MyOtherContainer implements Container<Float, Integer, Boolean>
{
    Float getElement(...) { ... }
    Integer getElement(...) { ... }
    Boolean getElement(...) { ... }
}

(dass die Methoden "eigentlich" unerschiedlich heißen müßten, ist klar...)

Es GIBT einfach keine Möglichkeit, mehrere Typparameter anzugeben (abgesehen von dieser mega-tricky rekursiven Variante). Aber vielleicht hat ja jemand eine Idee, wie man dem gewünschten Verhalten so nahe wie möglich kommt. Wenn nicht, muss ich halt mal sehen, ob man irgendwas mit einer Map<Class, ElementType> oder so machen kann, aber um irgendwelche "brutalen" casts (und damit den Bruch der Anforderung, Compilezeit-Typsicherheit zu haben) käme man mit keiner Alternativlösung, die ich mir jetzt vorstellen könnte, herum... :?