Datentypen Zuweisungsproblem bei parametrisierten Typen mit/ohne Wildcards

[Fish]

Hallo zusammen,

ich habe ein kleines aber unschönes Problem mit der Zuweisung von parametrisierten Typen. Nehmen wir einmal an, ich hätte drei Interfaces:

interface Result {  }

interface Action<R extends Result> { }

interface ActionHandler<A extends Action<R>, R extends Result> { 
    R execute(A action);
}

Ein gegebenes Action Object verknüpfe ich über eine Annotation mit ihrem ActionHandler; seine einzige Methode gibt die Klasse des benötigten ActionHandlers zurück. Ich muss hier natürlich Wildcards verwenden, weil Annotationen ja nicht parametrisiert werden können!

@interface HandledBy {
     Class<? extends ActionHandler<? extends Action<? extends Result>, ? extends Result>> value();
}

Nicht perfekt (ich könnte zwei verschiedene Result-Objekte verwenden), aber soweit, so gut.

Merkwürdig wird es dann, wenn ich versuche, einen ActionHandler auszuführen. Dazu verwende ich folgende Methode, die in einer Klasse Dispatcher untergebracht ist; die Klasse selbst spielt keine Rolle.

public class Dispatcher {
      public <A extends Action<R>, R extends Result> R execute(A action) {
		// liest die Annotation von der Action aus, die uns verrät, mit welchem ActionHandler wir sie ausführen müssen!
		HandledBy handledBy = action.getClass().getAnnotation(HandledBy.class);

		R result = null;

		try {
			// Instanz des speziellen ActionHandlers erstellen
			ActionHandler<A, R> handler = handledBy.value().newInstance();

			// die Action mit ihrem eigenen ActionHandler ausführen und das Ergebnis einkassieren!
			result = handler.execute(action);		
		} // catch clauses omitted for brevity


		return result;
	}
}

Bei der Zuweisung im try Block bekomme ich dann eine Fehlermeldung die mir erzählt, die beiden Typen wären nicht kompatibel. Liegt dass daran, dass der Typ, der aus der Annotation kommt, Erasures enthält? Oder liegt es an etwas ganz anderem?

Über eure Hilfe würde ich mich sehr freuen!

Einen schönen Abend noch,
Goldi

 

[Marco13]

Was da aus der Annotation kommt enthält "irgendwelche" Typen. Das gleiche Problem tritt ja schon bei vieeel einfacheren Strukturen auf:

import java.util.*;

public class Dispatcher
{
    private List<? extends Number> getList() { return null; }

    private void method()
    {
        List<Float> list = getList();
    }
}

Man bekommt bei getList "irgendeine" List, die zwar Numbers enthält, aber man weiß nicht ob dort Integers oder (wie benötigt) Floats drin sind.

Es gibt da einige mehr oder weniger schöne ... "Workarunds", um das Problem abzuschwächen oder ggf. ganz zu lösen, aber das ist in diesem Fall schwierig, weil das Beispiel erstens ziemlich verschachtelt ist, und zweitens die Typinformation AFAIK nicht so ohne weiteres durch die Annotation geschleift werden kann. Vielleicht könnte man das lösen, indem man der Annotation noch Parameter (Class-Objekte) mitgibt, aber da müßte ich auch erst genauer schauen.

 

[Fish]

Lieber Marco,

vielen Dank zunächst für deine Hilfe! Deinem Einwand kann ich allerdings nicht ganz folgen:

Was da aus der Annotation kommt enthält "irgendwelche" Typen. [...] Vielleicht könnte man das lösen, indem man der Annotation noch Parameter (Class-Objekte) mitgibt, aber da müßte ich auch erst genauer schauen.

Ich bekomme doch aus der Annotation nicht irgendwelche Typen, sondern nur solche, die ActionHandler implementieren; der Parameter value() enthält ja genau diese Information, und ich bekomme auch einen Kompilerfehler, wenn ich der Annotation zum Beispiel einen String übergebe. Der einzige Unterschied ist lediglich, dass ich die Typendefinition einmal mit einer Generischen Variable "A" und einmal mit einer Wildcard deklariere. Ich dachte ja ursprünglich, dass es an der Vermengung der Typen läge, aber folgende Deklaration kompiliert:

List<? extends Number> list = new ArrayList<Long>();

Was habe ich übersehen?

Viele Grüße,
Goldi

Edit: Ich habe eine erste einfache Lösung gefunden (ist eigentlich schon peinlich):
[java=10]
handler = (ActionHandler<A, R>) handledBy.value().newInstance();
[/code]
Mit der erzwungenen Typenumwandlung kompiliert der Code einwandfrei und lässt sich auch korrekt ausführen! Ich wüsste allerdings trotzdem gerne, warum diese Umwandlung überhaupt nötig ist...

 

[SlaterB]

ich weiß nicht genau worum es dir geht, aber hier mal etwas was kompiliert

interface HandledBy {
    <A extends Action<R>, R extends Result>Class<ActionHandler<A, R>> value();
}
class Dispatcher {
    public <A extends Action<R>, R extends Result> R execute(A action) {
      HandledBy handledBy = null;
      R result = null;
      try {
          // Instanz des speziellen ActionHandlers erstellen
          Class<ActionHandler<A, R>> c = handledBy.value();
          ActionHandler<A, R> handler = c.newInstance();

          // die Action mit ihrem eigenen ActionHandler ausführen und das Ergebnis einkassieren!
          result = handler.execute(action);       
      }  catch (Exception e) {}
      return result;
  }
}

Zeile 10 + 11 kann man allerdings auch hier nicht zusammen schreiben

edit:
niemals generische Parameter casten, (ActionHandler) statt (ActionHandler<A, R>) macht exakt dasselbe