Eclipse建模框架有一个有趣的想法，它也考虑了继承。Switch接口中定义了基本概念:通过调用doSwitch方法来完成切换。

真正有趣的是实现。对于每种类型的兴趣，a

public T caseXXXX(XXXX object);

方法必须实现(默认实现返回null)。doSwitch实现将尝试为对象的所有类型层次结构调用所有caseXXX方法。之类的东西:

BaseType baseType = (BaseType)object;
T result = caseBaseType(eAttribute);
if (result == null) result = caseSuperType1(baseType);
if (result == null) result = caseSuperType2(baseType);
if (result == null) result = caseSuperType3(baseType);
if (result == null) result = caseSuperType4(baseType);
if (result == null) result = defaultCase(object);
return result;

实际框架为每个类使用一个整数id，所以逻辑实际上是一个纯切换:

public T doSwitch(Object object) {
    return doSwitch(object.class(), eObject);
}

protected T doSwitch(Class clazz, Object object) {
    return doSwitch(getClassifierID(clazz), object);
}

protected T doSwitch(int classifierID, Object theObject) {
    switch (classifierID) {
    case MyClasses.BASETYPE:
    {
      BaseType baseType = (BaseType)object;
      ...
      return result;
    }
    case MyClasses.TYPE1:
    {
      ...
    }
  ...

您可以查看ECoreSwitch的完整实现，以获得更好的理解。

这是子类型多态有助于实现的典型场景。执行以下步骤

interface I {
  void do();
}

class A implements I { void do() { doA() } ... }
class B implements I { void do() { doB() } ... }
class C implements I { void do() { doC() } ... }

然后您可以简单地在此上调用do()。

如果您不能自由地更改A、B和C，则可以应用访问者模式来实现相同的目的。

如果您可以操作公共接口，您可以在枚举中添加，并让每个类返回唯一的值。您不需要instanceof或visitor模式。

对我来说，逻辑需要写在switch语句中，而不是对象本身。这就是我的解决方案:

ClassA、ClassB和ClassC实现了CommonClass

接口:

public interface CommonClass {
   MyEnum getEnumType();
}

枚举:

public enum MyEnum {
  ClassA(0), ClassB(1), ClassC(2);

  private int value;

  private MyEnum(final int value) {
    this.value = value;
  }

  public int getValue() {
    return value;
  }

Impl:

...
  switch(obj.getEnumType())
  {
    case MyEnum.ClassA:
      ClassA classA = (ClassA) obj;
    break;

    case MyEnum.ClassB:
      ClassB classB = (ClassB) obj;
    break;

    case MyEnum.ClassC:
      ClassC classC = (ClassC) obj;
    break;
  }
...

如果你使用的是java 7，你可以为枚举设置字符串值，并且switch case块仍然可以工作。

如果您想避免If (){} else If{}的冗长，您可以考虑将这个文件切换到kotlin，并将类似于开关的when表达式与is操作符结合使用。

在任何情况下，Kotlin和java文件都可以共存于一个项目中，并生成一个可以在JVM中运行的jar。

when (this) { //switch-like statement in kotlin supporting class-pattern-matching and smart casts via `is` operator.
    is A -> doA()
    is B -> doB()
    is C -> doC()
}

正如前面的回答所讨论的，传统的面向对象方法是使用多态性而不是开关。对于这种技巧，甚至有一个经过良好记录的重构模式:用多态性替换Conditional。每当我使用这种方法时，我也喜欢实现一个Null对象来提供默认行为。

从Java 8开始，我们可以使用lambda和泛型来提供函数式程序员非常熟悉的东西:模式匹配。它不是语言的核心特性，但是VAVR库(以前是Javaslang库)提供了一个实现。文档中的例子:

Match.ofType(Number.class)
    .caze((Integer i) -> i)
    .caze((String s) -> new BigDecimal(s))
    .orElse(() -> -1)
    .apply(1.0d); // result: -1

它不是Java世界中最自然的范例，所以要谨慎使用。虽然泛型方法将使您不必对匹配的值进行类型转换，但我们缺少一种分解匹配对象的标准方法，例如Scala的case类。

在最近发布的Java 19中，这非常简单和有用: 创建接口，并具有名为makesomenoise()的方法，它接受动物参数。

void makeSomeNoise (Animal animal) {
switch (animal) {
case Dog dog → dog.bark();
case Cat catcat.meow();
default throw new RuntimeException ("WTH is it???");
}
}