Java Exception Handling

• An exception can be anything that interrupts the normal flow of the program.
• When an exception occurs program processing gets terminated and doesn't continue further.
• In such cases we get a system-generated error message.
• Exception can occur at runtime.
• Reasons for Exceptions can include opening a non-existing file, network connection problem, class file missing which was supposed to be loaded, etc.
• The difference between error and exception is that errors indicate serious problems and abnormal conditions that most applications should not try to handle, while exceptions are conditions within the code.
• To terminate the program normally and to give a user-friendly error message to the user we have to handle the exceptions.
• Exception handling using a try…catch block is the way to do this.
• A try block must be followed by a catch block, or finally block, or both.
• A catch block associated with a try block executes if an exception of a particular type occurs within the try block.
• The syntax of try catch in Java is as follows:
• try { //statements that may cause an exception } catch (exception_type) { //error handling code }
• The flow of a try catch block is as follows:
• If an exception occurs in try block, the control of execution is passed to the catch block from try block.
• The exception is caught up by the corresponding catch block.
• If the try block is not throwing any exception, the catch block will be completely ignored and the program continues.
• If the try block throws an exception, the appropriate catch block (if one exists) will catch it.
• All the statements in the catch block will be executed.
• System generated exceptions are automatically thrown by the Java run time system. To manually throw an exception, we use the keyword throw.
• Since exceptions in Java are type of Throwable, all Java methods use throw statement to throw an exception.
• The throw statements required Throwable objects.
• The exception class is the base class for all exception classes.
• Types of Exceptions include checked exceptions (those that extend the Throwable class) and unchecked exceptions (those that extend RuntimeException).
• It is important to declare any exceptions that a method might throw in the throws clause of the method if the compiler has been configured to check for them.
• A try block can be followed by multiple catch blocks.
• Each catch block must contain a different exception handler.
• If an exception occurs in the try block then an exception is passed to the first catch block in the list.
• If an exception type matches with the first catch block it gets caught, if not the exception is passed down to the next catch block.
• The finally block in Java is used to put important codes such as clean up code.
• The finally block executes whether exception rise or not and whether exception handled or not.
• A finally contains all the crucial statements regardless of the exception occurs or not.

Test your knowledge about exception handling in Java with this quiz. Learn about the syntax of try-catch blocks, the role of catch and finally blocks, types of exceptions, handling system-generated and manually thrown exceptions, and the importance of declaring exceptions in the throws clause of a method.