从方法返回Java有界通用对象(Returning Java bounded generic objects from method)

 我知道Oracle教程和问题， 如何使方法返回类型通用？ 但是我仍然无法从Java方法返回通用对象。 
 
 简要示例：我有一个网络Packet的层次结构和Handler的层次结构，参数Packet它们处理的Packet 。 最后我有一个Handler的注册表 ，其中包含一个方法，它会返回给定数据包的正确处理程序。 
 
 我想实现所有这一切，理想情况下没有警告手动压制。 
 
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);
}
 
 这是非常规则的我相信，在我的实现中，我在中间有一些进一步的抽象类来塑造我的层次结构，但我认为现在可以忽略它。 
 
 关键部分是i）注册表： 
 
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> 
 
 ..和ii）和注册用户： 
 
class HandlerSwitchExample {
    public static void main() {
        // [...]
        <<OBJECT TYPE>> handler = HandlersRegistry.getHandler(somePacket);
        handler.handle(somePacket);
    }
}
 
 希望这个例子相当清楚。 感谢任何有用的建议，甚至完整的重新设计策略。 

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.

原文：https://stackoverflow.com/questions/29119731