需要更好地解释 Java 中的 try/catch/throw/throws 异常处理

Question

I am a little unsure about the difference between the try/catch, throw and throws in Java and every website seems to have an inhuman way of explaining it, I have tried the Oracle website but I just could not understand their explanation, is this correct?

Try/catch

With try catch, I want to try a piece of code and if something goes wrong do this.

Throw

With throw, I am throwing an error because I want to? So if I wanted to validate a users age, say all people over 20 and the user does not meet the requirements, I would throw an error?

Throws

With Throws I am throwing an error but something else handles the exception? Would this be another method/class?

Answer 1

Try / Catch

try
{
    // try to do some actions
}
catch(SomeExceptionType exception)
{
    // if the above actions throw a SomeExceptionType, do these actions
}

Throw

Correct. We're explicitly throwing an exception. You may do this if, for example, the caller of a method has violated your method's contract. Perhaps an argument cannot be negative.

In this situation, the best way to deal with this is to throw an exception which stops what we're doing and allows callers further up the stack to deal with the problem:

/** Do a thing. myInt must be positive */
void someMethod(Integer myInt)
{
    if (myInt < 0)
    {
        throw new IllegalArgumentException("Can't be negative");
    }
    // do something
}

void myCaller()
{
    someMethod( 1); // won't throw
    someMethod(-1); // will throw
}

Throws

throws is used as a keyword when dealing with checked exceptions . It's a way of letting callers know what checked exceptions they can expect they may have to deal with.

Those methods can decide to deal with the problem (ie a try-catch) or can themselves declare the same exception type to be thrown to propagate the exception up to their caller (and so on and so on)

Answer 2

You forget a important point : in Java all exceptions are not handled by the compiler in the same way.

The compiler ensures only that the checked exceptions be handled.
These exceptions don't inherit from RuntimeException but from Exception (directly or indirectly).

So whatever you throw in your code or a method of a third class declares throwing a checked exception, you have to explicitly handle it.

And there you have two ways :

• catching the exception

• letting the exception be propagated to the caller

try/catch addresses the first way while specifying the throws modifier in the method declaration addresses the second.

For no RunTimeException s, you don't have this constraint as the compiler doesn't force you to handle it. You may handle them if you want to.