While a JSP page is executing and processing client requests, runtime errors can occur either inside the page or outside the page (such as in a called JavaBean). This section describes the JSP error processing mechanism and provides a simple example.

There are two ways of handling exceptions in JSP. They are: By errorPage and isErrorPage attributes of page directive. By element in web.

Exception Handling is the process to handle the runtime errors. There may occur exception any time in your web application. In JSP, there are two ways to perform exception handling: By errorPage and isErrorPage attributes of page directive. By element in web.

The Runtime Exception is the parent class in all exceptions of the Java programming language that are expected to crash or break down the program or application when they occur. A user should not attempt to handle this kind of an exception because it will only patch the problem and not completely fix it.

There are two types of exceptions: checked exception and unchecked exception. The main difference between checked and unchecked exception is that the checked exceptions are checked at compile-time while unchecked exceptions are checked at runtime.

You can handle checked/unchecked exceptions the same way (with try/catch/throws), the difference just lies in the checks the compiler performs. This post has a decent example. Yes you can handle the unchecked exception but not compulsory.

Answer: The exception java. lang. NullPointerException is an unchecked exception and extends RuntimeException class. Hence there is no compulsion for the programmer to catch it.

If your code does not handle and exception when it is thrown, this prints an error message and crashes the program.

2.2. FileNotFoundException is a checked exception in Java. Anytime, we want to read a file from filesystem, Java forces us to handle error situation where file may not be present in place. In above case, you will get compile time error with message – Unhandled exception type FileNotFoundException .

Having to add runtime exceptions in every method declaration would reduce a program’s clarity. Thus, the compiler does not require that you catch or specify runtime exceptions (although you can). If an argument is null, the method might throw a NullPointerException , which is an unchecked exception.

Difference between Checked and Unchecked Exception Checked Exceptions are checked at runtime of the program, while Unchecked Exceptions are checked at the compile time of the program. Checked Exceptions and Unchecked Exceptions both can be handled using try, catch and finally.

It is up to the programmers to be civilized, and specify or catch the exceptions. In Java exceptions under Error and RuntimeException classes are unchecked exceptions, everything else under throwable is checked. Consider the following Java program. It compiles fine, but it throws ArithmeticException when run.

Some common unchecked exceptions in Java are NullPointerException, ArrayIndexOutOfBoundsException, and IllegalArgumentException.

Yes, we can have an empty catch block. But this is a bad practice to implement in Java. Generally, the try block has the code which is capable of producing exceptions, if anything wrong in the try block, for instance, divide by zero, file not found, etc. It will generate an exception that is caught by the catch block.

Further, since a blank line / empty body is totally ok, no exceptions will be thrown in the body of the try block during runtime, so the code would execute just fine as well.

What happens if an exception is not caught? If an exception is not caught (with a catch block), the runtime system will abort the program (i.e. crash) and an exception message will print to the console.

AVOID empty catch blocks. In general, empty catch blocks should be avoided. In cases where they are intended, a comment should be provided to explain why exceptions are being caught and suppressed. Alternatively, the exception identifier can be named with underscores (e.g., _ ) to indicate that we intend to skip it.

The try-catch is the simplest method of handling exceptions. Put the code you want to run in the try block, and any Java exceptions that the code throws are caught by one or more catch blocks. This method will catch any type of Java exceptions that get thrown. This is the simplest mechanism for handling exceptions.

When exception is thrown by main() method, Java Runtime terminates the program and print the exception message and stack trace in system console. If a non-checked exception is thrown (and not catch) in the main method, it will also terminate.

A finally block must be associated with a try block, you cannot use finally without a try block. You should place those statements in this block that must be executed always. However if an exception occurs then the catch block is executed before finally block.