For example, in case of a train reservation application, a passenger must specify the destination. Also, a ticket has to be bought for a passenger who is above three years of age.

Similarly, in the case of a banking application, if a customer is below 18 years of age, he is allowed to open a joint account only. Error handling becomes a necessity while developing applications that account for such constraints. The Exception class or its subclasses in Java do not address these application specific constraints. You can create your own exception classes to address these constraints and ensure the integrity of application data.

Creating and Handling User-defined Exceptions

The throw, throws, try, catch, and finally keywords are used while implementing userdefined exceptions. The Exception class inherits all the methods provided by the Throwable class. The user-defined Exception class also inherits the methods defined in the Throwable class. The following table lists the methods defined by the Throwable class:

You can use the following code to create a user-defined exception to catch the exception raised when the sum of two numbers exceeds 20:

class UserException extends Exception
{
int num1,num2,sum;
UserException(int a,int b)
{
num1 = a; num2 = b; sum = a + b;}
public String toString()
{
return "UserException Caught: The sum of the numbers Exceeds
20.."; }
}
class UserExceptionDemo
{
static void calculate(int a,int b) throws UserException
{
int sum;
System.out.println("Calculate Method(" + a + "," + b +
")");
sum=a+b;
if(sum>20)
throw new UserException(a,b);
System.out.println("The Value of the sum of two numbers
is:" + sum);
}
public static void main(String args[])
{
try
{
calculate(12,1);
calculate(15,7);
}
catch (UserException Obja)
1B.42 Programming in Java
{
System.out.println("Caught:" + Obja);
}
}
}

In the preceding code, the UserException subclass of the Exception class is created. The UserException class has one constructor, UserException() and the toString() method that returns a string containing the description of the exception. The UserExceptionDemo class defines the calculate() method that throws an object of the user-defined exception, UserException. The exception is thrown when the sum of two numbers passed as parameters to the calculate() method exceeds 20.

The output of the preceding code is:

Exception-Handling related Tutorial Article

1. Java Tutorial : Exception Handling
2. Java Tutorial : Exception Classes
3. Java Tutorial : Built-in Exceptions
4. Java Tutorial : Implementing Exception Handling
5. Java Tutorial : Implementing Exception Handling – Part 2
6. Java Tutorial : Throwing An Exception – Part 1
7. Java Tutorial : Throwing An Exception – Part 2
8. Implementing User Defined Exceptions
9. Java Tutorial : Assertion In Java

• Java Tutorial : Throwing An Exception – Part 1

Printing a Stack Trace

When an exception is caught, you can find out the method or the line of the code where the exception is raised by using the printStackTrace() method. You can call the printStackTrace() method for printing the stack trace. The objects of the Throwable class inherit the stack trace. You can use the following code to print the stack trace for the ArithmeticException exception:

class PrintStack
{
public static void main(String args[])
{
int Num1= 30 , Num2 = 0;
try
{
int Num3=Num1/Num2;
}
catch(ArithmeticException obj)
{
obj.printStackTrace();
}
}
}

In the preceding code, printStackTrace() method is used to print the stack trace to check the line in the code where the exception is raised.

Using the printStackTrace Statement

The output of the preceding code is:

Rethrowing an Exception

A catch block can rethrow an exception without handling it by using the throw statement. Exceptions are rethrown if a method causing the error wants to pass the error handling responsibilities to the exception-handlers in some other methods. You can use the following code snippet to rethrow an exception:

catch(Exception e)
{
System.out.println(“Exception Raised”);
throw e;
}

The exception goes to the catch block of the next higher context ignoring the catch blocks of the same try block.

You can use the following code to catch the NullPointerException and rethrow the exception to the outer handler:

class RethrowException
{
static void throwDemo()
{
try
{
throw new NullPointerException (“My Exception”);
}
catch(NullPointerException e)
{
System.out.println(“Exception caught in throwDemo()
method”);
throw e; // Rethrow the Exception.
}
}
public static void main(String args[])
{
try
{
throwDemo();
}
catch(NullPointerException e)
{
System.out.println(“Exception caught:” + e);
}
}
}

In the preceding code, the catch block in the throwDemo() method rethrows the NullPointer exception to the catch block defined in the main() method. The output of the preceding code is:

Rethrowing an Exception

Using the throws Statement

The throws statement is used by a method to specify the types of exceptions the method throws. If a method is capable of raising an exception that it does not handle, the method must specify that the exception have to be handled by the calling method. This is done using the throws statement. The throws clause lists the types of exceptions that a method might throw. The following syntax shows how to declare a method that specifies a throws clause:
[<access_specifier>] [<modifier>] <return_type> <method_name>
[<arg_list>] [throws <exception_list>]
You can use the following code to throw the ClassNotFoundException exception:

class NoClassexception
{
static void throwMethod()
{
System.out.println(“In throwMethod”);
throw new ClassNotFoundException();
}
public static void main(String args[])
{
throwMethod();
// no try and catch statements to handle the exception
}
}

In the preceding code, the code does not compile because the caller method throws an exception but does not catch the exception. You can compile the code by first declaring that the throwMethod() throws the ClassNotFoundException exception. In addition, the main() method must define the try-catch statements to catch the exception. You can use the following code to use the throws statement:

class ThrowsClass
{
static void throwMethod() throws ClassNotFoundException
{
System.out.println(“In throwMethod”);
throw new ClassNotFoundException();
}
public static void main(String args[])
{
try
{
throwMethod();
}
catch(ClassNotFoundException Obja)
{
System.out.println(“throwMethod has thrown an
Exception:” + Obja);
}
}
}

The output of the preceding code is:

Using the Throws Statement

Using the throw Statement

The throw statement causes termination of the normal flow of control of the Java code and stops the execution of the subsequent statements if an exception is thrown when the throw statement is executed. The throw clause transfers the control to the nearest catch block handling the type of exception object throws. If no such catch block exists, the program terminates. The throw statement accepts a single argument, which is an object of the Exception class.

The following syntax shows how to declare the throw statement:

throw ThrowableObj

In the preceding syntax, ThrowableObj is an object of the Throwable class or a subclass of the Throwable class, such as Exception class. The ThrowableObj object is created using the new operator. The Java compiler gives an error if the ThrowableObj object does not belong to a valid Exception class. You can use the following code to throw the IllegalStateException exception:

class ThrowStatement
{
static void throwDemo()
{
try
{
throw new IllegalStateException();
// creating and throwing an object of the
IllegalStateException class.
}
catch(NullPointerException objA)
{
System.out.println(“Not caught by catch block inside
throwDemo().”);
}
}
public static void main(String args[])
{
try
{
throwDemo();
}
catch(IllegalStateException objB)
{
// catching an object of the
IllegalStateException class.
System.out.println(” Exception Caught in :” + objB);
}
}
}

In the preceding code, the new operator is used to construct an object of IllegalStateException. In the throwDemo() method , an exception of the type IllegalStateException is thrown.

The output of the preceding code is:

Using the Throw Statement

Displaying the Description of an Exception

The built-in exception classes in Java have two types of constructors: one with no parameter and another with a String parameter that defines the exception. The String parameter that you pass to the constructor of an exception can be displayed when exception object is passed as an argument to the System.out.println() statement. The following code shows the use of constructor of the IlegalStateException with String parameter:

class ThrowClass
{
static void throwDemo()
{
try
{
throw new IllegalStateException(“MyException”);
}
catch(IllegalStateException objA)
{
System.out.println(“Caught:” + objA);
}
} // End of throwDemo() method.
public static void main(String args[])
{
throwDemo();
}
}// End of the ThrowClass.

In the preceding code, description added to the constructor of the IllegalStateException exception is displayed as MyException.

The output of the preceding code is:

Displaying the Description of an Exception

The multiple catch blocks generate unreachable code error. If the first catch block contains the Exception class object then the subsequent catch blocks are never executed. The Exception class being the superclass of all the exception classes catches various types of exceptions. The Java compiler gives an error stating that the subsequent catch blocks have not been reached. This is known as the unreachable code problem. To avoid unreachable code error, the last catch block in multiple catch blocks must contain the Exception class object.
The following code is an example of the unreachable code problem:

class UnreachableCodeDemo
{
public static void main(String args[])
{
int num1=5, num2=0, num3;
try
{
num3=num1/num2;
}
catch(Exception e)
{
System.out.println(“Error”);
}
catch(ArithmeticException e)
{
System.out.println(“Division by zero.”);
//Unreachable catch statement.
}
}
}

In the preceding code, the Java compiler gives an error stating that the catch block handling ArithmeticException has not been reached. This is because the Exception class, being the base class for all exceptions, handles all the exceptions that are raised by the Java code in the very first catch block. The output of the preceding code is:

Unreachable Code Problem

The unreachable code problem can be solved if the subclasses, such as ArithmeticException, ArrayIndexOutOfBounds, or NullPointerException in the multiple catch statements are written before the Exception superclass.

Using the finally Clause

When an exception is raised, the statements in the try block written after the statement in which the exception occurred are ignored. The finally block is used to process certain statements, no matter whether an exception is raised or not. The block of code attached with the finally clause is executed after a try-catch block has been executed. The following syntax shows how to declare the try-finally block:

try
{
// Block of code
}
finally
{
// Block of code that is always executed irrespective of an
exception being raised or not.
}

If there is a catch block associated with the try block, the finally clause is written after the catch block. The following syntax shows how to declare the try-catch-finally block:

try
{
// Block of code.
}
catch(execption1 obj1)
{
System.out.println(“Exception1 has been raised”);
}
catch(exception2 obj2)
{
System.out.println(“Exception2 has been raised”);
}
finally
{
// Block of code that is always executed irrespective of an
exception being raised or not.
}

The finally block executes whether or not an exception is raised. If an exception is thrown, the finally block executes even if no catch statement matches the exception. For example, a file has to be closed irrespective of whether an exception is raised or not. You can place the code to close the file in both the try and catch blocks.

To avoid duplication of code, you can place the code in the finally block. The following code snippet is used to write a try-catch block to declare methods to open and write to a file:

try
{
openFile();
writeFile(); // Might raise an exception.
}
catch(ExceptionName obj)
{
// Process the exception.
}
finally
{
closeFile();
}

In the preceding code, the finally clause is executed regardless of whether an exception is thrown or not. You can have only one finally block for an exceptionhandler. You can use the finally clause to execute the closeFile() method.