Generische Methoden

[John_Murdoch_ohne_login]

Hallo Leute,

ich habe nur eine kurze Frage bez generischen Methoden.

Folgendes Beispiel:

class genClass
{
  public <X> X tuwas()
  {
    X x = null;

    return (X) Integer.valueOf(1);
  }
}

..

  public static void main(String[] args)
  {
    genClass x = new genClass();
    System.out.println(x.<Integer> tuwas());
  }
..

Zeile 6 + 8 sind Spielereien/Experimente und haben nicht viel miteinander zu tun.

Ich übergebe der Methode den Typen Integer (als generischen Typen).
Jedoch kann ich das Objekt x in der Methode nicht wie ein Integer benutzen,
es sei denn ich caste explizit nach Integer (könnte mir mit instanceof abhelfen).

Frage:
Komme ich auch ohne explizites casting an die Methoden des Integer-Typen bei Objekt x ran?

Habe ich etwas übersehen oder ist das halt der Nachteil des generischen/allgemeinen ?

 

[byte]

Der Typ steht zur Laufzeit nicht mehr zur Verfügung. Es geht also nur umständlich per Reflection:

Class clazz = getClass();
    while (!(clazz.getGenericSuperclass() instanceof ParameterizedType)) {
        clazz = clazz.getSuperclass();
    }
    	
    Class<T> genericClass = (Class<T>) ((ParameterizedType) clazz.getGenericSuperclass()).getActualTypeArguments()[0];

 

[SlaterB]

sehr schlecht, in beiden Methoden das x x zu nennen,
so weiß man nicht, welches x du meinst,

> in der Methode

auch hier hättest du zwischen main-Methode und tuwas-Methode unterscheiden können

--------

in der main-Methode ist das zurückgegebene Objekt ein Integer,
ohne Cast alles möglich

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        Integer y = Test.<Integer>tuwas();
        System.out.println(y.doubleValue());
    }

    public static <X>X tuwas()
    {
        X x = null;
        return (X)Integer.valueOf(1);
    }
}

-------


in tuWas() weißt du nicht welcher Typ X ist, wieso sollte das ein Integer sein?
was machst du wenn die Operation mit String aufgerufen wird?
gut dann wird
return (X) Integer.valueOf(1);
eine ClassCastException werfen, aber das ist ja kein Grund, warum der Compiler für X immer Integer annehmen sollte

 

[tfa]

<X extends Integer>

Ist hier natürlich Blödsinn, da könntest du gleich Integer schreiben statt <X>. Aber es ist ja nur ein Beispiel.

 

[Guest]

in tuWas() weißt du nicht welcher Typ X ist, wieso sollte das ein Integer sein?
was machst du wenn die Operation mit String aufgerufen wird?
gut dann wird
return (X) Integer.valueOf(1);
eine ClassCastException werfen, aber das ist ja kein Grund, warum der Compiler für X immer Integer annehmen sollte

danke für die antwort auf den main-bereich.

aber bez der tuwas-methode:
ich hab das mit

return (X) Integer.valueOf(1);

nur eingesetzt damit der compiler vorerst nicht meckert.


Meine Frage ist, was bringen mir generische methoden genau? welche methoden stehen mir für die generischen typen zur verfügung bzw wie komme ich dort dran?

ich habe das gefühl dass generics nur bei collections was taugen?


public <X> X tuwas()
{
X x = 1;

//wie mache ich hier etwas mit x? in eclipse stehen mir nur die object-methoden zur verfügung

return x;
}



PS:das mit dem verwirrenden x haste recht, hab ich auf die schnelle gemacht und beim pasten nicht gemerkt.

 

[SlaterB]

tja, du kannst in der Operation wenig machen, aber das liegt an dir,
was gibst du dem Compiler auch für Infos?
"hier kommt eine Operation mit dem unbekannten Typ X"
na toll,
dazu kann man nix machen, weil das eben eine sehr geringe Grundlage ist,

bei Collections oder auch EigeneKlassen<X> macht das Sinn oder bei X extends Grundtyp und vorhandenen allgemeinen Operationen darin,
sonst wenig, stimmt

 

[John_Murdoch_ohne_login]

ok dank dir SlaterB!