108

拥有一系列“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 日添加的注释：

事实证明，未来可能会添加新的子类，而我现有的代码将不得不优雅地处理它们。在这种情况下，Class 上的 HashMap 将不起作用，因为找不到 Class。一连串的 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
}
4

9 回答 9

60

您可能对 Steve Yegge 的 Amazon 博客中的这篇文章感兴趣：“当多态性失败时”。从本质上讲，他正在解决这样的情况，即多态性带来的麻烦多于解决的问题。

问题是要使用多态性，您必须使每个“切换”类的“句柄”部分的逻辑——即在这种情况下为整数等。显然这是不切实际的。有时它甚至在逻辑上都不是放置代码的正确位置。他推荐“instanceof”方法，因为它是几种弊端中的较小者。

与您被迫编写有味道的代码的所有情况一样，将其固定在一种方法（或最多一个类）中，以免气味泄漏。

于 2010-05-07T16:51:34.100 回答
20

正如评论中强调的那样，访问者模式将是一个不错的选择。但是如果不直接控制目标/接受者/访问者，您就无法实现该模式。即使您无法通过使用包装器直接控制子类（以 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这里有那么糟糕的气味，特别是如果它仅限于一种方法并且我很乐意使用它（可能超过我自己上面的建议）。正如您所说，它非常易读、类型安全且可维护。一如既往，保持简单。

于 2010-05-07T20:02:09.220 回答
17

if您可以将处理的实例放在地图中（键：类，值：处理程序），而不是巨大的 。

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

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

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

于 2010-06-05T22:43:01.780 回答
15

您可以使用反射：

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...
}

您可以扩展该想法以通用处理实现某些接口的子类和类。

于 2011-01-14T16:13:05.470 回答
10

我认为最好的解决方案是 HashMap，以 Class 为 key， Handler 为 value。请注意，基于 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

于 2014-12-19T13:39:24.220 回答
9

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

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<StuffHandler>在您的调度程序类中添加一个，并让它遍历列表直到handle()返回 true）。

于 2010-06-06T04:21:51.603 回答
7

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

于 2012-07-18T23:37:54.513 回答
0

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

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

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

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

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

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

于 2015-08-26T15:29:38.187 回答
0

在 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(obj.classType()){
    case SubClass1:
        // do subclass1 task
        break;
    case SubClass2:
        // do subclass2 task
        break;
}
于 2020-09-05T06:13:56.410 回答