Java - SubType Enum或SubClass

Question

我试图让一个enum对应于一个类，或者返回那个类，但是我需要解决。如果我使用CommandType.SELLSHARES来返回SellShares.class，这种行为是可能的吗？或者，我可以用继承自父类型的不同类别来组织枚举吗？

命令- ADMIN，USER，CLIENT

public enum CommandType {

// SELLSHARES, BUYSHARES, UPDATEUSER, ADDUSER, ADMINASSIGNMENT, BANUSER, CHANGESTATUS, REMOVEUSER

    SELLSHARES (SellShares.class),
    BUYSHARES (BuyShares.class);

    private Class<Command> command;

    CommandType(Class<Command> command) {
        this.command = command;
    }

    private Class<Command> command() { return command; }

    public static <T extends Enum<T>> T getInstance(final String value,
            final Class<T> enumClass) {
        return Enum.valueOf(enumClass, value);
    }

}

或

public enum CommandType {
    AdminCommands,
    UserCommands
}

enum AdminCommands {
    UPDATEUSER,
    ADDUSER,
    ADMINASSIGNMENT,
    BANUSER,
    CHANGESTATUS,
    REMOVEUSER
}

enum User {
    SELLSHARES,
    BUYSHARES
}

对getByType有问题

void initialCommands() throws Exception
    {
        listCommands = Commands.getByType(Commands.Type.ADMIN);

        for (Commands command : listCommands)
            {
                Command commandss = command.newInstance();
                //addCommand(command.getCommand());
                //log.trace(command.newInstance());

            }

    }

Answer 1

你一定是在找这样的东西：

public enum Commands {

    UPDATE_USER(Type.ADMIN, UpdateUser.class),
    ADD_USER(Type.ADMIN, AddUser.class),
    ADMIN_ASSIGNMENT(Type.ADMIN, AdminAssignment.class),
    BAN_USER(Type.ADMIN, BanUser.class),
    CHANGE_STATUS(Type.ADMIN, ChangeStatus.class),
    REMOVE_USER(Type.ADMIN, RemoveUser.class),

    SELL_SHARES(Type.USER, SellShares.class),
    BUY_SHARES(Type.USER, BuyShares.class);

    public enum Type {
        ADMIN,
        USER;
    }

    public static List<Commands> getByType(Type type) {
        List<Commands> commands = new ArrayList<Commands>();
        for (Commands command : values()) {
            if (command.type.equals(type)) {
                commands.add(command);
            }
        }
        return commands;
    }

    private final Type type;

    private final Class<? extends Command> command;

    private Commands(Type type, Class<? extends Command> command) {
        this.type = type;
        this.command = command;
    }

    public Class<? extends Command> getCommand() {
        return command;
    }

    public Command newInstance() throws Exception {
        return command.newInstance();
    }

}

要创建实例，只需使用：

Commands.UPDATE_USER.newInstance();

要获取给定类型的所有命令，请执行以下操作：

Commands.getByType(Commands.Type.ADMIN);

请注意，使用此方法，Commands子类必须实现公共髓质构造函数。

Answer 2

我想提供这方面的建议和模式。

• 不要在枚举上使用/while/循环。
• 减少使用如果-然后-在一个枚举.
• 但是要利用这样一个事实:枚举是一种高效的hashmap。将操作构建到枚举中，这样您就不必在枚举上迭代来解析因枚举而产生的操作。
• 避免使用if块来解析枚举的适当操作，但是将函数lambda构建到枚举中。
• 设计您的代码以尽可能多地使用EnumSet来“子类”您的枚举。

重新设计使用EnumSet的代码流。不要使用复数但命令作为枚举类名。这样您就可以将命令持有者引用为Command.ADDUSER而不是Commands.ADDUSER。

使用EnumSet对枚举中的项进行分类的示例，

enum Command {
    UPDATEUSER,
    ADDUSER,
    ADMINASSIGNMENT,
    BANUSER,
    CHANGESTATUS,
    REMOVEUSER,
    SELLSHARES,
    BUYSHARES,
    ;

    final static public EnumSet<AdminCommands> ADMIN = EnumSet.of(
      UPDATEUSER,
      ADDUSER,
      ADMINASSIGNMENT,
      BANUSER,
      CHANGESTATUS,
      REMOVEUSER
    );

    final static public EnumSet<AdminCommands> USER= EnumSet.of(
      SELLSHARES,
      BUYSHARES
    );
}

将类构造函数调用及其各自的操作构建到枚举中：

interface Commander{}
@FunctionalInterface
public interface CommanderNoArg extends Commander {
  Action getAction();
}
@FunctionalInterface
public interface Commander1Arg extends Commander {
  Action getAction(ActionContext ctx);
}
@FunctionalInterface
public interface Commander2Arg extends Commander {
  Action getAction(ActionContext ctx, Options opts);
}

// Auxiliary casters needed due to Java's silly deficient treatment of generics
static private CommanderNoArg hasNoArg(CommanderNoArg lambd) {
  return lambd;
}
static private Commander1Arg has1Arg(Commander1Arg lambd) {
  return lambd;
}
static private Commander2Arg has2Args(Commander2Arg lambd) {
  return lambd;
}


enum Command {
    UPDATEUSER(hasNoArg(UserContext::new) ),
    ADDUSER(hasNoArg(UserContext::new) ),
    ADMINASSIGNMENT(has1Arg(AdminContext::new) ),
    BANUSER(hasNoArg(UserContext::new) ),
    CHANGESTATUS(hasNoNoArg(UserContext::new) ),
    REMOVEUSER(hasNoNoArg(UserContext::new) ),
    SELLSHARES(has2Args(UserContext::new) ),
    BUYSHARES(has2Args(UserContext::new) ),
    ;

    final public Commander commander;
    private Command(Commander cmdr) {
      this.commander = cmdr;
    }

}

哪里因为

• UserContext有不需要参数的构造函数。
• UserContext还具有需要2个参数的构造函数。
• AdminContext的构造函数需要一个参数。

您可以通过以下方法获得Action类：

// AdminContext requires 1 argument
Assignment assg = getAssgFromSomewhere();
Action act =
  ((Commander1Arg )Command.ADMINASSIGNMENT.commander)
     .getAction(assg);

或者，您可以将静态方法的lambda中的内容输入到枚举项中，而不是类中。