Exception Handling in Java

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 Java, an exception is an event that disrupts the normal flow of the
program. It is an object which is thrown at runtime.

What is Exception Handling?

Exception Handling is a mechanism to handle runtime errors such as

ClassNotFoundException, IOException, SQLException, RemoteException, etc.

Advantage of Exception Handling

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.

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.

Hierarchy of Java Exception classes

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:

1
Types of Java Exceptions

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

Difference between Checked and Unchecked Exceptions

1) Checked Exception

2
 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.

2) Unchecked Exception

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.

3) Error

Error is irrecoverable. Some example of errors are OutOfMemoryError,

VirtualMachineError, AssertionError etc.

Java Exception Keywords

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

Keyword Description

try The "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.

catch The "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.

finally The "finally" block is used to execute the necessary code of the
program. It is executed whether an exception is handled or not.

throw The "throw" keyword is used to throw an exception.

throws The "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.

Java Exception Handling Example

1. public class JavaExceptionExample{
2. public static void main(String args[]){
3. try{
4. //code that may raise exception

3
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. }

Output:
11. Exception in thread main java.lang.ArithmeticException:/
by zero
12. rest of the code...

Common Scenarios of Java Exceptions

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

1) A scenario where ArithmeticException occurs

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

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

2) A scenario where NullPointerException occurs

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

variable throws a NullPointerException.

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

3) A scenario where NumberFormatException occurs

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

4) A scenario where ArrayIndexOutOfBoundsException occurs

4
 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-catch block

Java try block

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.

Java catch block

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.

Internal Working of Java try-catch block

5
 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:

o Prints out exception description.

o Prints the stack trace (Hierarchy of methods where the exception
occurred).
o 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.

Problem without exception handling

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

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).
Note: if an exception occurs in the try block, the rest of the block
code will not execute.

Example 4

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

1. public class TryCatchExample4 {

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

Output:

java.lang.ArithmeticException: / by zero
rest of the code

Example 5

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

7
 TryCatchExample5.java

1. public class TryCatchExample5 {

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

Output:

Can't divided by zero

Example 6

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

TryCatchExample6.java

1. public class TryCatchExample6 {

2.
3. public static void main(String[] args) {
4. int i=50;
5. int j=0;
6. int data;
7. try
8. {
9. data=i/j; //may throw exception

8
10. }
11. // handling the exception
12. catch(Exception e)
13. {
14. // resolving the exception in catch block
15. System.out.println(i/(j+2));
16. }
17. }
18. }

Output:

25

Example 8

In this example, we handle the generated exception (Arithmetic Exception)

with a different type of exception class (ArrayIndexOutOfBoundsException).

1. public class TryCatchExample8 {

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

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

Java Multi-catch block

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.

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

Flowchart of Multi-catch Block

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

1. public class MultipleCatchBlock1 {

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

Output:
Arithmetic Exception occurs
rest of the code

Example

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.

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

Example 5

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. }

12
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 co
mpleted");}
10. System.out.println("rest of the code...");
11. }
12. }
Test it Now

Output:

Compile-time error

13
 Java Nested try block

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).

Java Nested try Example

Example 1

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.
16.
17. //inner try block 2
18. try{
19. int a[]=new int[5];
20.
21. //assigning the value out of array bounds

14
22. a[5]=4;
23. }
24.
25. //catch block of inner try block 2
26. catch(ArrayIndexOutOfBoundsException e)
27. {
28. System.out.println(e);
29. }
30.
31.
32. System.out.println("other statement");
33. }
34. //catch block of outer try block
35. catch(Exception e)
36. {
37. System.out.println("handled the exception (outer catch)");
38. }
39.
40. System.out.println("normal flow..");
41. }
42. }

15
 Java finally block

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.

Flowchart of finally block

Note: If you don't handle the exception, before terminating the program, JVM
executes finally block (if any).

Why use Java finally block?

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

16
 Usage of Java finally

Case 1: When an exception does not occur

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.
17. System.out.println("rest of phe code...");
18. }
19. }

Case 2: When an exception occurr but not handled by the catch block

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.

Case 3: When an exception occurs and is handled by the catch block

17
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.

Rule: For each try block there can be zero or more catch blocks, but only one
finally block.

Note: The finally block will not be executed if the program exits (either by calling
System.exit() or by causing a fatal error that causes the process to abort).

18
 Java throw Exception

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.

Java throw keyword

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.

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.

Example 1: Throwing Unchecked Exception

19
 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.

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.

Note: If we throw unchecked exception from a method, it is must to handle the

exception or declare in throws clause.

Throwing Checked Exception

20
 Note: Every subclass of Error and RuntimeException is an unchecked exception in
Java. A checked exception is everything else under the Throwable class.

1. import java.io.*;
2.
3. public class TestThrow2 {
4.
5. //function to check if person is eligible to vote or not
6. public static void method() throws FileNotFoundException {
7.
8. FileReader file = new FileReader("C:\\Users\\Anurati\\Desktop\\abc.txt");

9. BufferedReader fileInput = new BufferedReader(file);

10.
11.
12. throw new FileNotFoundException();
13.
14. }
15. //main method
16. public static void main(String args[]){
17. try
18. {
19. method();
20. }
21. catch (FileNotFoundException e)
22. {
23. e.printStackTrace();
24. }
25. System.out.println("rest of the code...");
26. }
27. }

