Exception Handling

1. Advantage of Exception Handling
2. Hierarchy of Exception classes
3. Types of Exception
4. Exception Example
5. Scenarios where an exception may occur

The Exception Handling in Java is one of the powerful mechanism to handle the runtime errors so that the normal flow of the application can be maintained.

In this tutorial, we will learn about Java exceptions, it's types, and the difference between checked and unchecked exceptions.

Dictionary Meaning: Exception is an abnormal condition.

In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

ADVERTISEMENT

Exception Handling is a mechanism to handle runtime errors such as ClassNotFoundException, IOException, SQLException, RemoteException, etc.

The core advantage of exception handling is to maintain the normal flow of the application. An exception normally disrupts the normal flow of the application; that is why we need to handle exceptions. Let's consider a scenario:

1. statement 1;  
2. statement 2;  
3. statement 3;  
4. statement 4;  
5. statement 5;//exception occurs 
6. statement 6;  
7. statement 7;  
8. statement 8;  
9. statement 9;  
10. statement 10;  

Suppose there are 10 statements in a Java program and an exception occurs at statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed. However, when we perform exception handling, the rest of the statements will be executed. That is why we use exception handling in Java.

Do You Know?

• What is the difference between checked and unchecked exceptions?
• What happens behind the code int data=50/0;?
• Why use multiple catch block?
• Is there any possibility when the finally block is not executed?
• What is exception propagation?
• What is the difference between the throw and throws keyword?
• What are the 4 rules for using exception handling with method overriding?

The java.lang.Throwable class is the root class of Java Exception hierarchy inherited by two subclasses: Exception and Error. The hierarchy of Java Exception classes is given below:

There are mainly two types of exceptions: checked and unchecked. An error is considered as the unchecked exception. However, according to Oracle, there are three types of exceptions namely:

1. Checked Exception
2. Unchecked Exception
3. Error

The classes that directly inherit the Throwable class except RuntimeException and Error are known as checked exceptions. For example, IOException, SQLException, etc. Checked exceptions are checked at compile-time.

The classes that inherit the RuntimeException are known as unchecked exceptions. For example, ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, etc. Unchecked exceptions are not checked at compile-time, but they are checked at runtime.

Error is irrecoverable. Some example of errors are OutOfMemoryError, VirtualMachineError, AssertionError etc.

Java provides five keywords that are used to handle the exception. The following table describes each.

KeywordDescriptiontryThe "try" keyword is used to specify a block where we should place an exception code. It means we can't use try block alone. The try block must be followed by either catch or finally.catchThe "catch" block is used to handle the exception. It must be preceded by try block which means we can't use catch block alone. It can be followed by finally block later.finallyThe "finally" block is used to execute the necessary code of the program. It is executed whether an exception is handled or not.throwThe "throw" keyword is used to throw an exception.throwsThe "throws" keyword is used to declare exceptions. It specifies that there may occur an exception in the method. It doesn't throw an exception. It is always used with method signature.

Let's see an example of Java Exception Handling in which we are using a try-catch statement to handle the exception.

JavaExceptionExample.java

1. public class JavaExceptionExample{  
2. public static void main(String args[]){  
3. try{  
4. //code that may raise exception 
5. int data=100/0;  
6.    }catch(ArithmeticException e){System.out.println(e);}  
7. //rest code of the program  
8.    System.out.println("rest of the code...");  
9.   }  
10. }  

Test it Now

Output:

Exception in thread main java.lang.ArithmeticException:/ by zero

rest of the code...

In the above example, 100/0 raises an ArithmeticException which is handled by a try-catch block.

There are given some scenarios where unchecked exceptions may occur. They are as follows:

If we divide any number by zero, there occurs an ArithmeticException.

1. int a=50/0;//ArithmeticException 

If we have a null value in any variable, performing any operation on the variable throws a NullPointerException.

ADVERTISEMENTADVERTISEMENT

1. String s=null;  
2. System.out.println(s.length());//NullPointerException 

If the formatting of any variable or number is mismatched, it may result into NumberFormatException. Suppose we have a string variable that has characters; converting this variable into digit will cause NumberFormatException.

1. String s="abc";  
2. int i=Integer.parseInt(s);//NumberFormatException 

When an array exceeds to it's size, the ArrayIndexOutOfBoundsException occurs. there may be other reasons to occur ArrayIndexOutOfBoundsException. Consider the following statements.

1. int a[]=new int[5];  
2. a[10]=50; //ArrayIndexOutOfBoundsException 

