避免在Java中使用instanceof

Question

拥有一系列“instanceof”操作被认为是“代码味道”。标准答案是“使用多态性”。在这种情况下我该怎么做？

一个基类有多个子类；他们都不在我的控制之下。类似的情况是 Java 类 Integer、Double、BigDecimal 等。

if (obj instanceof Integer) {NumberStuff.handle((Integer)obj);}
else if (obj instanceof BigDecimal) {BigDecimalStuff.handle((BigDecimal)obj);}
else if (obj instanceof Double) {DoubleStuff.handle((Double)obj);}

我确实可以控制 NumberStuff 等。

我不想使用很多行代码，而几行代码就可以了。 （有时我会创建一个 HashMap，将 Integer.class 映射到 IntegerStuff 的实例，将 BigDecimal.class 映射到 BigDecimalStuff 的实例等。但今天我想要更简单的东西。）

我想要像这样简单的东西：

public static handle(Integer num) { ... }
public static handle(BigDecimal num) { ... }

但 Java 不这样做那样工作。

我想在格式化时使用静态方法。我正在格式化的内容是复合的，其中 Thing1 可以包含 Thing2s 数组，Thing2 可以包含 Thing1s 数组。当我实现这样的格式化程序时，我遇到了一个问题：

class Thing1Formatter {
  private static Thing2Formatter thing2Formatter = new Thing2Formatter();
  public format(Thing thing) {
      thing2Formatter.format(thing.innerThing2);
  }
}
class Thing2Formatter {
  private static Thing1Formatter thing1Formatter = new Thing1Formatter();
  public format(Thing2 thing) {
      thing1Formatter.format(thing.innerThing1);
  }
}

是的，我知道 HashMap，更多的代码也可以解决这个问题。但相比之下，“instanceof”似乎更具可读性和可维护性。有没有什么简单又不臭的东西？

注：2010 年 5 月 10 日添加：

事实证明，将来可能会添加新的子类，而我现有的代码将必须妥善处理它们。在这种情况下，类上的 HashMap 将不起作用，因为找不到该类。一连串的 if 语句，从最具体的开始，到最一般的结束，可能是最好的：

if (obj instanceof SubClass1) {
    // Handle all the methods and properties of SubClass1
} else if (obj instanceof SubClass2) {
    // Handle all the methods and properties of SubClass2
} else if (obj instanceof Interface3) {
    // Unknown class but it implements Interface3
    // so handle those methods and properties
} else if (obj instanceof Interface4) {
    // likewise.  May want to also handle case of
    // object that implements both interfaces.
} else {
    // New (unknown) subclass; do what I can with the base class
}

Answer 1

您可能对 Steve Yegge 的 Amazon 博客中的这篇文章感兴趣：“当多态性失败时”< /a>.本质上，他正在解决这样的情况，即多态性造成的麻烦多于其解决的麻烦。

问题是，要使用多态性，您必须将“处理”逻辑作为每个“切换”类的一部分 - 即本例中的“整数”等。显然这是不切实际的。有时，从逻辑上讲，它甚至不是放置代码的正确位置。他推荐“instanceof”方法，因为它是几种弊端中较小的一个。

与所有被迫编写有气味的代码的情况一样，将其保留在一种方法（或最多一个类）中，这样气味就不会泄漏出去。

Answer 2

正如评论中强调的那样，访问者模式将是一个不错的选择。但如果没有对目标/接受者/访问者的直接控制，你就无法实现该模式。这是访问者模式仍然可以在这里使用的一种方式，即使您无法通过使用包装器直接控制子类（以 Integer 为例）：

public class IntegerWrapper {
    private Integer integer;
    public IntegerWrapper(Integer anInteger){
        integer = anInteger;
    }
    //Access the integer directly such as
    public Integer getInteger() { return integer; }
    //or method passthrough...
    public int intValue() { return integer.intValue(); }
    //then implement your visitor:
    public void accept(NumericVisitor visitor) {
        visitor.visit(this);
    }
}

当然，包装最终类可能会被认为是它自己的味道，但也许它非常适合您的子类。就我个人而言，我不认为 instanceof 这里有那么难闻，特别是如果它仅限于一种方法并且我很乐意使用它（可能超过我自己的建议）。正如你所说，它具有良好的可读性、类型安全性和可维护性。一如既往，保持简单。

Answer 3

您可以将处理的实例放入映射中（键：类，值：处理程序），而不是使用巨大的 if。

如果按键查找返回 null，则调用一个特殊的处理程序方法来尝试查找匹配的处理程序（例如，通过对映射中的每个键调用 isInstance()）。

找到处理程序后，将其注册到新密钥下。

这使得一般情况变得快速而简单，并允许您处理继承。

Answer 4

您可以使用反射：

