Returning Java bounded generic objects from method

Question

I am aware of Oracle tutorials and questions like How do I make the method return type generic? but still I am having trouble returning generic objects from a Java method.

Brief example: I have a hierarchy of network Packets and a hierarchy of Handlers, parametrized to the Packet they handle. Eventually I have a registry of Handlers which includes a method to that would return me the proper handler of a given packet.

I would like to implement all of this with ideally no warning to manually suppress.

class Packet {}
class ThisPacket extends Packet {}
class ThatPacket extends Packet {}

interface PacketHandler<P extends Packet> {
    boolean handle(P p);
}

class ThisPacketHandler extends PacketHandler<ThisPacket> {
    boolean handle(ThisPacket p);
}

class ThatPacketHandler extends PacketHandler<ThatPacket> {
    boolean handle(ThatPacket p);
}

This is quite regular I believe, in my implementation I have some further abstract classes in the middle to shape my hierarchy, but I think this can be ignored by now.

The critical part is i) the registry:

class HandlersRegistry {
    static <<RETURN TYPE>> getHandler(Packet p) {
        if (p instanceof ThisPacket) return new ThisPacketHandler();
        if (p instanceof ThatPacket) return new ThatPacketHandler();
        return null;
    }
}

<<RETURN TYPE>> OPTIONS (I tried):
    // Raw-type Warning:
    A. PacketHandler 
    // the registry user won't be able to use the handler:
    B. PacketHandler<? extends Packet>
    // Type mismatch: cannot convert from 
    C. PacketHandler<Packet> 

..and ii) and the registry user:

class HandlerSwitchExample {
    public static void main() {
        // [...]
        <<OBJECT TYPE>> handler = HandlersRegistry.getHandler(somePacket);
        handler.handle(somePacket);
    }
}

Hope the example is fairly clear. Thanks for any helpful suggestion, even complete redesign strategies.

Answer 1

You basically have two parallel hierarchies (Packet and PacketHandler), where each level on one hierarchy is related to the same level in other hierarchy. Below diagrams shows your structure (Skipped the ThatHandler)

  Packet ------------> PacketHandler
    ^                        ^
    |                        |
ThisPacket --------> ThisPacketHandler

These cases are often solved using self-referential type parameters. Also, use factory method instead of creating objects in registry.

Here's the change in structure of your classes (also, I guess you should make Packet class abstract:

abstract class Packet<T extends Packet<T>> {
  /**
   *  Factory method.
   *  Override this method in sub-packets to return appropriate handlers
   */
  abstract PacketHandler<T> getHandler();
}

Then your sub-packets would be like:

class ThisPacket extends Packet<ThisPacket> {
  @Override
  PacketHandler<ThisPacket> getHandler() {
    return new ThisPacketHandlerImpl();
  }
}

class ThatPacket extends Packet<ThatPacket> {
  @Override
  PacketHandler<ThatPacket> getHandler() {
    return new ThatPacketHandlerImpl();
  }
}

Now, your PacketHandlers (You don't need separate handler interfaces here):

interface PacketHandler<P extends Packet<P>> {
  boolean handle(P p);
}

class ThisPacketHandlerImpl implements PacketHandler<ThisPacket> {
  @Override
  public boolean handle(ThisPacket p) {
    return false;
  }

}

class ThatPacketHandlerImpl implements PacketHandler<ThatPacket> {
  @Override
  public boolean handle(ThatPacket p) {
    return false;
  }
}

Finally the registry:

class HandlersRegistry {
  static <P extends Packet<P>> PacketHandler<P> getHandler(P p) {
    return p.getHandler();
  }
}

And use it like this:

ThisPacket somePacket = new ThisPacket();
PacketHandler<ThisPacket> handler = HandlersRegistry.getHandler(somePacket);
handler.handle(somePacket);

Now, with the above structure, you can keep on adding new Packets without having the need to modify existing classes. Just create a Packet and corresponding PacketHandler. Override the getHandler() method in the new Packet class, and you're good to use it. Now need to change the registry class also.

Answer 2

Using Generic here is not making sense:

• First, you never know the type of return object in coding time, which didn't bring any benefit.
• Second, using generic will cost confusion (for case HandlerSwitchExample, you dont want to work with an object type T).

So instead, just use inheritance

PacketHandler handler = HandlersRegistry.getHandler(somePacket);

And

static PacketHandler getHandler(Packet p) {
    if (p instanceof ThisPacket) return new ThisPacketHandler();
    if (p instanceof ThatPacket) return new ThatPacketHandler();
    return null;
}

Inside the HandlersRegistry, you can implement strategy pattern to support different type of packet.

With this, you can add more flexibilities in your project, as you can have as many as you want number of type of packet and packet handler, and also hide the real implementation. Also force client to work with only the public API that you defined in the interface, thus, limiting your risk.