==============================================================================

 

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

If an exception occurs at the particular statement in the try block, the rest of the block code will not execute. So, it is recommended not to keep the code in try block that will not throw an exception.

Java try block must be followed by either catch or finally block.

1. try{    
2. //code that may throw an exception   
3. }catch(Exception_class_Name ref){}    

1. try{    
2. //code that may throw an exception   
3. }finally{}    

Java catch block is used to handle the Exception by declaring the type of exception within the parameter. The declared exception must be the parent class exception ( i.e., Exception) or the generated exception type. However, the good approach is to declare the generated type of exception.

The catch block must be used after the try block only. You can use multiple catch block with a single try block.

The JVM firstly checks whether the exception is handled or not. If exception is not handled, JVM provides a default exception handler that performs the following tasks:

• Prints out exception description.
• Prints the stack trace (Hierarchy of methods where the exception occurred).
• Causes the program to terminate.

But if the application programmer handles the exception, the normal flow of the application is maintained, i.e., rest of the code is executed.

Let's try to understand the problem if we don't use a try-catch block.

TryCatchExample1.java

1. public class TryCatchExample1 {  
2. public static void main(String[] args) {  
3. int data=50/0; //may throw exception  
4.         System.out.println("rest of the code");  
5.     }  
6. }  

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

As displayed in the above example, the rest of the code is not executed (in such case, the rest of the code statement is not printed).

There might be 100 lines of code after the exception. If the exception is not handled, all the code below the exception won't be executed.

Let's see the solution of the above problem by a java try-catch block.

TryCatchExample2.java

1. public class TryCatchExample2 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int data=50/0; //may throw exception  
6.         }  
7. //handling the exception 
8. catch(ArithmeticException e)  
9.         {  
10.             System.out.println(e);  
11.         }  
12.         System.out.println("rest of the code");  
13.     }  
14. }  

Output:

java.lang.ArithmeticException: / by zero

rest of the code

As displayed in the above example, the rest of the code is executed, i.e., the rest of the code statement is printed.

In this example, we also kept the code in a try block that will not throw an exception.

TryCatchExample3.java

1. public class TryCatchExample3 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int data=50/0; //may throw exception  
6. // if exception occurs, the remaining statement will not exceute 
7.         System.out.println("rest of the code");  
8.         }  
9. // handling the exception  
10. catch(ArithmeticException e)  
11.         {  
12.             System.out.println(e);  
13.         }  
14.     }  
15. }  

Output:

java.lang.ArithmeticException: / by zero

Here, we can see that if an exception occurs in the try block, the rest of the block code will not execute.

Here, we handle the exception using the parent class exception.

TryCatchExample4.java

1. public class TryCatchExample4 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int data=50/0; //may throw exception  
6.         }  
7. // handling the exception by using Exception class     
8. catch(Exception e)  
9.         {  
10.             System.out.println(e);  
11.         }  
12.         System.out.println("rest of the code");  
13.     }  
14. }  

Output:

java.lang.ArithmeticException: / by zero

rest of the code

Let's see an example to print a custom message on exception.

TryCatchExample5.java

1. public class TryCatchExample5 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int data=50/0; //may throw exception  
6.         }  
7. // handling the exception 
8. catch(Exception e)  
9.         {  
10. // displaying the custom message 
11.             System.out.println("Can't divided by zero");  
12.         }  
13.     }  
14. }  

Output:

Can't divided by zero

Let's see an example to resolve the exception in a catch block.

TryCatchExample6.java

1. public class TryCatchExample6 {  
2. public static void main(String[] args) {  
3. int i=50;  
4. int j=0;  
5. int data;  
6. try 
7.         {  
8.         data=i/j; //may throw exception  
9.         }  
10. // handling the exception 
11. catch(Exception e)  
12.         {  
13. // resolving the exception in catch block 
14.             System.out.println(i/(j+2));  
15.         }  
16.     }  
17. }  

Output:

25

In this example, along with try block, we also enclose exception code in a catch block.

TryCatchExample7.java

1. public class TryCatchExample7 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int data1=50/0; //may throw exception  
6.         }  
7. // handling the exception 
8. catch(Exception e)  
9.         {  
10. // generating the exception in catch block 
11. int data2=50/0; //may throw exception  
12.         }  
13.     System.out.println("rest of the code");  
14.     }  
15. }  

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

Here, we can see that the catch block didn't contain the exception code. So, enclose exception code within a try block and use catch block only to handle the exceptions.

