Java 内部的异常处理是如何工作的？

Question

try 
{
}
catch(ExceptionType name)
{
}

One thing that I'm particularly unable to understand is the argument of Catch Block. We write " catch(ExceptionType name) " What exactly is " name " though? If " ExceptionType " is class, shouldn't " name " be reference to an object? Even if it is a reference, since we haven't created any object, what exactly does it contain?

Now I have come up with this theory regarding Exception Handling - please correct me I'm getting it wrong.

CASE 1 - SUPPOSING NO TRY, CATCH BLOCK EXISTS - If an error occurs, the exception handler automatically generates an exception object[based on exception's class] and hands it over to the JVM and then JVM then returns the function or crashing error to be displayed at the run-time

CASE 2 - IF PROGRAMMER HAS WRITTEN A TRY CATCH BLOCK - If an error occurs, the exception handler generates an exception object[based on exception's class] and then instead of going to the JVM, it will first look into the catch block and try to match the reference variable to the exception object. If the match happens, exception handler hands that object to the catch block reference and then programmer can return the function of his or her choice. However, if the match does not happen, exception handler will hand that exception object back to the JVM.

Is this how Exception Handling work?

Answer 1

What exactly is " name " though?

name is like a local variable , that is assigned the exception that was thrown. Or you can think of it as a method parameter.

If " ExceptionType " is class, shouldn't "name" be reference to an object?

Both are: ExceptionType is a class, and name is an object reference.

we haven't created any object, what exactly does it contain?

Whatever logic that threw the exception, created it using the new operator, which is why the throw statement is almost always immediately followed by the new operator, eg throw new IllegalArgumentException() .

If it's a built-in exception (like NullPointerException , StackOverflowError , ArrayIndexOutOfBoundsException , etc.), the the JVM runtime created the exception.

CASE 1 - SUPPOSING NO TRY, CATCH BLOCK EXISTS
CASE 2 - IF PROGRAMMER HAS WRITTEN A TRY CATCH BLOCK
If an error occurs, the exception handler automatically generates an exception object ...

Your terminology is off: An "exception handler" is code that handles a thrown exception. See eg UncaughtExceptionHandler .

If an error occurs, an exception is created and thrown by the JVM runtime, regardless of whether or not there is a try-catch statement.

From there on, the handling of the exception is the same, regardless of whether the exception was thrown by the system, or us a user-defined exception thrown by the throw statement.

Answer 2

Let me explain How JVM handles an Exception? Whenever inside a method, if an exception has occurred, the method creates an Object known as Exception Object and hands it off to the run-time system(JVM). This exception object contains the details of that particular exception and the current state of the program where an exception has occurred. Creating the Exception Object and handling it to the run-time system is called throwing an Exception . There might be a list of the methods that had been called to get to the method where an exception has occurred. This ordered list of the methods is called Call Stack . Now the following procedure will happen.

• The run-time system searches the call stack to find the method that contains a block of code that can handle the occurred exception. The block of the code is called an Exception handler.
• The run-time system starts searching from the method in which exception occurred, proceeds through call stack in the reverse order in which methods were called.
• If it finds an appropriate handler then it passes the occurred exception to it. Appropriate handler means the type of the exception object thrown matches the type of the exception object it can handle.
• If the run-time system searches all the methods on the call stack and couldn't have found the appropriate handler then the run-time system handover the Exception Object to the default exception handler, which is part of the run-time system. This handler prints the exception information in the following format and terminates the program abnormally.

Now how flow control work in try catch finally block in java

1. Control flow in try-catch clause OR try-catch-finally clause: a. Case 1: Exception occurs in a try block and is handled in the catch block. b.Case 2: Exception that occurs in try-block is not handled in the catch block. c. Case 3: Exception doesn't occur in try-block

2. try-finally clause a. Case 1: Exception occurs in the try block. b.Case 2: Exception doesn't occur in try-block.

For more information regarding the flow control work in the try-catch-finally block you can refer to this link

Answer 3

If ExceptionType is class, shouldn't name be reference to an object? Even if it is a reference, since we haven't created any object, what exactly does it contain?

The simple answer to your question / misunderstanding is that catching an exception does NOT create an exception object. Rather, the exception object was created earlier .

When you do this:

 throw new SomeException("message");

the new is explicitly creating an exception object.

When you do this:

SomeClass foo = null;
foo.someMethod();

the JVM will create a NullPointerException object.

In either case, it will be those objects that are assigned to the variable in the catch clause; name in your example.

---

This also indirectly explains something else. When you call printStackTrace() on an exception object, it will (apparently) print the stack trace for the point at which the exception was thrown.

How does it manage this?

Well actually, what I said above was slightly incorrect. What it is actually printing is the stacktrace for the point at which the exception object was created! (The two points are usually the same, but not always.)

What actually happens is that when the exception object is created (by new , by the JVM, or by native code) the constructor for Throwable (the ancestor class of all exception classes) calls a method called fillInStackTrace() . This in turn calls an internal method that populates an array with the stack frame information for the current call context.

Answer 4

If I fully understood your question, this may be what you're looking for. Since Java is an interpreted language, when the JVM finds the correct error while executing the bytecode, it will jump to the bytecode for the block that you wrote in the except block, making a new SomeException() , which is basically an object of information about the error, and passes it as that local variable parameter, in your code ExceptionType name .

Referencing your example of no try / catch, it would have to just throw an error, print stack trace, and exit with an error, and no SomeException object is instantiated. Hope I can help. Some links that may be of interest are here , here , and maybe here (similar question) .