抽象超类的抽象方法作为子类中的静态方法

Question

I have developed a custom communication protocol. In this protocol each packet is made up of a header and a payload. Each payload contains multiple commands.

I'd like to implement a static 'decode' method within every Command (Command0, ..., Command N) because all commands of the same type are decoded the same way (they have the same field structure). I use an abstract class 'Command' as a template with some common fields and methods and an abstract 'decode' method for my commands. But since the superclass method is abstract, the 'decode' method within Command0, ..., CommandN can't be static.

Any workaounds? I'd like to avoid instantiating every command each time I have to decode some packet.

As an alternative I've got rid of the abstract 'decode' method and included a static 'decode' method within every command extending Command. However, without a superclass or an interface, another programmer could forget to implement a decode method. This alternative would lead to the following code:

{
    switch(commandIdentifier)
    {
        case 0:
        {
            Command0 command0 = Command0.decode(dbConnection, header, data, offset);
            payload.getCommands().add(command0);
            break;
        }
        //...
        case N:
        {
            CommandN commandN = CommandN.decode(dbConnection, header, data, offset);
            payload.getCommands().add(commandN);
            break;
        }
        default:
        {
            //some code
        }
    }
}

Where I first have to check the command identifier.

I have originally implemented the classes this way:

public class Packet
{
    private Header header;
    private Payload payload;

    public static Packet decode(Connection dbConnection, byte[] data, int offset) throws Exception
    {
        //...
    }
}

public class Header
{
    public static Header decode(byte[] data, int offset)
    {
        //...
    }
}

public class Payload
{
    private List<Command> commands;
    public static Payload decode(Connection dbConnection, Header header, byte[] data, int offset)
    {
        //iterate over the data bytes to populate commands
    }
}

public abstract class Command
{
    public abstract Command decode(Connection dbConnection, Header header, byte[] data, int offset) throws Exception;
}

public class Command0
{
    int field1;
    String field2;
    float field3;
    public Command decode(Connection dbConnection, Header header, byte[] data, int offset) throws Exception;  //I can't make it static and I'd like to because all commands of class Command0 are decoded the same way.
}

//...

public class Command N
{
    int field1;
    Map<Integer, ConfigBean> field2;
    public Command decode(Connection dbConnection, Header header, byte[] data, int offset) throws Exception;  //I can't make it static and I'd like to because all commands of class CommandN are decoded the same way.
}

Answer 1

You could have an enum class that contains the info relative to what command is and how to decode it. Using an abstract method instead of a static methid will force you to implement a decode for each one:

public enum CommandType {
    COMMAND_0(0) {
        @Override
        public <T extends Command> T decode(Connection dbConnection, ResponseBuilder.Header header, byte[] data, int offset) throws Exception {
            // decode Command 0
            ...
        }
    },
    COMMAND_1(1) {
        @Override
        public <T extends Command> T decode(Connection dbConnection, ResponseBuilder.Header header, byte[] data, int offset) throws Exception {
            // decode Command 1
            ...
        }
    }
    ...
    COMMAND_N(N) {
        @Override
        public <T extends Command> T decode(Connection dbConnection, ResponseBuilder.Header header, byte[] data, int offset) throws Exception {
            // decode Command N
            ...
        }
    }
    ;

    private final int commandIdentifier;

    CommandType(int commandIdentifier) {
        this.commandIdentifier = commandIdentifier;
    }

    public abstract <T extends Command> T decode(Connection dbConnection, ResponseBuilder.Header header, byte[] data, int offset) throws Exception;


    private static Map<Integer, CommandType> map = new HashMap<Integer, CommandType>();
    static {
        for (CommandType commandType : CommandType.values()) {
            if (map.get(commandType.commandIdentifier) != null)
                throw new IllegalStateException("There are several commands with the same identifier");
            map.put(commandType.commandIdentifier, commandType);
        }
    }

    public static CommandType fromIdentifier(int commandIdentifier) throws IllegalArgumentException {
        CommandType commandType = map.get(commandIdentifier);
        if (commandType == null)
            throw new IllegalArgumentException("Unkown command identifier");
        return commandType;
    }

}

After that you can simply use:

Command c = CommandType.fromIdentifier(commandIdentifier).decodedecode(dbConnection, header, data, offset);

I think that's a more stylish way of handling this