In this example, we handle the generated exception (Arithmetic Exception) with a different type of exception class (ArrayIndexOutOfBoundsException).

TryCatchExample8.java

1. public class TryCatchExample8 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int data=50/0; //may throw exception  
6.         }  
7. // try to handle the ArithmeticException using ArrayIndexOutOfBoundsException 
8. catch(ArrayIndexOutOfBoundsException e)  
9.         {  
10.             System.out.println(e);  
11.         }  
12.         System.out.println("rest of the code");  
13.     }  
14. }  

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

Let's see an example to handle another unchecked exception.

TryCatchExample9.java

1. public class TryCatchExample9 {  
2. public static void main(String[] args) {  
3. try 
4.         {  
5. int arr[]= {1,3,5,7};  
6.         System.out.println(arr[10]); //may throw exception  
7.         }  
8. // handling the array exception 
9. catch(ArrayIndexOutOfBoundsException e)  
10.         {  
11.             System.out.println(e);  
12.         }  
13.         System.out.println("rest of the code");  
14.     }  
15. }  

Output:

java.lang.ArrayIndexOutOfBoundsException: 10

rest of the code

Let's see an example to handle checked exception.

TryCatchExample10.java

ADVERTISEMENT

1. import java.io.FileNotFoundException;  
2. import java.io.PrintWriter;  
3. public class TryCatchExample10 {  
4. public static void main(String[] args) {  
5.         PrintWriter pw;  
6. try {  
7.             pw = new PrintWriter("jtp.txt"); //may throw exception  
8.             pw.println("saved");  
9.         }  
10. // providing the checked exception handler 
11. catch (FileNotFoundException e) {  
12.             System.out.println(e);  
13.         }         
14.     System.out.println("File saved successfully");  
15.     }  
16. }  

Output:

File saved successfully

============================================================================

A try block can be followed by one or more catch blocks. Each catch block must contain a different exception handler. So, if you have to perform different tasks at the occurrence of different exceptions, use java multi-catch block.

• At a time only one exception occurs and at a time only one catch block is executed.
• All catch blocks must be ordered from most specific to most general, i.e. catch for ArithmeticException must come before catch for Exception.
• 
  

Let's see a simple example of java multi-catch block.

MultipleCatchBlock1.java

1. public class MultipleCatchBlock1 {  
2. public static void main(String[] args) {  
3. try{    
4. int a[]=new int[5];    
5.                 a[5]=30/0;    
6.                }    
7. catch(ArithmeticException e)  
8.                   {  
9.                    System.out.println("Arithmetic Exception occurs");  
10.                   }    
11. catch(ArrayIndexOutOfBoundsException e)  
12.                   {  
13.                    System.out.println("ArrayIndexOutOfBounds Exception occurs");  
14.                   }    
15. catch(Exception e)  
16.                   {  
17.                    System.out.println("Parent Exception occurs");  
18.                   }             
19.                System.out.println("rest of the code");    
20.     }  
21. }  

Output:

Arithmetic Exception occurs

rest of the code

MultipleCatchBlock2.java

1. public class MultipleCatchBlock2 {  
2. public static void main(String[] args) {  
3. try{    
4. int a[]=new int[5];    
5.                 System.out.println(a[10]);  
6.                }    
7. catch(ArithmeticException e)  
8.                   {  
9.                    System.out.println("Arithmetic Exception occurs");  
10.                   }    
11. catch(ArrayIndexOutOfBoundsException e)  
12.                   {  
13.                    System.out.println("ArrayIndexOutOfBounds Exception occurs");  
14.                   }    
15. catch(Exception e)  
16.                   {  
17.                    System.out.println("Parent Exception occurs");  
18.                   }             
19.                System.out.println("rest of the code");    
20.     }  
21. }  

Output:

ArrayIndexOutOfBounds Exception occurs

rest of the code

In this example, try block contains two exceptions. But at a time only one exception occurs and its corresponding catch block is executed.

MultipleCatchBlock3.java

1. public class MultipleCatchBlock3 {  
2. public static void main(String[] args) {  
3. try{    
4. int a[]=new int[5];    
5.                 a[5]=30/0;    
6.                 System.out.println(a[10]);  
7.                }    
8. catch(ArithmeticException e)  
9.                   {  
10.                    System.out.println("Arithmetic Exception occurs");  
11.                   }    
12. catch(ArrayIndexOutOfBoundsException e)  
13.                   {  
14.                    System.out.println("ArrayIndexOutOfBounds Exception occurs");  
15.                   }    
16. catch(Exception e)  
17.                   {  
18.                    System.out.println("Parent Exception occurs");  
19.                   }             
20.                System.out.println("rest of the code");    
21.     }  
22. }  

