java - 如何多次实现相同的接口(interface)，但使用不同的泛型？

Question

我有以下接口(interface)，我想在我的类中多次实现:

public interface EventListener<T extends Event>
{
    public void onEvent(T event);
}

现在，我希望能够通过以下方式实现这个接口(interface):

class Foo implements EventListener<LoginEvent>, EventListener<LogoutEvent>
{

    @Override
    public void onEvent(LoginEvent event)
    {

    }

    @Override
    public void onEvent(LogoutEvent event)
    {

    }
}

但是，这给了我错误:Duplicate class com.foo.EventListener 就行了:

class Foo implements EventListener<LoginEvent>, EventListener<LogoutEvent>

是否可以使用不同的泛型两次实现接口(interface)？如果没有，我能做的下一个最接近的事情是什么？

Answer 1

Is it possible to implement the interface twice with different generics

很遗憾，没有。您不能两次实现相同接口(interface)的原因是类型删除。编译器将处理类型参数和运行时 EventListener<X>只是一个 EventListener

---

If not, what's the next closest thing I can do to achieve what I'm trying to do here?

类型删除对我们有利。一旦你知道 EventListener<X>和 EventListener<Y>只是原始的EventListener在运行时，写一个 EventListener 比你想象的要容易。可以处理不同种类的Events . Bellow 是通过 IS-A 的解决方案测试 EventListener并正确处理 Login和 Logout通过简单委托(delegate)的事件:

@SuppressWarnings("rawtypes")
public class Foo implements EventListener {

    // Map delegation, but could be anything really
    private final Map<Class<? extends Event>, EventListener> listeners;

    // Concrete Listener for Login - could be anonymous
    private class LoginListener implements EventListener<LoginEvent> {
        public void onEvent(LoginEvent event) {
            System.out.println("Login");
        }
    }

    // Concrete Listener for Logout - could be anonymous        
    private class LogoutListener implements EventListener<LogoutEvent> {
        public void onEvent(LogoutEvent event) {
            System.out.println("Logout");
        }
    }

    public Foo() {
        @SuppressWarnings("rawtypes")
        Map<Class<? extends Event>, EventListener> temp  = new HashMap<>();
        // LoginEvents will be routed to LoginListener
        temp.put(LoginEvent.class, new LoginListener());
        // LogoutEvents will be routed to LoginListener
        temp.put(LogoutEvent.class, new LogoutListener());
        listeners = Collections.unmodifiableMap(temp);
    }

    @SuppressWarnings("unchecked")
    @Override
    public void onEvent(Event event) {
        // Maps make it easy to delegate, but again, this could be anything
        if (listeners.containsKey(event.getClass())) {
            listeners.get(event.getClass()).onEvent(event);
        } else {
            /* Screams if a unsupported event gets passed
             * Comment this line if you want to ignore
             * unsupported events
             */
            throw new IllegalArgumentException("Event not supported");
        }
    }

    public static void main(String[] args) {
        Foo foo = new Foo();
        System.out.println(foo instanceof EventListener); // true
        foo.onEvent(new LoginEvent()); // Login
        foo.onEvent(new LogoutEvent()); // Logout
    }
}

存在抑制警告是因为我们“滥用”类型删除并根据事件具体类型委托(delegate)给两个不同的事件监听器。我选择使用 HashMap和运行时事件 class ，但还有很多其他可能的实现方式。您可以使用建议的@user949300 之类的匿名内部类，可以包含getEventType Event 类上的鉴别器以了解每个事件的处理方式等。

通过对所有效果使用此代码，您将创建一个 EventListener能够处理两种事件。解决方法是 100% 独立的(无需公开内部 EventListeners )。

最后，还有一个问题可能会困扰您。在编译时 Foo类型实际上是 EventListener .现在，您无法控制的 API 方法可能需要参数化 EventListener年代:

public void addLoginListener(EventListener<LoginEvent> event) { // ...
// OR
public void addLogoutListener(EventListener<LogoutEvent> event) { // ...

同样，在运行时，这两种方法都处理原始 EventListener s。所以通过拥有 Foo实现一个原始接口(interface)，编译器很乐意让你摆脱一个类型安全警告(你可以忽略 @SuppressWarnings("unchecked") ):

eventSource.addLoginListener(foo); // works

虽然所有这些看起来令人生畏，但只要对自己重复一遍“编译器试图欺骗我(或拯救我)；没有 spoon <T>。一旦你为几个月试图让 Java 1.5 之前编写的遗留代码与充满类型参数的现代代码一起工作，类型删除成为你的第二天性。