Java中的致命异常处理

Question

I am creating a basic math parser with Java and doing this is revealing my shallow understanding of Java exception handling.

when I have this input:

String mathExpression = "(3+5";

and I subsequently call:

throw new MissingRightParenException();

the IDE forces me to surround with a try/catch like so:

             try {
                    throw new MissingRightParenException();
                } catch (MissingRightParenException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();

                }

however, in order to force this to be a fatal exception, it looks like I have to add my own code to call System.exit() , like so:

             try {
                    throw new MissingRightParenException();
                } catch (MissingRightParenException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    System.exit(0);
                }

I am not sure I understand the syntax behind all of this, especially why I have to use a try/catch block around throwing an exception.

what is the rhyme and reason behind this?

Instead of throwing the exception, I could do this instead:

new MissingRightParenException();

instead of calling

throw new MissingRightParenException();

so I guess my question is - if this is a fatal exception, what is the best way to make it truly fatal while giving the user the best feedback?

Answer 1

If you want to have a checked exception that you have to catch - but not right away - then you can define throws MissingRightParenException in the signature of your methods.

class MissingRightParenException extends CalculationException {
    ...
}

class CalculationException extends Exception {
    ...
}

class MyClass {

    int myMathRelatedMethod(String calculation) throws CalculationException {
        ...
        if (somethingWrong) {
            throw new MissingRightParenException("Missing right paren for left paren at location: " + location);
        }
        ...
    }

    public static void main(String ... args) {        
        ...
        try {
            myMathRelatedMethod(args[0]);
        } catch (CalculationException e) {
            // stack trace not needed maybe
            System.err.println(e.getMessage());
        }
        ...
    }
}

You can also define it as the cause of a RuntimeException but that doesn't seem a good match for your current problem.

try {
     ...
     throw new MissingRightParenException();
     ...
} catch (MissingRightParenException e) {
     // IllegalStateException extends (IS_A) RuntimeException
     throw new IllegalStateException("This should never happen", e);
}

If your MissingRightParenException class extends RuntimeException then you don't have to catch it. The message will fall through all methods where it (or it's parent classes such as Throwable , Exception and RuntimeException ) is not explicitly caught. You should however not use RuntimeException s for input related errors.

Usually the user will get the stack trace or at least the error message, although that depends of course or the error handling further down the line. Note that even main does not have to handle exceptions. You can just specify throws Exception for the main method to let the console receive the stack traces.

So in the end: use throws in the signature of your methods instead of catching exceptions before you want to handle them.

Answer 2

Assuming that your exception is currently a subclass of Exception, which is a Checked Exception, you need to handle in a try catch. If you can make your exception a RunTimeException, you no longer need to do the try-catch stuffs.

Answer 3

what is the best way to make it truly fatal while giving the user the best feedback?

Personally, I don't think a missing parenthesis should be a Fatal exception. The user should have the possibility to re-try.

However, if you really want to know, It is not possible with java to create a custom fatal exception as fatal exception means something went wrong on the system/jvm, not on the program itself. Still, you should change System.exit(0) to System.exit(1) or anything not equal to 0 as a program exiting with 0 as error code mean everything went right which is not the definition of an exception.

I am not sure I understand the syntax behind all of this

Basically what you do here is throw an exception so you have two choices, either catch it or re-throw it but anyway it will have to be caught somewhere. Then in the catch you simply end the program returning an error code meaning that something failed System.exit(1)

See this Difference in System. exit(0) , System.exit(-1), System.exit(1 ) in Java for a better understanding of error code.

Answer 4

If MissingRightParenException is a checked exception (that seems to be the case, otherwise your IDE wouldn't be "nagging") then either you have to wrap it inside a try ... catch block or declare it via a throws clause in the method definition. The latter allows you to "bubble up" the exception and catch in the caller of your method throwing the MissingRightParenException exception.

Did you think about a throws clause?