Output:

Arithmetic Exception occurs

rest of the code

In this example, we generate NullPointerException, but didn't provide the corresponding exception type. In such case, the catch block containing the parent exception class Exception will invoked.

MultipleCatchBlock4.java

1. public class MultipleCatchBlock4 {  
2. public static void main(String[] args) {  
3. try{    
4.                 String s=null;  
5.                 System.out.println(s.length());  
6.                }    
7. catch(ArithmeticException e)  
8.                   {  
9.                    System.out.println("Arithmetic Exception occurs");  
10.                   }    
11. catch(ArrayIndexOutOfBoundsException e)  
12.                   {  
13.                    System.out.println("ArrayIndexOutOfBounds Exception occurs");  
14.                   }    
15. catch(Exception e)  
16.                   {  
17.                    System.out.println("Parent Exception occurs");  
18.                   }             
19.                System.out.println("rest of the code");    
20.     }  
21. }  

Output:

Parent Exception occurs

rest of the code

Let's see an example, to handle the exception without maintaining the order of exceptions (i.e. from most specific to most general).

MultipleCatchBlock5.java

1. class MultipleCatchBlock5{    
2. public static void main(String args[]){    
3. try{    
4. int a[]=new int[5];    
5.     a[5]=30/0;    
6.    }    
7. catch(Exception e){System.out.println("common task completed");}    
8. catch(ArithmeticException e){System.out.println("task1 is completed");}    
9. catch(ArrayIndexOutOfBoundsException e){System.out.println("task 2 completed");}    
10.    System.out.println("rest of the code...");    
11.  }    
12. }   

Output:

Compile-time error

===============================================================================

 

In Java, using a try block inside another try block is permitted. It is called as nested try block. Every statement that we enter a statement in try block, context of that exception is pushed onto the stack.

For example, the inner try block can be used to handle ArrayIndexOutOfBoundsException while the outer try block can handle the ArithemeticException (division by zero).

Sometimes a situation may arise where a part of a block may cause one error and the entire block itself may cause another error. In such cases, exception handlers have to be nested.

1. ....    
2. //main try block 
3. try 
4. {    
5.     statement 1;    
6.     statement 2;    
7. //try catch block within another try block 
8. try 
9.     {    
10.         statement 3;    
11.         statement 4;    
12. //try catch block within nested try block 
13. try 
14.         {    
15.             statement 5;    
16.             statement 6;    
17.      }    
18. catch(Exception e2)    
19.         {    
20. //exception message 
21.         }    
22.     }    
23. catch(Exception e1)    
24.     {    
25. //exception message 
26.     }    
27. }    
28. //catch block of parent (outer) try block 
29. catch(Exception e3)    
30. {    
31. //exception message 
32. }    
33. ....  

Let's see an example where we place a try block within another try block for two different exceptions.

NestedTryBlock.java

1. public class NestedTryBlock{    
2. public static void main(String args[]){   
3. //outer try block  
4. try{    
5. //inner try block 1 
6. try{    
7.      System.out.println("going to divide by 0");    
8. int b =39/0;    
9.    }  
10. //catch block of inner try block 1 
11. catch(ArithmeticException e)  
12.     {  
13.       System.out.println(e);  
14.     }    
15. //inner try block 2 
16. try{    
17. int a[]=new int[5];    
18. //assigning the value out of array bounds 
19.      a[5]=4;    
20.      }  
21. //catch block of inner try block 2 
22. catch(ArrayIndexOutOfBoundsException e)  
23.     {  
24.        System.out.println(e);  
25.     }    
26.     System.out.println("other statement");    
27.   }  
28. //catch block of outer try block 
29. catch(Exception e)  
30.   {  
31.     System.out.println("handled the exception (outer catch)");  
32.   }    
33.   System.out.println("normal flow..");    
34.  }    
35. }  

Output:

When any try block does not have a catch block for a particular exception, then the catch block of the outer (parent) try block are checked for that exception, and if it matches, the catch block of outer try block is executed.

If none of the catch block specified in the code is unable to handle the exception, then the Java runtime system will handle the exception. Then it displays the system generated message for that exception.