Output:

21
 Example 3: Throwing User-defined Exception
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. }

22
26. }
27.}

Java Exception Propagation

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.

Note: By default Unchecked Exceptions are forwarded in calling chain (propagated).

Exception Propagation Example

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:

23
 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.

Note: By default, Checked Exceptions are not forwarded in calling chain

(propagated).

Exception Propagation Example

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();

24
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. }

Java throws keyword

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.

Which exception should be declared?

Ans: Checked exception only, because:

o unchecked exception: under our control so we can correct our code.

o error: beyond our control. For example, we are unable to do anything if there
occurs VirtualMachineError or StackOverflowError.

Advantage of Java throws keyword

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

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

Java throws Example

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;

25
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.}
Test it Now

Output:

exception handled
normal flow...
Rule: If we are calling a method that declares an exception, we must either caught or
declare the exception.

There are two cases:

1. Case 1: We have caught the exception i.e. we have handled the exception
using try/catch block.
2. Case 2: We have declared the exception i.e. specified throws keyword with
the method.

Case 1: Handle Exception Using try-catch block

In case we handle the exception, the code will be executed fine whether
exception occurs during the program or not.

Testthrows2.java

26
1. import java.io.*;
2. class M{
3. void method()throws IOException{
4. throw new IOException("device error");
5. }
6. }
7. public class Testthrows2{
8. public static void main(String args[]){
9. try{
10. M m=new M();
11. m.method();
12. }catch(Exception e){System.out.println("exception handled");}
13.
14. System.out.println("normal flow...");
15. }
16.}
Test it Now

Output:

exception handled
normal flow...

Case 2: Declare Exception

o In case we declare the exception, if exception does not occur, the code will be
executed fine.
o In case we declare the exception and the exception occurs, it will be thrown
at runtime because throws does not handle the exception.

Let's see examples for both the scenario.

A) If exception does not occur

Testthrows3.java

1. import java.io.*;
2. class M{
3. void method()throws IOException{
4. System.out.println("device operation performed");
5. }

27
6. }
7. class Testthrows3{
8. public static void main(String args[])throws IOException{//declare exception
9. M m=new M();
10. m.method();
11.
12. System.out.println("normal flow...");
13. }
14.}
Test it Now

Output:

device operation performed

normal flow...

B) If exception occurs

Testthrows4.java

1. import java.io.*;
2. class M{
3. void method()throws IOException{
4. throw new IOException("device error");
5. }
6. }
7. class Testthrows4{
8. public static void main(String args[])throws IOException{//declare exception
9. M m=new M();
10. m.method();
11.
12. System.out.println("normal flow...");
13. }
14.}
Test it Now

Output:

28
Difference between throw and throws in
Java
The throw and throws is the concept of exception handling where the throw
keyword throw the exception explicitly from a method or a block of code
whereas the throws keyword is used in signature of the method.

There are many differences between throw and throws keywords. A list of
differences between throw and throws are given below:

Sr Basis of throw throws

. Differences
no
.

1. Definition Java throw keyword is Java throws keyword

used throw an is used in the method
exception explicitly in signature to declare
the code, inside the an exception which
function or the block might be thrown by
of code. the function while
the execution of the
code.

2. Type of exception Using throw keyword, Using throws keyword,

we can only we can declare both
propagate unchecked checked and
exception i.e., the unchecked exceptions.
checked exception However, the throws
cannot be propagated keyword can be used
using throw only. to propagate checked
exceptions only.

3. Syntax The throw keyword is The throws keyword

followed by an is followed by class
instance of Exception names of Exceptions
to be thrown. to be thrown.

4. Declaration throw is used within throws is used with

the method. the method
signature.

5. Internal We are allowed to We can declare

implementation throw only one multiple exceptions
exception at a time using throws
i.e. we cannot throw keyword that can be
multiple exceptions. thrown by the

29
 method. For
example, main()
throws IOException,
SQLException.

Java Custom Exception

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.

Why use custom exceptions?

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:

o To catch and provide specific treatment to a subset of existing Java

exceptions.
o 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 {

30
2. public WrongFileNameException(String errorMessage) {
3. super(errorMessage);
4. }
5. }
Note: We need to write the constructor that takes the String as the error message
and it is called parent class constructor.

Example 1:
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.
11.// class that uses custom exception InvalidAgeException
12.public class TestCustomException1
13.{
14.
15. // method to check the age
16. static void validate (int age) throws InvalidAgeException{
17. if(age < 18){
18.
19. // throw an object of user defined exception
20. throw new InvalidAgeException("age is not valid to vote");
21. }
22. else {
23. System.out.println("welcome to vote");

31
24. }
25. }
26.
27. // main method
28. public static void main(String args[])
29. {
30. try
31. {
32. // calling the method
33. validate(13);
34. }
35. catch (InvalidAgeException ex)
36. {
37. System.out.println("Caught the exception");
38.
39. // printing the message from InvalidAgeException object
40. System.out.println("Exception occured: " + ex);
41. }
42.
43. System.out.println("rest of the code...");
44. }
45.}

Output:

Example 2:
TestCustomException2.java

1. // class representing custom exception

2. class MyCustomException extends Exception
3. {
4.

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

Output:

33