Exception handling is a mechanism in Java that allows you to handle runtime errors so that the normal flow of the application can be maintained. When an exception occurs, the program does not terminate abruptly. Instead, the exception is handled by a block of code called a try-catch block.
An Example of Exception Handling
Here is an example of exception handling using Java try-catch block:
public class TryCatchExample {
public static void main(String[] args) {
try {
int data = 50 / 0; //may throw exception.
} catch (ArithmeticException e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
}In this example, the main() method tries to divide the number 50 by 0. This will cause an ArithmeticException to be thrown. The try block catches the exception and prints a message to the console.
The catch block takes an Exception object as an argument. This object contains information about the exception, such as the type of exception and the message that was associated with the exception. The getMessage() method of the Exception object can be used to get the message that was associated with the exception.
Exception Hierarchy
The exception hierarchy is a tree-like structure that represents the relationship between different types of exceptions. The top of the hierarchy is the Throwable class. All other exceptions in Java are subclasses of Throwable.
Error
Errors are unexpected conditions that are usually caused by problems with the Java Virtual Machine (JVM) or the operating system. Errors are not recoverable, so they should not be handled by the application.
Here are some examples of errors:
- StackOverflowError: This error occurs when a method calls itself recursively too many times.
- OutOfMemoryError: This error occurs when the JVM runs out of memory.
- VirtualMachineError: This error occurs when the JVM encounters a fatal error.
When an error occurs, the JVM will print an error message to the console and terminate the application. The application should not try to handle errors, as this may lead to unexpected behavior.
Exception
Exceptions are unexpected conditions that can be caused by problems with the application code. Exceptions can be handled by the application, which allows the normal flow of the application to be maintained.
The Exception class has many subclasses, each of which represents a specific type of exception. Some of the most common types of Java exceptions are ArithmeticException, ArrayIndexOutOfBoundsException, NullPointerException, and IOException. Let us see a bit of detailed information about each of these.
- ArithmeticException: This exception is thrown when an arithmetic operation results in an error, such as dividing by zero.
- ArrayIndexOutOfBoundsException: This exception is thrown when an array is accessed with an index that is out of bounds.
- NullPointerException: This exception is thrown when a reference variable is used to access a null object.
- IOException: This exception is thrown when an input/output operation fails.
Writing Custom Exceptions
To write your own exceptions, you can extend the Exception class or one of its subclasses. When you extend a class, you inherit all of its methods and properties. This means that your custom exception will have all of the same functionality as the exception class it extends.
Here is an example of how to write a custom exception:
class MyException extends Exception {
public MyException(String message) {
super(message);
}
}This code creates a custom exception class called MyException. The MyException class extends the Exception class, which means that it inherits all of the methods and properties of the Exception class. The MyException class also has a constructor that takes a String message as an argument. This message is used to provide more information about the exception when it is thrown.
Here is an example of how to use the MyException class:
try {
// Do something that might throw an exception
} catch (MyException e) {
// Handle the exception
}This code tries to do something that might throw an exception. If an exception is thrown, the catch block will be executed. The catch block will have access to the exception object, which can be used to get more information about the exception.
Difference between Throw and Throws Keywords
The throw and throws keywords are used in Java to handle exceptions. The throw keyword is used to explicitly throw an exception, while the throws keyword is used to declare that a method can throw an exception.
The throw keyword is used to explicitly throw an exception. It is used in the body of a method, and it takes an instance of an exception class as its argument. The exception will then be propagated up the call stack until it is handled by a catch block.
For example, the following code will throw an ArithmeticException if the value of x is 0:
public void divide(int x, int y) {
if (y == 0) {
throw new ArithmeticException("Division by zero");
}
int result = x / y;
System.out.println(result);
}The throws keyword is used to declare that a method can throw an exception. It is used in the method signature, and it lists the types of exceptions that the method can throw. The compiler will then require that the method either handle these exceptions itself or that it declare that it throws them so that the caller of the method can handle them.
For example, the following method declaration declares that the divide() method can throw an ArithmeticException:
public int divide(int x, int y) throws ArithmeticException {
// ...
}The following table summarizes the key differences between the throw and throws keywords:
| Feature | throw | throws |
|---|---|---|
| Purpose | Used to explicitly throw an exception | Used to declare that a method can throw an exception |
| Location | Used in the body of a method | Used in the method signature |
| Argument | Takes an instance of an exception class as its argument | Does not take any arguments |
| Effect | Propagates an exception up the call stack | Does not propagate an exception |
| Required | Not required | Required for methods that can throw checked exceptions |
When to use throw and throws keywords
The throw and throws keywords should be used as follows:
- The throw keyword should be used to explicitly throw an exception when the exception is not expected to occur frequently, or when the exception is not something that can be easily handled by the caller of the method.
- The throws keyword should be used to declare that a method can throw an exception when the exception is expected to occur frequently, or when the exception is something that can be easily handled by the caller of the method.
By using the throw and throws keywords correctly, you can help to improve the readability and maintainability of your Java code.
Java finally block
In Java, a finally block is a block of code that is always executed, regardless of whether or not an exception is thrown. It is used to perform cleanup tasks, such as closing files or releasing resources. The finally block is always executed, even if the try block is exited by a return, break, or continue statement. This ensures that cleanup tasks are always performed, even if an exception is thrown.
Here is an example of a finally block:
try {
// Do something
} catch (Exception e) {
// Handle the exception
} finally {
// Close any files or release any resources
}A practical example:
try {
// Open a file
FileInputStream fis = new FileInputStream("myfile.txt");
// Read data from the file
byte[] data = new byte[1024];
int bytesRead = fis.read(data);
// Do something with the data
// ...
} catch (IOException e) {
// Handle the exception
} finally {
// Close the file
fis.close();
}In this example, the finally block ensures that the file is closed, even if an exception is thrown while reading from the file. This is important, because if the file is not closed, it may not be properly closed and the data may be lost.
The finally block is a block of code that is always executed, regardless of whether or not an exception is thrown. It is used to perform cleanup tasks, such as closing files or releasing resources.
The finally block is a powerful tool that can be used to ensure that cleanup tasks are always performed. It is a good practice to use a finally block whenever you are working with resources that need to be closed or released.
How to avoid exceptions in Java?
here are some tips on how to avoid exceptions in Java:
- Check for null values. NullPointerException is one of the most common exceptions in Java. You can avoid it by checking for null values before using them.
- Use try-catch blocks. Try-catch blocks allow you to handle exceptions gracefully. If an exception is thrown, the try-catch block will catch it and you can take appropriate action.
- Use finally blocks. Finally blocks are always executed, even if an exception is thrown. This means that you can use them to clean up resources, such as closing files or releasing database connections.
- Use assertions. Assertions are a way of checking for errors at runtime. They can be used to help you find and fix bugs before they cause exceptions.
- Use exception chaining. Exception chaining allows you to combine multiple exceptions into a single exception. This can be useful for debugging and logging exceptions.
- Use defensive programming techniques. Defensive programming is a way of writing code that is more resistant to errors. It involves using techniques such as checking for null values, using try-catch blocks, and using assertions.
- Write unit tests. Unit tests are a way of testing your code for errors. They can help you to find and fix bugs before they cause exceptions.
- Use a code review process. A code review process is a way of having another developer review your code for errors. This can help you to find and fix bugs before they cause exceptions.
Further Readings
- https://docs.oracle.com/javase/tutorial/essential/exceptions/
- Some Questions and exercises – https://docs.oracle.com/javase/tutorial/essential/exceptions/QandE/questions.html
- https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
- Our other blog on Checked and Unchecked Exceptions: An Interesting Tale of the Duo!
Feel free to share your thoughts on this topic in the comments section below 👇 We would be happy to hear and discuss the same 🙂