Let's consider the following example. Here the try block within nested try block (inner try block 2) do not handle the exception. The control is then transferred to its parent try block (inner try block 1). If it does not handle the exception, then the control is transferred to the main try block (outer try block) where the appropriate catch block handles the exception. It is termed as nesting.

NestedTryBlock.java

1. public class NestedTryBlock2 {  
2. public static void main(String args[])  
3.     {  
4. // outer (main) try block 
5. try {  
6. //inner try block 1  
7. try {  
8. // inner try block 2 
9. try {  
10. int arr[] = { 1, 2, 3, 4 };  
11. //printing the array element out of its bounds 
12.                     System.out.println(arr[10]);  
13.                 }  
14. // to handles ArithmeticException 
15. catch (ArithmeticException e) {  
16.                     System.out.println("Arithmetic exception");  
17.                     System.out.println(" inner try block 2");  
18.                 }  
19.             }  
20. // to handle ArithmeticException  
21. catch (ArithmeticException e) {  
22.                 System.out.println("Arithmetic exception");  
23.                 System.out.println("inner try block 1");  
24.             }  
25.         }  
26. // to handle ArrayIndexOutOfBoundsException  
27. catch (ArrayIndexOutOfBoundsException e4) {  
28.             System.out.print(e4);  
29.             System.out.println(" outer (main) try block");  
30.         }  
31. catch (Exception e5) {  
32.             System.out.print("Exception");  
33.             System.out.println(" handled in main try-block");  
34.         }  
35.     }  
36. }  

Output:

 

 

Java finally block is a block used to execute important code such as closing the connection, etc.

Java finally block is always executed whether an exception is handled or not. Therefore, it contains all the necessary statements that need to be printed regardless of the exception occurs or not.

The finally block follows the try-catch block.

• finally block in Java can be used to put "cleanup" code such as closing a file, closing connection, etc.
• The important statements to be printed can be placed in the finally block.

Let's see the different cases where Java finally block can be used.

Backward Skip 10sPlay VideoForward Skip 10sADVERTISEMENT

Let's see the below example where the Java program does not throw any exception, and the finally block is executed after the try block.

TestFinallyBlock.java

1. class TestFinallyBlock {    
2. public static void main(String args[]){    
3. try{    
4. //below code do not throw any exception 
5. int data=25/5;    
6.    System.out.println(data);    
7.   }    
8. //catch won't be executed 
9. catch(NullPointerException e){  
10. System.out.println(e);  
11. }    
12. //executed regardless of exception occurred or not 
13. finally {  
14. System.out.println("finally block is always executed");  
15. }    
16. System.out.println("rest of phe code...");    
17.   }    
18. }    

Output:

Let's see the the fillowing example. Here, the code throws an exception however the catch block cannot handle it. Despite this, the finally block is executed after the try block and then the program terminates abnormally.

TestFinallyBlock1.java

1. public class TestFinallyBlock1{    
2. public static void main(String args[]){   
3. try {    
4.         System.out.println("Inside the try block");  
5. //below code throws divide by zero exception 
6. int data=25/0;    
7.        System.out.println(data);    
8.       }    
9. //cannot handle Arithmetic type exception 
10. //can only accept Null Pointer type exception 
11. catch(NullPointerException e){  
12.         System.out.println(e);  
13.       }   
14. //executes regardless of exception occured or not  
15. finally {  
16.         System.out.println("finally block is always executed");  
17.       }    
18.       System.out.println("rest of the code...");    
19.       }    
20.     }    

Output:

Example:

Let's see the following example where the Java code throws an exception and the catch block handles the exception. Later the finally block is executed after the try-catch block. Further, the rest of the code is also executed normally.

TestFinallyBlock2.java

1. public class TestFinallyBlock2{    
2. public static void main(String args[]){   
3. try {    
4.         System.out.println("Inside try block");  
5. //below code throws divide by zero exception 
6. int data=25/0;    
7.        System.out.println(data);    
8.       }   
9. //handles the Arithmetic Exception / Divide by zero exception 
10. catch(ArithmeticException e){  
11.         System.out.println("Exception handled");  
12.         System.out.println(e);  
13.       }   
14. //executes regardless of exception occured or not  
15. finally {  
16.         System.out.println("finally block is always executed");  
17.       }    
18.       System.out.println("rest of the code...");    
19.       }    
20.     }  

Output:

==============================================================================

In Java, exceptions allows us to write good quality codes where the errors are checked at the compile time instead of runtime and we can create custom exceptions making the code recovery and debugging easier.

The Java throw keyword is used to throw an exception explicitly.

