接口中的继承

Question

I have two interfaces:

public interface EventListener {

    <T extends Data> T modify(T data);

    public static class Data {

    }
}

And:

public interface ServerInfoEventListener extends EventListener {

    // This works
    @Override ServerInfoData modify(Data data);

    // This doesn't work!
    @Override ServerInfoData modify(ServerInfoData data);

    public static class ServerInfoData extends Data {
        public ServerInfoData(String motd, int playerCount, int maxPlayers) {
            this.motd = motd;
            this.playerCount = playerCount;
            this.maxPlayers = maxPlayers;
        }
        public String motd;
        public int playerCount;
        public int maxPlayers;
    }
}

As you can see from the comments, modify(ServerInfoData data) does not compile. Why not, and how do I fix it? ServerInfoData extends Data , so it should work, right?

Answer 1

@Override ServerInfoData modify(ServerInfoData data)

does not work because it does not actually override the EventListener.modify since it will not accept any other subclass of Data other than ServerInfoData (and its subclasses).

You either have to handle all Data types or make the interface itself generic, not only one method:

public interface EventListener<T extends Data> {
    T modify(T data);
}

public interface ServerInfoEventListener extends EventListener<ServerInfoData> {
    @Override ServerInfoData modify(ServerInfoData data);
}

Answer 2

You cannot narrowing down the generic type when override super method.

<T extends Data> T modify(T data);

This method from interface accepts Data and any subclass of Data .

But when you override it like:

@Override 
ServerInfoData modify(ServerInfoData data);

Then your method cannot sibling class of ServerInfoData which extends Data class, hence it breaks the overridden contract.

Answer 3

I can't adequately explain the specific technical reason why it won't work, but I can explain the fix.

Your interface should use generics at the class-level, not the method-level. We're also required to move Data out of EventListener (due to creation deadlock ) :

class Data
{
    //...
}

interface EventListener<T extends Data>
{
    T modify(T data);
}

interface ServerInfoEventListener extends EventListener<ServerInfoEventListener.ServerInfoData>
{
    @Override ServerInfoData modify(ServerInfoData data);

    class ServerInfoData extends Data {
        //...
    }
}

class ServerInfoEventListenerImpl implements ServerInfoEventListener
{
    @Override
    public ServerInfoData modify(final ServerInfoData data)
    {
        return null;
    }
}

Answer 4

As declared in the interface EventListener method modify requires argument of type Data (or any subclass)

ServerInfoData modify(ServerInfoData data); takes argument of type ServerInfoData , however definiton in interface says "It should take anything, that happens to have superclass of type Data " which means that type of arguments of method in subclass does not match what is declared in interface.

Consider this example:

public static class AnotherData extends Data {
    // Whatever
}

public void main() {
    EventListener el = new ServerInfoEventListener() {...};
    el.modify(new AnotherData()); // We have a problem
}

The problem: There is no method implementation to handle AnotherData , but there is supposed to be, because EventListener says so. ServerInfoData modify(ServerInfoData data) Can't take it, because AnotherData is not instanceof ServerInfoData

Hope this helps.