Datentypen Generics: Erste Berührungen

[MarvinsDepression]

Ich versuche mich erstmalig in Generics und finde zur folgenden Situation keine klare Antwort.
typeA und typeB erben von Object.
main() erhält von method_A() ein Array, dessen konkreter Datentyp erst zur Laufzeit bestimmt ist.
Um den Scope zu halten kann ich (im Beispiel) die Wertzuweisung nicht zusammen mit der Initialisierung von value erledigen, also erstmal Typ Object.
Am Ende der main() übergebe ich value an method_B(), die dann Elemente des Arrays mit Methoden von Object weiterverarbeitet..

<T> T[] method_A() {
    ...
    if (...) return typeA[];
    return typeB[];
}


<T> method_B(T[] value) {
    ...
    ... value[0].toString();
    ...
}


<T> main() {
    Objekt value = null;
    {
        ...
        value = method_A();
        ...
    }
    method_B( (T[]) value);
}

Funkionieren würde es, aber mir gefällt das irgendwie nicht. Ich fürchte, dass es mir den Code zur Laufzeit um die Ohren hauen kann.
Außerdem: Komme ich um das 'Object' in main() drumrum? Geht das auch ohne?

Also, wie geht sowas in schön und sicher?

 

[Robert Zenz]

Dein Code ergibt aber auch keinen Sinn, du verwendest generische Typen nur um auf Object zuzuweisen, das, um, tut nichts und bringt dir keinen Vorteil. Was genau hast du denn vor? Ist das eine Uebungsaufgabe?

 

[MarvinsDepression]

GedankenExperiment: Ist das vorstellbar? Ich weiß, dass ich gleich eine Referenz erhalte (z.B. in einer if-Anweisung, oder einer Schleife. Nur kenne ich den konkreten Typ nicht. Diese Referenz möchte ichspäter weiter reichen...
Klar will ich das Object nicht haben. Mir fällt nur nix ein, wie ich darauf verzichten kann.

 

[Robert Zenz]

Ach jetzt verstehe ich was du willst. Die Frage ist ob "A" und "B" etwas gemeinsam sein. Der Rueckgabewert von der Funktion muss der kleineste gemeinsame nenner von den beiden Typen sein.

Dennoch ergibt in deinem Fall es wenig Sinn dort einen generischen Typen einzusetzen, da kann man genauso gut direkt Object nehmen:

Object[] getData() {
    if (condition) {
        return new TypeA[];
    } else {
        return new TypeB[];
    }
}

void doSomething(Object[] data) {
    System.out.println(data[0].toString());
}

void main() {
    Object[] data = getData();
    doSomething(data);
}

Oder wenn du einen gemeinsame Grundtyp hast, zum Beispiel eine Schnittstelle auf welche du spezialisieren kannst:

Datending[] getData() {
    if (condition) {
        return new BesseresDatending[];
    } else {
        return new AnderesDatending[];
    }
}

void doSomething(Datending[] data) {
    System.out.println(data[0].toString());
}

void main() {
    Datending[] data = getData();
    doSomething(data);
}

In deinem Beispiel macht aber der Einsatz von generischen Typen einfach keinen Sinn.

 

[MarvinsDepression]

Ja, danke. Das verstehe ich. Bzgl. der Generics gehe ich dann wieder die Schulbank drücken (leise heul).

 

[Robert Zenz]

Also ein besseres Beispiel fuer generische Typen waere zum Beispiel das holen vom xten Objekt aus einem Array.

public <TYPE> getItem(TYPE[] types, int index) {
    return types[index];
}

BigDecimal bigDecimals = new BigDecimal[] { ... };
BigDecimal itemAtIndex = getItem(bigDecimals, index);

Random randoms = new Random[] { ... };
Random itemAtIndex = getItem(randoms, index);

Generische Typen verwendet man dann wenn man einen bestimmten Typen haben will, diesen aber zum Zeitpunkt des Code tippens aber nicht kennt. Primaer braucht man das dann wenn man einen Wert aus einer Funktion zurueckgeben will. Ein anderes gutes Beispiel ist einen List. Die haelt irgendwelche beliebigen Werte, aber wenn man get aufruft will man ja diesen Typen wieder haben mit welchem die Liste erstellt wurde, aber der Tipper von List kannte diese Typen ja nicht.

 

[Neumi5694]

Vor Generics war alles Object ... deshalb schwirren im originalen Java-Code auch so viele Arrays rum anstatt Listen, da man den Arrays den Typ mitgeben konnte, Listen aber nicht.

Selbst gelangte man auch in Versuchung, "nicht ganz sauber" zu arbeiten. Ich hatte z.B. in einer Liste abwechselnd verschiedene Typen (Wertepaare) drin und kam mir dabei ziemlich genial vor