We specify the exception object which is to be thrown. The Exception has some message with it that provides the error description. These exceptions may be related to user inputs, server, etc.

We can throw either checked or unchecked exceptions in Java by throw keyword. It is mainly used to throw a custom exception. We will discuss custom exceptions later in this section.

ADVERTISEMENTADVERTISEMENT

We can also define our own set of conditions and throw an exception explicitly using throw keyword. For example, we can throw ArithmeticException if we divide a number by another number. Here, we just need to set the condition and throw exception using throw keyword.

The syntax of the Java throw keyword is given below.

throw Instance i.e.,

1. throw new exception_class("error message");  

Let's see the example of throw IOException.

1. throw new IOException("sorry device error");   

Where the Instance must be of type Throwable or subclass of Throwable. For example, Exception is the sub class of Throwable and the user-defined exceptions usually extend the Exception class.

In this example, we have created a method named validate() that accepts an integer as a parameter. If the age is less than 18, we are throwing the ArithmeticException otherwise print a message welcome to vote.

TestThrow1.java

In this example, we have created the validate method that takes integer value as a parameter. If the age is less than 18, we are throwing the ArithmeticException otherwise print a message welcome to vote.

1. public class TestThrow1 {   
2. //function to check if person is eligible to vote or not  
3. public static void validate(int age) {  
4. if(age<18) {  
5. //throw Arithmetic exception if not eligible to vote 
6. throw new ArithmeticException("Person is not eligible to vote");    
7.         }  
8. else {  
9.             System.out.println("Person is eligible to vote!!");  
10.         }  
11.     }  
12. //main method 
13. public static void main(String args[]){  
14. //calling the function 
15.         validate(13);  
16.         System.out.println("rest of the code...");    
17.   }    
18. }    

Output:

The above code throw an unchecked exception. Similarly, we can also throw unchecked and user defined exceptions.

If we throw a checked exception using throw keyword, it is must to handle the exception using catch block or the method must declare it using throws declaration.

TestThrow2.java

1. import java.io.*;  
2. public class TestThrow2 {   
3. //function to check if person is eligible to vote or not  
4. public static void method() throws FileNotFoundException {  
5.         FileReader file = new FileReader("C:\\Users\\Anurati\\Desktop\\abc.txt");  
6.         BufferedReader fileInput = new BufferedReader(file);  
7. throw new FileNotFoundException();  
8.     }  
9. //main method 
10. public static void main(String args[]){  
11. try 
12.         {  
13.             method();  
14.         }   
15. catch (FileNotFoundException e)   
16.         {  
17.             e.printStackTrace();  
18.         }  
19.         System.out.println("rest of the code...");    
20.   }    
21. }    

Output:

exception is everything else under the Throwable class.

TestThrow3.java

1. // class represents user-defined exception 
2. class UserDefinedException extends Exception  
3. {  
4. public UserDefinedException(String str)  
5.     {  
6. // Calling constructor of parent Exception 
7. super(str);  
8.     }  
9. }  
10. // Class that uses above MyException 
11. public class TestThrow3  
12. {  
13. public static void main(String args[])  
14.     {  
15. try 
16.         {  
17. // throw an object of user defined exception 
18. throw new UserDefinedException("This is user-defined exception");  
19.         }  
20. catch (UserDefinedException ude)  
21.         {  
22.             System.out.println("Caught the exception");  
23. // Print the message from MyException object 
24.             System.out.println(ude.getMessage());  
25.         }  
26.     }  
27. }   

Output:

 

==============================================================================

An exception is first thrown from the top of the stack and if it is not caught, it drops down the call stack to the previous method. If not caught there, the exception again drops down to the previous method, and so on until they are caught or until they reach the very bottom of the call stack. This is called exception propagation.

TestExceptionPropagation1.java

1. class TestExceptionPropagation1{  
2. void m(){  
3. int data=50/0;  
4.   }  
5. void n(){  
6.     m();  
7.   }  
8. void p(){  
9. try{  
10.     n();  
11.    }catch(Exception e){System.out.println("exception handled");}  
12.   }  
13. public static void main(String args[]){  
14.    TestExceptionPropagation1 obj=new TestExceptionPropagation1();  
15.    obj.p();  
16.    System.out.println("normal flow...");  
17.   }  
18. }  

Output:

exception handled

       normal flow...

In the above example exception occurs in the m() method where it is not handled, so it is propagated to the previous n() method where it is not handled, again it is propagated to the p() method where exception is handled.

