Java中的泛型继承

我有一个抽象类

AbstractEvent

和一些扩展它的“真实”类。我想用一个方法

进程（？事件）

创建一个抽象类

AbstractListener

，这样扩展

AbstractListener

的非抽象类至少需要一个方法来接受扩展

AbstractEvent

的类。可能吗

public abstract class AbstractListener {
    public abstract void process(AbstractEvent event...);
}

试试看。它创建了一个名为AbstractListener的抽象类，该类有一个接受一个或多个抽象事件的抽象方法。如果您必须始终参加一个活动，您可以尝试这样的活动（尽管我不记得这在技术上是否可行）：

---

希望这会有所帮助。

您已经获得了所需机械装置的名称-

首先，将您的事件分类为：

abstract class AbstractEvent {
    // Insert fields/methods common for all events here
}

没什么奇怪的。接下来，创建一个参数化侦听器类/接口，并为其类型参数指定事件对象类的上限：

interface Listener<T extends AbstractEvent> {
    void process(T event);
}

这应该是你所需要的。继续并实现您的侦听器类：

class LoggingPonyListener implements Listener<PonyEvent> {
    @Override
    public void process(PonyEvent event){
        System.out.println("Pony event occurred: " + event);
    }
}

这应该是可重用的，对吗？不，这样不行：

EventDispatcher<PonyEvent> dispatcher = new EventDispatcher<PonyEvent>();
dispatcher.add(new DebugListener("pony event"));

这将为您提供您所追求的行为：就像您可以将

PonyEvent

发送到

侦听器的
过程
方法一样（因为
PonyEvent
是
抽象事件
），现在，您可以使用使用类型参数化的事件调度程序类来触发使用其超类型之一参数化的侦听器

class LoggingPonyListener implements Listener<PonyEvent> {
    @Override
    public void process(PonyEvent event){
        System.out.println("Pony event occurred: " + event);
    }
}

class EventDispatcher<T extends AbstractEvent> {
    private final List<Listener<T>> listeners =
        new CopyOnWriteArrayList<Listener<T>>();
    public void addListener(Listener<T> listener) {
        listeners.add(listener);
    }
    public void dispatchEvent(T event) {
        for (Listener<T> listener : listeners) 
            listener.process(event);
    }

}

EventDispatcher<PonyEvent> dispatcher = new EventDispatcher<PonyEvent>();
dispatcher.add(new LoggingPonyListener());
dispatcher.dispatchEvent(new PonyEvent());

class DebugListener implements Listener<AbstractEvent> {
    private final String msg;
    public DebugListener(String msg) { this.msg = msg; }
    @Override
    public void process(AbstractEvent event){
        System.out.println(msg);
    }
}

EventDispatcher<PonyEvent> dispatcher = new EventDispatcher<PonyEvent>();
dispatcher.add(new DebugListener("pony event"));

class EventDispatcher<T extends AbstractEvent> {
    private final List<Listener<? super T>> listeners =
        new CopyOnWriteArrayList<Listener<? super T>>();
    public void addListener(Listener<? super T> listener) {
        listeners.add(listener);
    }
    public void dispatchEvent(T event) {
        for (Listener<? super T> listener : listeners) 
            listener.process(event);
    }

}