Datentypen Generics: Exacten Typ ermitteln

[MattHHDE]

Hi
Ich glaub was ich will geht mit der momentanen Java Version nicht aber ich will dennoch mal nachfragen:
Folgender Code (nur ein kleiner Ausschnitt ):

public <T extends IIdentifiable<?>> T getKid(....)
            final Method mth = getClass().getMethod("getKid");
            final Class<?> retType = mth.getReturnType();
...

Ist es möglich den EXACTEN Type von T zu ermitteln? Also wenn z.B. IFoo von IIdentifiable ableitet ist es dann möglich herauszufinden ob T vom Typ IFoo ist?

retType.isAssignableFrom(IFoo.class)

funktioniert leider nicht und liefert nur IIdentifiable...

Bei 1.5 wars so das die Generischen Information zur Laufzeit nicht mehr da sind. Ich dachte aber eigentlich dass sich dies mit 1.6 geändert hätte?
Oder gibts andere Wege (außer ein cast nach T und dann jedes mal die Exception zu fangen...)

Danke
PS: Ich weiß das Reflection hier ne "doofe" Art ist daran zu kommen, mir viel nur nicht anderes ein.

 

[MattHHDE]

Öhhmmm
dass soll natürlich "Exakten" und "fiel" heißen... :-/

 

[Marco13]

???:L Vermutlich nicht, aber es ist nicht 100% klar, was du willst. Mit retType.getClass() kriegt man die Klasse des Typs, retType selbst sollte schon der Typ sein, T ist zur Laufzeit nicht bekannt, außer wenn es eben gerade retType ist Poste vielleicht mal mehr (am besten compilierbaren) Code...

 

[MattHHDE]

OK, dies wird ein wenig länger:
Basis für Test Code:

    private interface IParent1 {

    }

    private interface IParent2 {

    }

    private interface IKidString extends IIdentifiable<String> {

    }

    private interface IKidInteger extends IIdentifiable<Integer> {

    }

    private interface IKidIntegerALittleDifferent extends IIdentifiable<Integer> {

    }

    private class KidString implements IKidString {
        private final String key;

        /**
         *
         */
        public KidString(final String key) {
            this.key = key;
        }

        /** {@inheritDoc} */
        @Override
        public String getKey() {
            return key;
        }

        /** {@inheritDoc} */
        @Override
        public String toString() {
            return "StringType " + key;
        }
    }

    private class KidInteger implements IKidInteger {
        private final Integer key;

        /**
         *
         */
        public KidInteger(final Integer key) {
            this.key = key;
        }

        /** {@inheritDoc} */
        @Override
        public Integer getKey() {
            return key;
        }

        /** {@inheritDoc} */
        @Override
        public String toString() {
            return "IntegerType " + key;
        }
    }

    private class KidIntegerALittleDifferent implements IKidIntegerALittleDifferent {
        private final Integer key;

        /**
         *
         */
        public KidIntegerALittleDifferent(final Integer key) {
            this.key = key;
        }

        /** {@inheritDoc} */
        @Override
        public Integer getKey() {
            return key;
        }

        /** {@inheritDoc} */
        @Override
        public String toString() {
            return "IntegerALittleDifferentType " + key;
        }
    }

Test Code:

@Test
    public void getKidMultipleType() {
        sut.registerParentKidRelationShip(IParent1.class, IKidString.class, IKidInteger.class,
            IKidIntegerALittleDifferent.class);
        final KidString kid1 = new KidString("A");
        final KidString kid2 = new KidString("B");
        final KidInteger kid3 = new KidInteger(1);
        final KidInteger kid4 = new KidInteger(2);
        final KidIntegerALittleDifferent kid5 = new KidIntegerALittleDifferent(2);

        sut.addParent(parent1);
        sut.addKid(parent1, kid1);
        sut.addKid(parent1, kid2);
        sut.addKid(parent1, kid3);
        sut.addKid(parent1, kid4);
        sut.addKid(parent1, kid5);

        final IKidString kid1Ret = sut.getKid(parent1, "A");
        Assert.assertSame(kid1, kid1Ret);

        final IKidString kid2Ret = sut.getKid(parent1, "B");
        Assert.assertSame(kid2, kid2Ret);

        final IKidInteger kid3Ret = sut.getKid(parent1, 1);
        Assert.assertSame(kid3, kid3Ret);

        final IKidInteger kid4Ret = sut.getKid(parent1, 2); //Problem: sut liefert IKidIntegerALittleDifferent obwohl es IKidInteger sein sollte. Das sut hat daher keine Ahnung ob der return type passt
        Assert.assertSame(kid4, kid4Ret);

        final IKidIntegerALittleDifferent kid5Ret = sut.getKid(parent1, 2);
        Assert.assertSame(kid5, kid5Ret);

    }

Hier der code der Implementierung (welcher nicht funktioniert)

    public <T extends IIdentifiable<?>> T getKid(final Object parent, final Object key) {
        if (key == null || parent == null) {
            throw new NullPointerException("Neither parent nor key may be null");
        }
        final Set<? extends IIdentifiable<?>> relationShip = parentToKidMap.get(parent);
        if (relationShip == null) {
            throw new RuntimeException("No Parent for " + parent);
        }

        try {
            final Method mth = getClass().getMethod("getKid", Object.class, Object.class);
            final Class<?> retType = mth.getReturnType();

            for (final IIdentifiable<?> iFace : relationShip) {
                if (retType.isAssignableFrom(iFace.getClass()) && iFace.getKey().equals(key)) {
                    return (T) iFace;
                }
            }
        } catch (final SecurityException e) {
            // Nothing to do
        } catch (final NoSuchMethodException e) {
            // Nothing to do
        }

        return null;
    }

Wenn ichs richtig verstanden hab ist das der Fall von "Reified Generics", oder? Und anscheinend ist wohl nicht klar ob das mit 1.7 gefixt wird...
Oder gibts andere Wege das zu coden (mit Ausnahme den Ret-Type als Parameter mitzugeben...)

 

[Noctarius]

Die Typeinformationen sind auch in 1.6 nur für Klassen abrufbar. Damit kannst du Generic-Typen von Klassen abfragen ([c]class Foo implements Comparable<Foo>[/c] aber nicht von Methodenparametern oder -returntypes.

Eine Möglichkeit wäre diese zur Compile-Time durch ein passendes Plugin (Ant / Maven) generieren und hinterlegen zu lassen. Dann könnte man diese auch wieder zugänglich machen.

Generell würde dein Code aber funktionieren, da einfach auf den aktuellen Type der Variable gecastet wird (wenn's nicht geht fliegt eine ClassCastException).

Foo foo = getKid(...);

Dies beinhaltet bei deinem Code einen expliziten Cast nach Foo.

Eine Alternative wäre:

public <T extends IdentifiedType> T getKid(..., Class<T> clazz)

 

[MattHHDE]

Danke!
Schade das Java das (noch?) nicht kann

 

[Noctarius]

Japp ich denke das auch an manchen Stellen. Ich bin mir jetzt nicht mal sicher ob das noch auf dem Java 7 oder schon auf dem Java 8 Plan steht.

Z.B. hätte ich hier gerne den generischen Typen: [c]public void foo(@Child List<Foo> foos)[/c] da es aber nicht geht habe ich mir z.B. so beholfen [c]public void foo(@Child(listType=Foo.class) List<Foo> foos)[/c].