Exception can be handled in any method in call stack either in the main() method, p() method, n() method or m() method.

TestExceptionPropagation1.java

1. class TestExceptionPropagation2{  
2. void m(){  
3. throw new java.io.IOException("device error");//checked exception 
4.   }  
5. void n(){  
6.     m();  
7.   }  
8. void p(){  
9. try{  
10.     n();  
11.    }catch(Exception e){System.out.println("exception handeled");}  
12.   }  
13. public static void main(String args[]){  
14.    TestExceptionPropagation2 obj=new TestExceptionPropagation2();  
15.    obj.p();  
16.    System.out.println("normal flow");  
17.   }  
18. }  

Output:

Compile Time Error

================================================================================

The Java throws keyword is used to declare an exception. It gives an information to the programmer that there may occur an exception. So, it is better for the programmer to provide the exception handling code so that the normal flow of the program can be maintained.

Exception Handling is mainly used to handle the checked exceptions. If there occurs any unchecked exception such as NullPointerException, it is programmers' fault that he is not checking the code before it being used.

1. return_type method_name() throws exception_class_name{  
2. //method code 
3. }  

Ans: Checked exception only, because:

• unchecked exception: under our control so we can correct our code.
• error: beyond our control. For example, we are unable to do anything if there occurs VirtualMachineError or StackOverflowError.

Now Checked Exception can be propagated (forwarded in call stack).

It provides information to the caller of the method about the exception.

Let's see the example of Java throws clause which describes that checked exceptions can be propagated by throws keyword.

Testthrows1.java

1. import java.io.IOException;  
2. class Testthrows1{  
3. void m()throws IOException{  
4. throw new IOException("device error");//checked exception 
5.   }  
6. void n()throws IOException{  
7.     m();  
8.   }  
9. void p(){  
10. try{  
11.     n();  
12.    }catch(Exception e){System.out.println("exception handled");}  
13.   }  
14. public static void main(String args[]){  
15.    Testthrows1 obj=new Testthrows1();  
16.    obj.p();  
17.    System.out.println("normal flow...");  
18.   }  
19. }  

Output:

exception handled

normal flow...

=============================================================================== 

There are many rules if we talk about method overriding with exception handling.

Some of the rules are listed below:

• If the superclass method does not declare an exception
  • If the superclass method does not declare an exception, subclass overridden method cannot declare the checked exception but it can declare unchecked exception.
• If the superclass method declares an exception
  • If the superclass method declares an exception, subclass overridden method can declare same, subclass exception or no exception but cannot declare parent exception.

Let's consider following example based on the above rule.

TestExceptionChild.java

1. import java.io.*;    
2. class Parent{   
3. // defining the method  
4. void msg() {  
5.     System.out.println("parent method");  
6.     }    
7. }    
8. public class TestExceptionChild extends Parent{    
9. // overriding the method in child class 
10. // gives compile time error 
11. void msg() throws IOException {    
12.     System.out.println("TestExceptionChild");    
13.   }  
14. public static void main(String args[]) {    
15.    Parent p = new TestExceptionChild();    
16.    p.msg();    
17.   }    
18. }    

Output:

TestExceptionChild1.java

1. import java.io.*;    
2. class Parent{    
3. void msg() {  
4.     System.out.println("parent method");  
5.   }    
6. }    
7. class TestExceptionChild1 extends Parent{    
8. void msg()throws ArithmeticException {    
9.     System.out.println("child method");    
10.   }    
11. public static void main(String args[]) {    
12.    Parent p = new TestExceptionChild1();    
13.    p.msg();    
14.   }    
15. }   

Output:

TestExceptionChild2.java

1. import java.io.*;    
2. class Parent{    
3. void msg()throws ArithmeticException {  
4.     System.out.println("parent method");  
5.   }    
6. }    
7. public class TestExceptionChild2 extends Parent{    
8. void msg()throws Exception {  
9.     System.out.println("child method");  
10.   }    
11. public static void main(String args[]) {    
12.    Parent p = new TestExceptionChild2();    
13. try {    
14.    p.msg();    
15.    }  
16. catch (Exception e){}   
17.   }    
18. }     

Output:

TestExceptionChild3.java

1. import java.io.*;    
2. class Parent{    
3. void msg() throws Exception {  
4.     System.out.println("parent method");  
5.   }    
6. }    
7. public class TestExceptionChild3 extends Parent {    
8. void msg()throws Exception {  
9.     System.out.println("child method");  
10.   }    
11. public static void main(String args[]){    
12.    Parent p = new TestExceptionChild3();    
13. try {    
14.    p.msg();    
15.    }  
16. catch(Exception e) {}    
17.   }    
18. }    

