Question

我在变量中有一个异常（没有抛出）。

什么是最好的选择？

Exception exception = someObj.getExcp();
try {
    throw exception;
} catch (ExceptionExample1 e) {
    e.getSomeCustomViolations();
} catch (ExceptionExample2 e) {
    e.getSomeOtherCustomViolations(); 
}

或

Exception exception = someObj.getExcp();
if (exception instanceof ExceptionExample1) {
    exception.getSomeCustomViolations();
} else if (exception instanceof ExceptionExample2) {
    exception.getSomeOtherCustomViolations();
}

Answer 1

我建议使用instanceof因为它可能会更快。抛出异常是一项复杂而昂贵的操作。在不发生异常的情况下，JVM经过优化，可以快速进行。例外应该是例外。

请注意，throw技术可能无法编译，如果您的异常类型是已检查的异常，编译器会抱怨您必须捕获该类型或将其声明为抛出（对应于{{ 1}}子句，如果使用else { ... }技术），可能会或可能没有帮助，这取决于您希望如何处理不属于某个特定子类型的异常。

Answer 2

讨厌破坏所有人的泡沫，但使用try/catch 更快。这并不是说它是正确的＆＃34;方式，但如果表现是关键，那么这就是胜利者。以下是来自以下计划的结果：

运行1

子运行1：实例：130毫秒
子运行1：尝试/捕获：118毫秒
子运行2：实例：96毫秒
子运行2：尝试/捕获：93毫秒
子运行3：实例：100毫秒
子运行3：尝试/捕获：99毫秒

运行2

子运行1：实例：140毫秒
子运行1：尝试/捕获：111毫秒
子运行2：实例：92毫秒
子跑2：尝试/捕捉：92毫秒
子运行3：实例：105毫秒
子运行3：尝试/捕获：95毫秒

运行3

子运行1：实例：140毫秒
子运行1：尝试/捕获：135毫秒
子运行2：实例：107毫秒
子运行2：尝试/捕获：88毫秒
子运行3：实例：96毫秒
子运行3：尝试/捕获：90毫秒

测试环境

Java：1.7.0_45
Mac OSX Mavericks

对每次运行的预热子运行进行折扣instanceof方法最多只能实现try/catch的性能。 instanceof方法的平均值（折扣热身）为98毫秒，try/catch的平均值为92毫秒。

请注意，我没有改变每种方法的测试顺序。我总是测试一块instanceof然后一块try/catch。我希望看到其他结果与这些发现相矛盾或确认。

public class test {

    public static void main (String [] args) throws Exception {
        long start = 0L;
        int who_cares = 0; // Used to prevent compiler optimization
        int tests = 100000;

        for ( int i = 0; i < 3; ++i ) {
            System.out.println("Testing instanceof");
            start = System.currentTimeMillis();
            testInstanceOf(who_cares, tests);
            System.out.println("instanceof completed in "+(System.currentTimeMillis()-start)+" ms "+who_cares);

            System.out.println("Testing try/catch");
            start = System.currentTimeMillis();
            testTryCatch(who_cares, tests);
            System.out.println("try/catch completed in "+(System.currentTimeMillis()-start)+" ms"+who_cares);
        }
    }

    private static int testInstanceOf(int who_cares, int tests) {
        for ( int i = 0; i < tests; ++i ) {
            Exception ex = (new Tester()).getException();
            if ( ex instanceof Ex1 ) {
                who_cares = 1;
            } else if ( ex instanceof Ex2 ) {
                who_cares = 2;
            }
        }
        return who_cares;
    }

    private static int testTryCatch(int who_cares, int tests) {
        for ( int i = 0; i < tests; ++i ) {
            Exception ex = (new Tester()).getException();
            try {
                throw ex;
            } catch ( Ex1 ex1 ) {
                who_cares = 1;
            } catch ( Ex2 ex2 ) {
                who_cares = 2;
            } catch ( Exception e ) {}
        }
        return who_cares;
    }

    private static class Ex1 extends Exception {}

    private static class Ex2 extends Exception {}

    private static java.util.Random rand = new java.util.Random();

    private static class Tester {
        private Exception ex;
        public Tester() {
            if ( rand.nextBoolean() ) {
                ex = new Ex1();
            } else {
                ex = new Ex2();
            }
        }
        public Exception getException() {
            return ex;
        }
    }
}

Answer 3

我强烈建议您实际使用普通对象来表示“约束”。标记界面（例如Message）或java.lang.String是否取决于您。例外并不意味着按照你的意图使用，即使其中任何一个都可以使用（我希望第二个更快，但过早优化......）。

Answer 4

您还可以通过为包含getCustomViolation（）方法的自定义异常创建接口来使用多态。然后每个Custom异常都会实现该接口和该方法。

抛出并捕获异常，或使用instanceof？

4 个答案: