switch 语句在这里是否合适，采用枚举？

Question

今天我用 Java 制作了一个俄罗斯方块克隆，到了实现块生成机制的时候，我写了这个带有枚举的 switch 语句。有人告诉我尽可能避免使用 switch 语句，但我不确定是否可以在此处避免使用 switch 语句，除非我彻底检查我最初的基于继承的设计选择。

为了实现不同类型的块，我决定创建一个名为 Block 的抽象超类，并为每个特定类型创建一个子类。我还制作了一个标记块类型的枚举。例如，ZBlock extends Block 对象会将 Type.ZBlock 枚举分配给其 Type 字段变量。

private void spawnBlock(Type type){
        switch(type){
            case I:
                currentBlock = new IBlock();
                break;
            case L:
                currentBlock = new LBlock();
                break;
            case J:
                currentBlock = new JBlock();
                break;
            case Z:
                currentBlock = new ZBlock();
                break;
            case S:
                currentBlock = new SBlock();
                break;
            case T:
                currentBlock = new TBlock();
                break;
            default:
                currentBlock = new OBlock();
        }
    }

当我开始考虑在此处不使用 switch 语句的方法时，除了摆脱所有子类并在单个非抽象 Block 类中对不同块的行为进行编程之外，我想不出别的办法.但它可能会变得一团糟，因为不同的块有不同的形状和墙踢数据。那么 switch 语句在这里是一个不错的选择吗？如果没有，我该如何改进我的代码？为什么？

Answer 1

Switch 比使用 if-else 语句更好。在我看来，这是更简洁的代码。 只需使用 if-else 将其与相同的代码进行比较：

private void spawnBlock(Type type){
    if(Type.I.equals(type)) {
        currentBlock = new IBlock();
    } else if(Type.L.equals(type)) {
        currentBlock = new LBlock();
    } else if(Type.J.equals(type)) {
        currentBlock = new JBlock();
    } else if(Type.Z.equals(type)) {
        currentBlock = new ZBlock();
    } else if(Type.S.equals(type)) {
        currentBlock = new SBlock();
    } else if(Type.T.equals(type)) {
        currentBlock = new TBlock();
    } else {
        currentBlock = new OBlock();
    }
}

但您通常有机会使用与 switch 或 if-else 不同的方法。 只需看看其他答案或查看this。它解释了如何使用枚举改进代码并将逻辑直接放入枚举中。

Answer 2

还有另一种避免switch 情况的方法，即使用Map 和EnunMap 实现，它将Type 作为键，将值作为Block 实现。

在处理 Enum 键时，建议按照 Javadoc 实现 EnumMap：

用于枚举类型键的专用 Map 实现。

这种表示非常紧凑和高效。

实现说明：所有基本操作都在恒定时间内执行。他们很可能 （虽然不能保证）比它们的 HashMap 对应物更快。

使用EnumMap 代替switch 时的示例代码，其中键 是Type 枚举实例，值是Supplier<Block>（构造函数引用）：

//During initialization
Map<Type, Supplier<Block>> registry =  new EnumMap<>(Type.class);
registry.put(Type.I, IBlock::new);
registry.put(Type.L, LBlock::new);
registry.put(Type.J, JBlock::new);
registry.put(Type.Z, ZBlock::new);
...

然后您可以通过提供正确的Type 从spawnBlock() 获取它，并且由于最后调用Supplier.get()，您每次都会获得Block 实现的新实例：

private void spawnBlock(Type type){
   currentBlock = this.registry.get(type).get();
}

Answer 3

有人告诉我尽可能避免使用 switch 语句

这是正确的，但你在这里所做的可能没问题。

重点是：您不想到处都有这样的 switch 语句。它们很糟糕，因为它们将事物结合在一起。当您一遍又一遍地重复“相同”的开关模式时，这可能会变成维护的噩梦。因为对枚举类型的更改...意味着您必须查看每个开关以确定是否需要对其进行调整。

因此，当您能够隐藏大部分代码中的此类切换（仅在少数几个地方进行，理想情况下，在一个地方进行），您就可以了。

不过，更好的方法是用这个单行替换整个 switch 语句：

currentBlock = type.createBlock();

换句话说：为什么不将知识直接放入枚举类本身？当然，这还有其他含义，例如可能违反单一责任原则。

但它感觉很自然，表示不同类型块的枚举也提供了创建此类块的方法（鉴于 type 是唯一的确定您需要哪种 Block 子类的信息）。

请注意：您不一定移动 开关 到枚举中。您可以完全避免在这里切换：

enum Type {
  I(IBlock::new), L(LBlock::new), ...;

  private Supplier<? extends Block> supplier;
  private Type(Supplier<? extends Block> supplier) {
    this.supplier = supplier;
  }

  public Block getBlock() {
    return supplier.get();
  }

（我没有通过编译器运行以上代码，所以请注意拼写错误）

Answer 4

既然你已经有了一个枚举，就让每个常量知道如何创建它所代表的类型的实例。

interface Block {}
class IBlock implements Block {}
class LBlock implements Block {}

enum  Type {
  I(IBlock::new), 
  L(LBlock::new);

  private Supplier<? extends Block> blockSupplier;

  Type(Supplier<? extends Block> supplier) {
    blockSupplier =supplier;
  }

  public Supplier<? extends Block> getBlockSupplier() {
    return blockSupplier;
  }
}

生成块的方法如下所示

private void spawnBlock(Type type) {
  currentBlock = type.getBlockSupplier().get();
}

话虽如此，我认为这里的切换方法没有问题。更令人担忧的是该方法有一个副作用：它不会产生新的Block（我会使用它），它会设置字段。一个名为spawnBlock 的方法什么都不返回，会有什么期望？