Output:

TestExceptionChild4.java

1. import java.io.*;    
2. class Parent{    
3. void msg()throws Exception {  
4.     System.out.println("parent method");  
5.   }    
6. }    
7. class TestExceptionChild4 extends Parent{    
8. void msg()throws ArithmeticException {  
9.     System.out.println("child method");  
10.   }    
11. public static void main(String args[]){    
12.    Parent p = new TestExceptionChild4();    
13. try {    
14.    p.msg();    
15.    }  
16. catch(Exception e) {}    
17.   }    
18. }    

Output:

TestExceptionChild5.java

1. import java.io.*;    
2. class Parent {    
3. void msg()throws Exception{  
4.     System.out.println("parent method");  
5.   }    
6. }    
7. class TestExceptionChild5 extends Parent{    
8. void msg() {  
9.     System.out.println("child method");  
10.   }    
11. public static void main(String args[]){    
12.    Parent p = new TestExceptionChild5();    
13. try {    
14.    p.msg();    
15.    }  
16. catch(Exception e) {}  
17.   }    
18. }     

Output:

 

=============================================================================

 

In Java, we can create our own exceptions that are derived classes of the Exception class. Creating our own Exception is known as custom exception or user-defined exception. Basically, Java custom exceptions are used to customize the exception according to user need.

Consider the example 1 in which InvalidAgeException class extends the Exception class.

Using the custom exception, we can have your own exception and message. Here, we have passed a string to the constructor of superclass i.e. Exception class that can be obtained using getMessage() method on the object we have created.

In this section, we will learn how custom exceptions are implemented and used in Java programs.

Java exceptions cover almost all the general type of exceptions that may occur in the programming. However, we sometimes need to create custom exceptions.

Following are few of the reasons to use custom exceptions:

• To catch and provide specific treatment to a subset of existing Java exceptions.
• Business logic exceptions: These are the exceptions related to business logic and workflow. It is useful for the application users or the developers to understand the exact problem.

In order to create custom exception, we need to extend Exception class that belongs to java.lang package.

Consider the following example, where we create a custom exception named WrongFileNameException:

1. public class WrongFileNameException extends Exception {  
2. public WrongFileNameException(String errorMessage) {  
3. super(errorMessage);  
4.     }  
5. }  

Let's see a simple example of Java custom exception. In the following code, constructor of InvalidAgeException takes a string as an argument. This string is passed to constructor of parent class Exception using the super() method. Also the constructor of Exception class can be called without using a parameter and calling super() method is not mandatory.

TestCustomException1.java

1. // class representing custom exception 
2. class InvalidAgeException  extends Exception  
3. {  
4. public InvalidAgeException (String str)  
5.     {  
6. // calling the constructor of parent Exception 
7. super(str);  
8.     }  
9. }  
10. // class that uses custom exception InvalidAgeException 
11. public class TestCustomException1  
12. {  
13. // method to check the age 
14. static void validate (int age) throws InvalidAgeException{    
15. if(age < 18){  
16. // throw an object of user defined exception 
17. throw new InvalidAgeException("age is not valid to vote");    
18.     }  
19. else {   
20.         System.out.println("welcome to vote");   
21.         }   
22.      }    
23. // main method 
24. public static void main(String args[])  
25.     {  
26. try 
27.         {  
28. // calling the method  
29.             validate(13);  
30.         }  
31. catch (InvalidAgeException ex)  
32.         {  
33.             System.out.println("Caught the exception");  
34. // printing the message from InvalidAgeException object 
35.             System.out.println("Exception occured: " + ex);  
36.         }  
37.         System.out.println("rest of the code...");    
38.     }  
39. }  

Output:

TestCustomException2.java

1. // class representing custom exception 
2. class MyCustomException extends Exception  
3. {  
4. }  
5. // class that uses custom exception MyCustomException 
6. public class TestCustomException2  
7. {  
8. // main method 
9. public static void main(String args[])  
10.     {  
11. try 
12.         {  
13. // throw an object of user defined exception 
14. throw new MyCustomException();  
15.         }  
16. catch (MyCustomException ex)  
17.         {  
18.             System.out.println("Caught the exception");  
19.             System.out.println(ex.getMessage());  
20.         }  
21.         System.out.println("rest of the code...");    
22.     }  
23. }  

Output: