'instanceof'实际上是一个运算符，就像+或-，我相信它有自己的JVM字节码指令。应该够快了。

我不应该说，如果你有一个开关，你正在测试一个对象是否是某个子类的实例，那么你的设计可能需要重做。考虑将特定于子类的行为下推到子类本身。

现代JVM/JIT编译器已经消除了大多数传统的“慢”操作对性能的影响，包括instanceof、异常处理、反射等。

正如Donald Knuth所写的，“我们应该忘记小的效率，大约97%的时候:过早的优化是万恶之源。”instanceof的性能可能不是问题，所以在确定问题所在之前，不要浪费时间想出奇异的解决方案。

在现代Java版本中，instanceof操作符作为一个简单的方法调用更快。这意味着:

if(a instanceof AnyObject){
}

为:

if(a.getType() == XYZ){
}

另一件事是如果你需要级联许多instanceof。然后，只调用一次getType()的切换会更快。

在大多数现实世界的实现中(也就是说，在真正需要instanceof的实现中，您不能像每个初学者教科书和上面的Demian所建议的那样，通过重写一个通用方法来解决它)，instanceof可能会比简单的等号更昂贵。

为什么呢?因为可能会发生的情况是，你有几个接口，它们提供了一些功能(比如，接口x, y和z)，以及一些要操作的对象，这些对象可能(或不)实现其中一个接口……但不是直接的。例如，我有:

W扩展x

A实现了w

B延伸A

C扩展B，实现y

D扩展C，实现z

假设我正在处理D的一个实例，对象D . Computing (D instanceof x)需要采用d.getClass()，循环通过它实现的接口来知道是否一个是==到x，如果不是这样做，再次递归为它们的所有祖先… 在我们的例子中，如果你对那棵树进行宽度优先的探索，假设y和z没有扩展任何东西，至少会产生8个比较……

现实世界的推导树的复杂性可能更高。在某些情况下，JIT可以优化其中的大部分，如果它能够在所有可能的情况下，将d解析为扩展x的某个实例。然而，实际上，您大部分时间都将遍历该树。

如果这成为一个问题，我建议使用处理程序映射，将对象的具体类链接到进行处理的闭包。它删除了树遍历阶段，以支持直接映射。但是，要注意，如果你为C.class设置了一个处理程序，上面的对象d将不会被识别。

这是我的2美分，我希望他们能帮助…

我有同样的问题，但因为我没有找到类似于我的用例的“性能指标”，我做了一些更多的示例代码。在我的硬件和Java 6和7上，instanceof和switch在1000万次迭代上的区别是

for 10 child classes - instanceof: 1200ms vs switch: 470ms
for 5 child classes  - instanceof:  375ms vs switch: 204ms

因此，instanceof确实比较慢，特别是在大量的if-else-if语句上，但是在实际应用中差异可以忽略不计。

import java.util.Date;

public class InstanceOfVsEnum {

    public static int c1, c2, c3, c4, c5, c6, c7, c8, c9, cA;

    public static class Handler {
        public enum Type { Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, TypeA }
        protected Handler(Type type) { this.type = type; }
        public final Type type;

        public static void addHandlerInstanceOf(Handler h) {
            if( h instanceof H1) { c1++; }
            else if( h instanceof H2) { c2++; }
            else if( h instanceof H3) { c3++; }
            else if( h instanceof H4) { c4++; }
            else if( h instanceof H5) { c5++; }
            else if( h instanceof H6) { c6++; }
            else if( h instanceof H7) { c7++; }
            else if( h instanceof H8) { c8++; }
            else if( h instanceof H9) { c9++; }
            else if( h instanceof HA) { cA++; }
        }

        public static void addHandlerSwitch(Handler h) {
            switch( h.type ) {
                case Type1: c1++; break;
                case Type2: c2++; break;
                case Type3: c3++; break;
                case Type4: c4++; break;
                case Type5: c5++; break;
                case Type6: c6++; break;
                case Type7: c7++; break;
                case Type8: c8++; break;
                case Type9: c9++; break;
                case TypeA: cA++; break;
            }
        }
    }

    public static class H1 extends Handler { public H1() { super(Type.Type1); } }
    public static class H2 extends Handler { public H2() { super(Type.Type2); } }
    public static class H3 extends Handler { public H3() { super(Type.Type3); } }
    public static class H4 extends Handler { public H4() { super(Type.Type4); } }
    public static class H5 extends Handler { public H5() { super(Type.Type5); } }
    public static class H6 extends Handler { public H6() { super(Type.Type6); } }
    public static class H7 extends Handler { public H7() { super(Type.Type7); } }
    public static class H8 extends Handler { public H8() { super(Type.Type8); } }
    public static class H9 extends Handler { public H9() { super(Type.Type9); } }
    public static class HA extends Handler { public HA() { super(Type.TypeA); } }

    final static int cCycles = 10000000;

    public static void main(String[] args) {
        H1 h1 = new H1();
        H2 h2 = new H2();
        H3 h3 = new H3();
        H4 h4 = new H4();
        H5 h5 = new H5();
        H6 h6 = new H6();
        H7 h7 = new H7();
        H8 h8 = new H8();
        H9 h9 = new H9();
        HA hA = new HA();

        Date dtStart = new Date();
        for( int i = 0; i < cCycles; i++ ) {
            Handler.addHandlerInstanceOf(h1);
            Handler.addHandlerInstanceOf(h2);
            Handler.addHandlerInstanceOf(h3);
            Handler.addHandlerInstanceOf(h4);
            Handler.addHandlerInstanceOf(h5);
            Handler.addHandlerInstanceOf(h6);
            Handler.addHandlerInstanceOf(h7);
            Handler.addHandlerInstanceOf(h8);
            Handler.addHandlerInstanceOf(h9);
            Handler.addHandlerInstanceOf(hA);
        }
        System.out.println("Instance of - " + (new Date().getTime() - dtStart.getTime()));

        dtStart = new Date();
        for( int i = 0; i < cCycles; i++ ) {
            Handler.addHandlerSwitch(h1);
            Handler.addHandlerSwitch(h2);
            Handler.addHandlerSwitch(h3);
            Handler.addHandlerSwitch(h4);
            Handler.addHandlerSwitch(h5);
            Handler.addHandlerSwitch(h6);
            Handler.addHandlerSwitch(h7);
            Handler.addHandlerSwitch(h8);
            Handler.addHandlerSwitch(h9);
            Handler.addHandlerSwitch(hA);
        }
        System.out.println("Switch of - " + (new Date().getTime() - dtStart.getTime()));
    }
}

我也更喜欢枚举方法，但我将使用抽象基类强制子类实现getType()方法。

public abstract class Base
{
  protected enum TYPE
  {
    DERIVED_A, DERIVED_B
  }

  public abstract TYPE getType();

  class DerivedA extends Base
  {
    @Override
    public TYPE getType()
    {
      return TYPE.DERIVED_A;
    }
  }

  class DerivedB extends Base
  {
    @Override
    public TYPE getType()
    {
      return TYPE.DERIVED_B;
    }
  }
}