Default Exception in Java

Exception Handling in Java is one of the effective means to handle runtime errors so that the regular flow of the application can be preserved. Java Exception Handling is a mechanism to handle runtime errors such as ClassNotFoundException, IOException, SQLException, RemoteException, etc.

In Java, exception is an unwanted or unexpected event that occurs during the execution of a program, i.e. at run time, that disrupts the normal flow of the program's instructions. Exceptions can be caught and handled by the program. When an exception occurs within a method, it creates an object. The object is called the exception object. It contains information about the exception, such as the name and description of the exception and the state of the program when the exception occurred.

Why an Exception Occurs?

Invalid user input
Device failure
Loss of network connection
Physical limitations (out-of-disk memory)
Code errors
Opening an unavailable file

Errors represent irrecoverable conditions such as Java virtual machine (JVM) running out of memory, memory leaks, stack overflow errors, library incompatibility, infinite recursion, etc. Errors are usually beyond the control of the programmer, and we should not try to handle errors.

Exception Hierarchy

All exception and error types are subclasses of the class Throwable, which is the base class of the hierarchy. One branch is headed by Exception. This class is used for exceptional conditions that user programs should catch. NullPointerException is an example of such an exception. Another branch, Error is used by the Java run-time system(JVM) to indicate errors having to do with the run-time environment itself(JRE). StackOverflowError is an example of such an error.

Let us discuss the above-defined listed exception that is as follows:

1. Built-in Exceptions

Built-in exceptions are the exceptions that are available in Java libraries. These exceptions are suitable to explain certain error situations.

2. Checked Exceptions

Checked exceptions are called compile-time exceptions because these exceptions are checked at compile-time by the compiler.

3. Unchecked Exceptions

The unchecked exceptions are just opposite to the checked exceptions. The compiler will not check these exceptions at compile time. In simple words, if a program throws an unchecked exception, and even if we didn't handle or declare it, the program would not give a compilation error.

4. User-Defined Exceptions

Sometimes, the built-in exceptions in Java are not able to describe a certain situation. In such cases, users can also create exceptions, which are called user-defined Exceptions.

The advantages of Exception Handling in Java are as follows:

Provision to Complete Program Execution
Easy Identification of Program Code and Error-Handling Code
Propagation of Errors
Meaningful Error Reporting
Identifying Error Types

Methods to Print the Exception Message

1. printStackTrace() Method

The method prints exception information in the format of the Name of the exception: description of the exception, stack trace.

Exception.java

//program to print the exception information using printStackTrace() method 
import java.io.*; 
class Exception { 
	public static void main (String[] args) { 
	int a=5; 
	int b=0; 
		try{ 
		System.out.println(a/b); 
		} 
	catch(ArithmeticException e){ 
		e.printStackTrace(); 
	} 
	} 
}

Output:

java.lang.ArithmeticException: / by zero
at Exception.main(File.java:10)

2. toString() Method

The toString() method prints exception information in the format of the Name of the exception: description of the exception.

ToString.java

//program to print the exception information using toString() method 
import java.io.*; 
class ToString { 
	public static void main (String[] args) { 
	int a=5; 
	int b=0; 
		try{ 
		System.out.println(a/b); 
		} 
	catch(ArithmeticException e){ 
		System.out.println(e.toString()); 
	} 
	} 
}

Output:

java.lang.ArithmeticException: / by zero

3. getMessage() Method

The getMessage() method prints only the description of the exception.

GetMessage.java

//program to print the exception information using getMessage() method 
import java.io.*; 
class GetMessage { 
	public static void main (String[] args) { 
	int a=5; 
	int b=0; 
		try{ 
		System.out.println(a/b); 
		} 
	catch(ArithmeticException e){ 
		System.out.println(e.getMessage()); 
	} 
	} 
}

Output:

Zero

Default Exception Handling

The default exception handler is a method that is called when an exception is thrown but not caught by any of the exception handlers in the call stack.

Whenever inside a method, if an exception has occurred, the method creates an Object known as an Exception Object and hands it off to the run-time system(JVM). The exception object contains the name and description of the exception and the current state of the program where the exception has occurred. Creating the Exception Object and handling it in 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 occurred. This ordered list of 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 the exception occurred and proceeds through the 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. An appropriate handler means the type of exception object thrown matches the type of 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.

The default exception handler is defined in the ThreadGroup class and has the following signature

public void uncaughtException(Thread t, Throwable e)

The uncaughtException() method takes two parameters:

t - The thread that threw the exception.
e - The exception object.

The default exception handler simply prints the exception class name, exception description, and stack trace to the console and then terminates the program abnormally.

Here is the default exception example.

DefaultException.java

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class DefaultException {
    public static void main(String[] args) {
        File logFile = new File("error.log");
        LoggingThreadGroup threadGroup = new LoggingThreadGroup("MyThreadGroup", logFile);
        // Create a thread in the custom thread group
        Thread thread = new Thread(threadGroup, new Runnable() {
            @Override
            public void run() {
                // Simulate an uncaught exception
                throw new RuntimeException("Something went wrong!");
            }
        });
        thread.start();
    }
}

Output:

Uncaught exception in thread Thread-0
Something went wrong!
[Ljava.lang.StackTraceElement;@1d251891

Default exceptions in Java play a crucial role in exception handling but have both benefits and drawbacks to consider.

Advantages of Default Exception

Simplicity

Uncaught exceptions automatically propagate up the call stack, requiring no explicit handling beyond the default behaviour. It can be helpful for simple programs or prototypes.

Robustness

Default exception handling prevents programs from silently ignoring potentially critical errors, forcing developers to address them at some point.

Clear error reporting

The default handler prints the stack trace, providing valuable information for debugging and identifying the source of the problem.

Drawbacks

Unpredictability Uncontrolled propagation can lead to unexpected program termination, making debugging more challenging.

Limited information

The default message of Exception in thread... provides basic information but lacks details about the specific error cause.

Lack of customization

Default handling offers no opportunity to tailor the response to different types of exceptions, potentially impacting user experience or data integrity.

Next TopicHow to Install Multiple JDK's in Windows

← prev next →