Java generics: capture kann nicht angewendet werden, - Objekt

Ich habe code, der eine Map von (Message)Handler. Ich bin versucht zu machen, den Handler generified (wie gesehen, durch die interface-Prozedur). Ohne Generika Handler, die alle brauchen, um zu Gießen aus dem Objekt der jeweiligen Klasse, das wäre schön, zu vermeiden (aber alles funktioniert). Für jede Nachrichtenklasse (Foo unten) ich habe eine handler-Klasse.

Wie kann ich eine Karte von jeder Art von Klasse, um jede Art von Handler und Holen/rufen Sie "nur" mit einem Object? (die parameter handleMessage(Object) können nicht eingeschränkt werden)

Sehen MWE unten.

import java.util.*;
public class Logic
{   
    Map<Class<?>, Handler<?>> handlers = new HashMap<Class<?>, Handler<?>>();

    public void run()
    {   
        handlers.put(Foo.class, new FooHandler());
    }   

    public void handleMessage(Object msg)
    {   
        Handler<?> handler = handlers.get(msg.getClass());
        if (handler != null) {
            handler.execute(msg);
        }   
    }   

    private interface Handler<T>
    {   
        public void execute(T msg);
    }   

    private class FooHandler implements Handler<Foo>
    {   
        public void execute(Foo msg) {}
    }   

    private class Foo {}
}

Dieser code erzeugt:

Logik.java:16: execute(capture#x ?) in der Logik.Handler kann nicht angewendet werden, > to (java.lang.Objekt)
handler.ausführen(msg);

Wie kann das repariert werden, zu arbeiten, während immer noch halten die Handler-Schnittstelle generischen?

InformationsquelleAutor Jonas WS | 2011-11-29
  1. 8

    Kann man nicht definieren, die Beziehung zwischen Schlüssel und Wert in einem Feld, aber Sie können accessor Methoden zu erzwingen, sofern nur diese Methoden verwendet werden, um auf die Karte.

    private final Map<Class, Handler> handlers = new HashMap<Class, Handler>();

public <T> void addHandler(Class<T> clazz, Handler<T> handler) {
    handlers.put(clazz, handler);
}

@SuppressWarnings("unchecked")
public <T> Handler<T> getHandler(Class<T> clazz) {
    return (Handler<T>) handlers.get(clazz);
}

@SuppressWarnings("unchecked")
public <T> Handler<T> getHandlerFor(T t) {
    return getHandler((Class<T>) t.getClass());
}

public void run()    {
    addHandler(Foo.class, new FooHandler());
}

public <T> void handleMessage(T msg) {
    Handler<T> handler = getHandlerFor(msg);
    if (handler != null) {
        handler.execute(msg);
    }
}
    • Ihre Antwort führte mich zu dem Typ sicher heterogenen Containern, Beziehungen für die Generika-Typen und so weiter! Ich bin ein bisschen enttäuscht, dass es unmöglich ist ohne wrapper-Methoden und @SuppressWarnings jedoch :<. Immer noch, es funktioniert jetzt, aber ich weiß nicht, ob es sich lohnt, den Aufwand der Einführung von Generika hier.
    • Das problem ist, wie kompliziert willst du die generische syntax zu sein. 😉 Ihr überprüfen Aufrufe addHandler, hetHandler und getHandlerFor korrekt sind.
    InformationsquelleAutor Peter Lawrey
  2. 2

    Das problem ist, dass execute() nimmt einen bestimmten parameter-Typ, dass ist genauer als Object.

    Jedoch in Ihrer handleMessage() Methode, die der compiler nicht weiß, welche Art der parameter. Angenommen, ein Fall, wo FooHandler ist registriert für Klasse Bar (die möglich wäre).

    In diesem Zusammenhang handler.execute(msg); würde tatsächlich dazu führen FooHandler#execute(Foo) genannt wird, mit einem Bar argument, das Ergebnis wäre ein ClassCastException (es sei denn Bar extends Foo). Damit der compiler weigert sich zu kompilieren, der code.

    • Guter Punkt da!
    InformationsquelleAutor Thomas
  3. 1

    Andere Antwort, die war nicht hier, aber es sollten - entfernen Sie alle generics-syntax (d.h. entfernen Sie alle <?>). Dann wird der parser wieder JDK1.4 syntax und das wird alles gut funktionieren.

    InformationsquelleAutor Ryan Shillington
Schreibe einen Kommentar