Generic Methoden die sich aufrufen wollen nicht immer

[thE_29]

Ahoi!
Warum geht das hier nicht:

  private <T extends String> void testGeneric(Vector<T> data, Class<T> clazz)
  {
    
  }
  
  private <T extends String> void callGeneric(Vector<T> data)
  {
    testGeneric(data, String.class);
  }

Aber wenn ich bei testGeneric das hintere <T> bei Class weglasse, geht es problemlos!

  private <T extends String> void testGeneric(Vector<T> data, Class clazz)
  {
    
  }
  
  private <T extends String> void callGeneric(Vector<T> data)
  {
    testGeneric(data, String.class);
  }

Es geht darum, dass ich bei der testGeneric gerne ein clazz.newInstance machen will ohne es auf T zu casten (jaja ist ja nicht so schwer, aber mir gehts ums Prinzip).

mfg

PS.: Editiert mal einer was mit Java Tags, da ist nachher alles kaputt 🙁

 

[thE_29]

Lustig ist ja, diese 2 Dinge funktionieren!

  private <T extends String> void callGeneric(Vector<T> data)
  {
    testGeneric(null, String.class);
    testGeneric(data, (Class<T>)String.class);
  }

 

[0x7F800000]

Warum geht das hier nicht:

  private <T extends String> void testGeneric(Vector<T> data, Class<T> clazz)
  {
    //"T extends String" ist irgendwie sinnfrei, weil string final class ist o_O??
  }
  
  private <T extends String> void callGeneric(Vector<T> data)
  {
    testGeneric(data, String.class);
    //trotzdem, mal angenommen du hast SubString extends String abgeleitet,
    //dann wäre callGeneric(new Vector<SubString>()) möglich
    //dann wäre data vom typ Vector<SubString>
    //dann würde das T bei testGeneric für SubString stehen
    //dann wäre String.class falsch, weil String.class vom Typ Class<String> ist
    //obwohl Class<SubString> erwartet wird, weil ja T=SubString sein soll... 
  }

PS.: Editiert mal einer was mit Java Tags, da ist nachher alles kaputt 🙁

wer ist hier mod? ???:L

 

[0x7F800000]

Lustig ist ja, diese 2 Dinge funktionieren!

  private <T extends String> void callGeneric(Vector<T> data)
  {
    testGeneric(null, String.class); //hier kann es nicht zu widersprüchen kommen, weil das T aus dem zweiten argument bestimmt wird
    testGeneric(data, (Class<T>)String.class);//da hätte ich eigentlich "unchecked" warnung erwartet o_O?
  }

12

 

[SlaterB]

    private <T extends String>void testGeneric(Vector<? super T> data, Class<T> clazz)
    {

    }

    private void callGeneric(Vector<? super String> data)
    {
        testGeneric(data, String.class);
    }

edit: aber hilft vielleicht nicht viel, die genaue Bedeutung von super vergesse ich oft 😉

 

[Ebenius]

Ahoi!
Warum geht das hier nicht:

  private <T extends String> void testGeneric(Vector<T> data, Class<T> clazz)
  {
    
  }
  
  private <T extends String> void callGeneric(Vector<T> data)
  {
    testGeneric(data, String.class);
  }

Sehen wir mal davon ab, dass String final ist... Der Typ T muss natürlich als Parameter des Vector-Arguments und des Class-Arguments der gleiche sein. In Deinem Aufruf in Zeile 8 ist der Vector parametrisiert mit irgendwas das von String erbt, das Class-Argument ist aber genau vom Typ String. Wenn ich das Beispiel mal umbastele (auf eine Klasse die nicht final ist), dann machst Du in etwa das gleiche wie:

<T extends Number> void foo(List<T> list, Class<T> clazz) { }

void bar() {
  foo(new ArrayList<Integer>(), Number.class);
  foo(new ArrayList<Double>(), Number.class);
  foo(new ArrayList<Float>(), Number.class);
  foo(new ArrayList<Long>(), Number.class);
}