public final class Handler {
  public static void handle(Object o) {
    try {
      Method handler = Handler.class.getMethod("handle", o.getClass());
      handler.invoke(null, o);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  public static void handle(Integer num) { /* ... */ }
  public static void handle(BigDecimal num) { /* ... */ }
  // to handle new types, just add more handle methods...
}

您可以扩展这个想法来一般处理实现某些接口的子类和类。

Answer 5

我认为最好的解决方案是以 Class 为键、Handler 为值的 HashMap。请注意，基于 HashMap 的解决方案以恒定的算法复杂度 θ(1) 运行，而 if-instanceof-else 的嗅觉链以线性算法复杂度 O(N) 运行，其中 N 是 if-instanceof-else 链中的链接数（即要处理的不同类的数量）。因此，基于 HashMap 的解决方案的性能比 if-instanceof-else 链解决方案的性能渐进高 N 倍。
考虑到您需要以不同的方式处理 Message 类的不同后代：Message1、Message2 等。下面是基于 HashMap 的处理的代码片段。

public class YourClass {
    private class Handler {
        public void go(Message message) {
            // the default implementation just notifies that it doesn't handle the message
            System.out.println(
                "Possibly due to a typo, empty handler is set to handle message of type %s : %s",
                message.getClass().toString(), message.toString());
        }
    }
    private Map<Class<? extends Message>, Handler> messageHandling = 
        new HashMap<Class<? extends Message>, Handler>();

    // Constructor of your class is a place to initialize the message handling mechanism    
    public YourClass() {
        messageHandling.put(Message1.class, new Handler() { public void go(Message message) {
            //TODO: IMPLEMENT HERE SOMETHING APPROPRIATE FOR Message1
        } });
        messageHandling.put(Message2.class, new Handler() { public void go(Message message) {
            //TODO: IMPLEMENT HERE SOMETHING APPROPRIATE FOR Message2
        } });
        // etc. for Message3, etc.
    }

    // The method in which you receive a variable of base class Message, but you need to
    //   handle it in accordance to of what derived type that instance is
    public handleMessage(Message message) {
        Handler handler = messageHandling.get(message.getClass());
        if (handler == null) {
            System.out.println(
                "Don't know how to handle message of type %s : %s",
                message.getClass().toString(), message.toString());
        } else {
            handler.go(message);
        }
    }
}

有关 Java 中 Class 类型变量的使用的更多信息：http://docs .oracle.com/javase/tutorial/reflect/class/classNew.html

Answer 6

您可以考虑责任链模式。对于您的第一个示例，类似于：

public abstract class StuffHandler {
   private StuffHandler next;

   public final boolean handle(Object o) {
      boolean handled = doHandle(o);
      if (handled) { return true; }
      else if (next == null) { return false; }
      else { return next.handle(o); }
   }

   public void setNext(StuffHandler next) { this.next = next; }

   protected abstract boolean doHandle(Object o);
}

public class IntegerHandler extends StuffHandler {
   @Override
   protected boolean doHandle(Object o) {
      if (!o instanceof Integer) {
         return false;
      }
      NumberHandler.handle((Integer) o);
      return true;
   }
}

然后对于其他处理程序也类似。然后是按顺序将 StuffHandler 串在一起的情况（从最具体到最不具体，带有最终的“后备”处理程序），并且您的调度程序代码只是 firstHandler.handle(o);。

（另一种方法是，不使用链，而是在调度程序类中使用 List ，并让它循环遍历列表，直到 handle() 返回真的）。

Answer 7

只需使用instanceof即可。所有的解决方法似乎都更加复杂。这是一篇讨论它的博客文章： http://www.velocityreviews.com/forums/t302491-instanceof-not-always-bad-the-instanceof-myth.html

Answer 8

我已经使用 reflection 解决了这个问题（大约 15 年前的前泛型时代）。

GenericClass object = (GenericClass) Class.forName(specificClassName).newInstance();

我定义了一个通用类（抽象基类）。我已经定义了基类的许多具体实现。每个具体类都将以 className 作为参数进行加载。此类名称被定义为配置的一部分。

基类定义了所有具体类的公共状态，具体类将通过​​覆盖基类中定义的抽象规则来修改状态。

当时我还不知道这个机制的名字，一直被称为反射。

这篇文章中列出了更多替代方案：Map 和 enum 除了反射之外。

Answer 9

在 BaseClass 中添加一个返回类名称的方法。并使用特定类名覆盖方法

public class BaseClass{
  // properties and methods
  public String classType(){
      return BaseClass.class.getSimpleName();
  }
}

public class SubClass1 extends BaseClass{
 // properties and methods
  @Override
  public String classType(){
      return SubClass1.class.getSimpleName();
  }
}

public class SubClass2 extends BaseClass{
 // properties and methods
  @Override
  public String classType(){
      return SubClass1.class.getSimpleName();
  }
}

现在按以下方式使用 switch case-

switch(obj.classType()){
    case SubClass1:
        // do subclass1 task
        break;
    case SubClass2:
        // do subclass2 task
        break;
}

Answer 10

我在 Java 8 中使用的是：

void checkClass(Object object) {
    if (object.getClass().toString().equals("class MyClass")) {
    //your logic
    }
}