Dynamisch getypte Klasseninstanz?

[tuxedo]

Hallo,

hab ein kleines Problem. Ich hab eine Methode deren Argument unter anderem eine Klasse ist.

In der Methode möchte ich die Klasse benutzen um eine typisierte Instanz einer Hilfsklasse zu erzeugen. Nur irgendwie bin ich zu doof. Kann mich mal einer in die richtige Richtung weisen? Oder geht das gar nicht?

Exemplarisch hier mal die Methode, aufs kleinste reduziert:

    public void create(Class<?> type)  {

        // ....                
        MyService<type> service= new MyService<type>();
        // ....

    }

Any ideas?

 

[SlaterB]

public class Test {
    public static void main(String[] args)   {
        MyService<Double> m;
        m = create(); // funktioniert
        m = create(Double.class);  // funktioniert
        doit(m); // sowieso
        doit(create()); // funktioniert leider nicht
        doit(create(Double.class));  // funktioniert
    }
    static void doit(MyService<Double> service)  { }

    static <T extends Number>MyService<T> create(Class<T> c) {
        return new MyService<T>();
    }
    static <T extends Number>MyService<T> create() {
        return new MyService(); // evtl. suppressWarning nötig, aber ist ok
    }
}
class MyService<T extends Number> {}

 

[Marco13]

Mit

    static <T extends Number> void doit(MyService<T> service)  { }

funktioniert (oder zumindest: compiliert ) auch [c]doit(create());[/c]

 

[tuxedo]

Okay, auf mein Beispiel bezogen wäre das dann also

 public <T> MyService<T> create(Class<T> type)  {

        // ....                
        MyService<T> service= new MyService<T>();
        // ....
        return service;
    }

Gut, das frisst der Compiler.

Das zurückgegebene service Objekt sollte nun getyped sein.
In diesem Service-Objekt gibts nun Methoden die den Type verwenden sollen:

public void myMethod(T something) {
        // ....
}

Ich hätte jetzt erwartet dass ich da nur den Typ reinstecken darf, mit dem ich die Klasse getyped habe. Aber ich kann da alles reinstecken und der compiler nimmt's mir ab ???:L

 

[SlaterB]

ohne Code (komplett ohne wichtige ... mit main-Methode) nimmt dir Compiler SlaterB dafür gar nix ab

 

[tuxedo]

public class TestGenericType {
    
    static class TestObject {
        public String msg;
        public int i;

        @Override
        public String toString() {
            return msg+"-"+i;
        }

    }

    static class TypedClass<T> {

        private T myT;

        public void myTypedMethod(T typedObject) {
            System.out.println("myTypedMethod argument: "+typedObject.getClass().getName());
            myT = typedObject;
        }

    }

    public static <T> TypedClass<T> createTypedObject(Class<T> type) {
        return new TypedClass<T>();
    }

    public static void main(String[] args) {

        TypedClass myTypedObject = createTypedObject(TestObject.class);

        TestObject tm = new TestObject();
        tm.i=1234;
        tm.msg="HelloWorld";

        myTypedObject.myTypedMethod(new String("Hallo Welt")); // warum geht das?
        myTypedObject.myTypedMethod(tm); // nur das hier sollte gehen



    }

}

Hab schon ne dumpfe vermutung warum das nicht geht ...
Muss das aber erst noch testen.

- Alex

[update]

Ich glaub das Stichwort heisst type erasure?!

Hatte in meiner Anwendung ganz übersehen das erzeugte Service-Objekt mit nem Type zu versehen. Ich hatte zwar den Type beim erzeugen angegeben, aber die Membervariable war nicht getyped. Ergo konnte ich alles reinfüttern.

- Alex

 

[SlaterB]

deine Vermutung vorweggenommen:

> TypedClass myTypedObject = createTypedObject(TestObject.class);

myTypedObject ist nicht typisiert,
du müßtest
TypedClass<TestObject> myTypedObject = ..
schreiben