Alle Aufrufe von foo() aus bar() sind falsch, weil T sowohl genau Number als auch genau Integer (Double, Float, Long) sein will. Verstanden?

Ebenius

 

[thE_29]

String war ja nur als Bsp Klasse genommen 😉

Und ihr könnt ja sicher eure eigenen Beiträge editieren oder?


Achso mit dem super könnte man das machen. Naja, es geht halt mit beiden. Ich belasse es bei meinem cast 😉

 

[thE_29]

So, ich hänge das gleich hier rein!

Wieso geht das hier:

    Map<String, Hashtable<Integer, String>> testGen = new Hashtable<String, Hashtable<Integer, String>>();

Aber wenn ich das Stirng, Hashtable in String, Map ändere geht es nicht mehr?

    Map<String, Map<Integer, String>> testGen = new Hashtable<String, Hashtable<Integer, String>>();

Hashtable ist ja Interface und beim ersten geht es ja auch!

 

[SlaterB]

das habe ich doch gerade erklärt 😉 :
http://www.java-forum.org/java-basics-anfaenger-themen/82176-list-generics-und-eine-list.html

 

[thE_29]

Verstehe ich trotzdem nicht ganz (stehe auf dem Schlauch).

Ich gebe an das ich ein Interface MAP dort habe. Und die Klasse implementiert es ja auch, also warum geht das jetzt nicht (da mich dein List Bsp nur noch mehr verwirrt).

In deinem Bsp führt das ja zu einer ClassCastException weil du es zu einer ArrayList zurückcastest!
Ich will es ja wieder als MAP zurückhaben und nicht als Hashtable.

 

[SlaterB]

in eine Map<String, Map<Integer, String>>-map kann auch eine TreeMap einfügen,

falls das konkret dort hineingelegte Map-Objekt vom Typ Hashtable<String, Hashtable<Integer, String>>
auch noch irgendwo anders unter seinem richtigen Typ Hashtable<String, Hashtable<Integer, String>>
bekannt ist, dann kann man auf das Map-Objekt get() oder ähnlich aufrufen und eine Hashtable erwarten,

es kommt aber die einfügte TreeMap -> ClassCastException

lass das Beispiel aus dem anderen Thema ablaufen, ob List oder Map ist doch egal

> Ich will es ja wieder als MAP zurückhaben und nicht als Hashtable.

dann erzeuge doch nicht ein Objekt mit Hashtable, sondern mit Map,
z.B.
new Hashtable<String, Map<Integer, String>>();

 

[thE_29]

So, bin nur noch verwirrt 😉
Kannste da mal ein Bsp angeben mit meiner Angabe?

Wenigstens geht ja das hier:

  private Map<String, Map<Integer, List<Long>>> tempLists1 = new Hashtable<String, Map<Integer, List<Long>>>();

Edit: Jo, auf das bin ich auch schon draufgekommen! Wußte nicht, dass man dort hinten auch ein Interface angeben kann 🙂

 

[SlaterB]

so ist es auch korrekt

-----

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        Map<String, Map<Integer, List<Long>>> map;

        Map<String, Map<Integer, List<Long>>> map1 = new Hashtable<String, Map<Integer, List<Long>>>();
        map = map1;
        map.put("", new TreeMap<Integer, List<Long>>());

        Map<Integer, List<Long>> valueMap1 = map1.values().iterator().next(); 
        // man kann gar nicht Hashtable auslesen, alles supi

        // ----------

        Map<String, Hashtable<Integer, List<Long>>> map2 = new Hashtable<String, Hashtable<Integer, List<Long>>>();
        map = (Map)map2; // Check ausschalten
        map.put("", new TreeMap<Integer, List<Long>>());

        Hashtable<Integer, List<Long>> valueMap2 = map2.values().iterator().next(); // ClassCastException

    }
}