Java Generic Type utilisation

kay :

I have these classes:

My problem is that for each class I am having to manually register the node.

/**
 * Contains the encoder for messages from the server.
 * 
 * @since 18/08/2018
 */
public abstract class MessageEncoder<T> {

    /**
     * Register this encoder to a message.
     */
    public abstract void register();

    /**
     * Get the encoded message to send to the client.
     * 
     * @param message The message.
     * @return the {@link GamePacket} ready to be sent.
     */
    public abstract GamePacket encode(T message);

}

Where < T > is always someClass extends Message.

And here is how a message encoder looks like:

public final class ComponentMessageEncoder extends MessageEncoder<ComponentTextMessage> {

    @Override 
    public void register() {
        GameConstants.RELEASE.register(ComponentTextMessage.class, this);

    }

    @Override 
    public GamePacket encode(ComponentTextMessage message) {
        // TODO Auto-generated method stub
        return null;
    }

}

As you can see the items in the register method, I have to manually type that for every encoder I make.

Is there a shortcut for this that I can just put in MessageEncoder abstract class instead?

I could not find anything that works here

Edit:

Where register sig. is:

/**
     * The encoders.
     */
    private final Map<Class<? extends Message>, MessageEncoder<?>> encoders = new HashMap<>();

    /**
     * Register a encoder to a message.
     * 
     * @param message The message.
     * @param encoder The encoder.
     */
    public void register(Class<? extends Message> message, MessageEncoder<?> encoder) {
        encoders.put(message, encoder);
    }

jacobm :

You can do slightly better with:

public abstract class MessageEncoder<T extends Message> {
    protected MessageEncoder(Class<? extends T> messageClass) {
      GameConstants.RELEASE.register(messageClass, this);
    }

    /**
     * Get the encoded message to send to the client.
     * 
     * @param message The message.
     * @return the {@link GamePacket} ready to be sent.
     */
    public abstract GamePacket encode(T message);
}

Now subclasses would do:

public final class ComponentMessageEncoder extends MessageEncoder<ComponentTextMessage> {
    ComponentMessageEncoder() {
      super(ComponentTextMessage.class);
    }

    // etc as before
}

This cuts down slightly on the repetition, and it allows the compiler to stop you from getting it wrong, so it's something of a win.