比较枚举条目 - Java

Question

假设我有几台机器：

//Test code of course.
public class Start{
  public static void main(String args[]){
    System.out.println(Machine.COFFEE_GRINDER.getCatalogId());
    System.out.println(Machine.COFFEE_MACHINE.isOfType(Machine.BASIC_MACHINE)); 
    //The above should be true.
  }

  private enum Machine {
    BASIC_MACHINE (-1),
    BEVERAGE (-1),
    COFFEE(-1),
    COFFEE_GRINDER (5),
    COFFEE_MACHINE (6),
    GARDEN (-1),
    LAWN_MOWER (28);

    private final int catalogId;

    public int getCatalogId(){
      return catalogId;
    }

    public boolean isOfType(Machine to){
      return this == to;
    }

    Machine (int catalogId) {
      this.catalogId = catalogId;
    }
  }
}

在上面的示例中，有一些机器，它们会出现在目录中并具有与之关联的 ID 号。还有部分和部分的部分。所以饮料机仍然是 BASIC_MACHINE。咖啡机仍然是饮料机。

程序中的一些功能在执行其功能之前必须检查机器是否实际上是 BEFERAGE 机器。目录中的 COFFEE_GRINDER 和 COFFEE_MACHINE 都将检出，并且该函数应该通过。

我正在寻找的行为类似于 instanceof 或抽象类的继承。无论如何，COFFEE_MACHINE 最终是 BASIC_MACHINE 的一种，我想检查一下。

所以：

Machine.COFFEE_MACHINE isa Machine.COFFEE
Machine.BEVERAGE isa MACHINE.BASIC_MACHINE
Machine.LAWN_MOWER isa Machine.GARDEN == Machine.BASIC_MACHINE
Machine.COFFEE_MACHINE isnota Machine.COFFEE_GRINDER
Machine.LAWN_MOWER isnota Machine.COFFEE

Answer 1

一种可能的解决方案是使用回调和保存的超类型来模拟某些继承。 我很好奇这是否是最好的方法。

实现如下：

//Test code of course.
public class Start{
  public static void main(String args[]){
    System.out.println(Machine.COFFEE_GRINDER.getCatalogId());
    System.out.println(Machine.COFFEE_MACHINE.isOfType(Machine.BASIC_MACHINE)); //Should be true.
  }

  private enum Machine {
    BASIC_MACHINE (-1),
    BEVERAGE (-1, BASIC_MACHINE),
    COFFEE(-1, BEVERAGE),
    COFFEE_GRINDER (5, COFFEE),
    COFFEE_MACHINE (6, COFFEE),
    GARDEN (-1, BASIC_MACHINE),
    LAWN_MOWER (28, GARDEN);

    private int catalogId;
    private Machine superMachine;

    public int getCatalogId(){
      return catalogId;
    }

    public Machine getSuperMachine(){
      return superMachine;
    }

    //With callback to superMachine (if present)
    public boolean isOfType(Machine to){
      return this == to || (getSuperMachine() != null && getSuperMachine().isOfType(to));
    }

    Machine (int catalogId) {
      this.catalogId = catalogId;
    }

    Machine (int catalogId, Machine superMachine) {
      this(catalogId);
      this.superMachine = superMachine;
    }
  }
}

Answer 2

如果我正确理解您的目标，您想表达enum 常量之间的关系网络。考虑到继承不一定与您希望表达的关系保持一致。继承对类型之间的is-a 关系建模；你想要实例之间的connects-to 关系。也许使用与“超级/继承”不同的术语，例如“所有者拥有”。您可以在每个常量中嵌入一个指向 owner 实例的指针，并在静态初始化程序和构造函数中创建一个无环有向图结构。

public enum NetworkedMachine
{
BASIC_MACHINE(-1, null),
BEVERAGE(-1, BASIC_MACHINE),
COFFEE(-1, BASIC_MACHINE),
COFFEE_GRINDER(5, COFFEE),
COFFEE_MACHINE(6, COFFEE),
GARDEN(-1, BASIC_MACHINE),
LAWN_MOWER(28, GARDEN),
;

static final Map<NetworkedMachine, Set<NetworkedMachine>> owners;
static {
  Map<NetworkedMachine, Set<NetworkedMachine>> ownership = new HashMap<>();
  for (NetworkedMachine machine : values()) {
    ownership.put(machine, new HashSet<>());
  }
  for (NetworkedMachine machine : values()) {
    if (machine.owner != null) {
      ownership.get(machine.owner).add(machine);
    }
  }
  for (NetworkedMachine machine : values()) {
    Set<NetworkedMachine> owns = ownership.get(machine);
    ownership.put(machine, Collections.unmodifiableSet(owned));
  }
  owners = Collections.unmodifiableMap(ownership);
}

private final int catalogId;
private final NetworkedMachine owner;

NetworkedMachine(int catalogId, NetworkedMachine machine) {
  this.catalogId = catalogId;
  this.owner = machine;
}

public int getCatalogId() {
  return catalogId;
}

public NetworkedMachine getOwner() {
  return owner;
}

public Set<NetworkedMachine> getOwns() {
  return owners.get(this);
}

public boolean isOwned() {
  return owner != null;
}

}

测试输出：

BASIC_MACHINE id: -1, owner: [null], owns: [GARDEN, BEVERAGE, COFFEE]
BEVERAGE id: -1, owner: [BASIC_MACHINE], owns: []
COFFEE id: -1, owner: [BASIC_MACHINE], owns: [COFFEE_GRINDER, COFFEE_MACHINE]
COFFEE_GRINDER id: 5, owner: [COFFEE], owns: []
COFFEE_MACHINE id: 6, owner: [COFFEE], owns: []
GARDEN id: -1, owner: [BASIC_MACHINE], owns: [LAWN_MOWER]
LAWN_MOWER id: 28, owner: [GARDEN], owns: []