Exception Handling in Java with try, catch, finally

In this post, we will explore the mechanics of exception handling in the Java programming language. Exception handling is a crucial mechanism designed to manage runtime errors without compromising the main flow of an application. An exception denotes an unexpected event during program execution, disrupting the usual sequence of operations. Java Exception Handling provides a robust and object-oriented approach to address these exceptional scenarios.

An exception represents an undesired occurrence that takes place during program execution, specifically at runtime, causing a deviation from the regular flow of program instructions. Java’s exception handling mechanism is adept at addressing such unexpected events, allowing the program to navigate an alternative flow to handle the exception appropriately before returning to the primary application flow.

Type of Exceptions

In Java, exceptions are categorized into two types: built-in and user-defined.

  1. Built-in Exception:
    • Definition: Built-in exceptions are part of the Java libraries and are thrown when errors occur while invoking Java class methods or when the Java program encounters an error.
    • Usage: These exceptions are automatically thrown by the Java runtime environment in response to various error conditions.
  2. User-defined Exception:
    • Definition: User-defined exceptions are customized exceptions created by extending classes such as Throwable, Exception, Error, etc.
    • Creation: Developers can design their own exception classes by extending the appropriate base class and throwing instances of these exceptions in their applications.
    • Handling: User-defined exceptions should be thrown deliberately by the application when specific error conditions arise and then handled in the application code accordingly.

Built-in exceptions in Java can be further categorized into two types: checked exceptions and unchecked exceptions.

  1. Checked Exceptions:
    • Definition: Checked exceptions are exceptions that the compiler forces the application to catch or declare in the method signature.
    • Handling: If a method throws a checked exception, the calling code must either catch the exception using a try-catch block or declare that it throws the exception using the throws clause.
    • Compile-time: Checked exceptions result in compile-time errors if they are not handled in the code.
  2. Unchecked Exceptions (Runtime Exceptions):
    • Definition: Unchecked exceptions, also known as runtime exceptions, are exceptions that occur during runtime and are not explicitly checked by the compiler.
    • Handling: The compiler does not enforce catching or declaring unchecked exceptions. Developers can choose to handle them but are not required to do so.
    • Runtime: Unchecked exceptions can occur during the execution of the program. If not handled properly, they can lead to the application crashing without prior warning.

Try Catch Block

Exception handling in Java involves the utilization of the try-catch block, providing a structured approach to manage potential errors during program execution. The try block encapsulates the code segment where exceptions might occur, ensuring its execution regardless of whether an exception is thrown. Conversely, the catch block contains code specifically designed to handle a particular type of exception thrown within the associated try block.

package com.test;

public class JavaTest {

	public static void main(String[] args) {
		int a = 0;
		try {
			a = 5/0;
		} catch (ArithmeticException e) {
			a =0;
		}
		System.out.println(a);
	}
}

Here, the catch block is activated only if an exception of type ExceptionType arises in the corresponding try block. Multiple catch blocks can be employed for diverse exception types, enabling tailored responses to different error scenarios. Effectively employing try-catch blocks is integral to enhancing code resilience, mitigating potential disruptions caused by unexpected errors.

Try Catch Finally Block

In addition to the try and catch blocks, the finally block plays a crucial role in ensuring specific code is executed regardless of whether an exception occurs or not. After an error triggers the catch block, the subsequent code in the try block will not be executed. To handle situations where certain actions must be taken regardless of the outcome, the finally block is employed. Irrespective of whether the try or catch block is executed, the code within the finally block will be executed. The example below illustrates the usage of the try, catch, and finally blocks:

package com.test;

public class JavaTest {

	public static void main(String[] args) {
		int a = 0;
		try {
			a = 5/0;
		} catch (ArithmeticException e) {
			a =0;
		} finally {
			System.out.println(a);
		}
	}
}

In this construct, the finally block ensures the specified actions are taken, providing a mechanism for necessary cleanup or finalization tasks.

Try Finally block

An alternative approach to structuring code within a Java method involves utilizing the try–finally block. In this setup, the try block is executed, and any potential errors are handled within the block. Regardless of whether an exception occurs or not, the code within the finally block is executed before transferring control back to the calling method. The example below illustrates the implementation of the try–finally block:

package com.test;

public class JavaTest {

	public static void main(String[] args) {
		try {
			callmethod();
		} catch (ArithmeticException e) {
			System.out.println("Exception is thrown");
		}
	}
	
	public static void callmethod() {
		int a = 0;
		try {
			a = 5/0;
		} finally {
			System.out.println(a);
		}
		
	}
}

This construct allows for essential cleanup or finalization tasks within the finally block, ensuring that specific actions are taken before returning control to the calling method. If an exception occurs in the try block, it will be thrown to the calling method after the finally block is executed.

Leave a Reply