Exception Handling in Java
The Exception Handling in Java is one of the powerful mechanism to handle the runtime
errors so that normal flow of the application can be maintained.
In this page, we will learn about Java exceptions, its type and the difference between checked
and unchecked exceptions.
What is Exception in Java
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.
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 use exception handling. Let's take 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 your program and there occurs an exception at statement
5, the rest of the code will not be executed i.e. statement 6 to 10 will not be executed. If we
perform exception handling, the rest of the statement will be executed. That is why we use
exception handling in Java
Hierarchy of Java Exception classes
The [Link] class is the root class of Java Exception hierarchy which is inherited
by two subclasses: Exception and Error. A hierarchy of Java Exception classes are given
below:
a/0
a=NULL
s.o.p(a)
X=123
Int a[10];
A[12]=10
Char str[10];
Str[16]
Types of Java Exceptions
There are mainly two types of exceptions: checked and unchecked. Here, an error is
considered as the unchecked exception. According to Oracle, there are three types of
exceptions:
1. Checked Exception
2. Unchecked Exception
3. Error
Difference between Checked and Unchecked Exceptions
1) Checked Exception
The classes which directly inherit Throwable class except RuntimeException and Error are
known as checked exceptions e.g. IOException, SQLException etc. Checked exceptions are
checked at compile-time.
2) Unchecked Exception
The classes which inherit RuntimeException are known as unchecked exceptions e.g.
ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.
Unchecked exceptions are not checked at compile-time, but they are checked at runtime.
3) Error
Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError etc.
Java Exception Keywords
There are 5 keywords which are used in handling exceptions in Java.
Keyword Description
The "try" keyword is used to specify a block where we should place exception code. The
try try block must be followed by either catch or finally. It means, we can't use try block
alone.
The "catch" block is used to handle the exception. It must be preceded by try block which
catch
means we can't use catch block alone. It can be followed by finally block later.
The "finally" block is used to execute the important code of the program. It is executed
finally
whether an exception is handled or not.
throw The "throw" keyword is used to throw an exception.
The "throws" keyword is used to declare exceptions. It doesn't throw an exception. It
throws specifies that there may occur an exception in the method. It is always used with method
signature.
Java Exception Handling Example
Let's see an example of Java Exception Handling where we using a try-catch statement to
handle the exception.
1. public class JavaExceptionExample{
2. public static void main(String args[]){
3. Try
4. {
5. //code that may raise exception
6. int data=100/0;
7. }
8. catch(ArithmeticException e)
9. {
10. [Link](e);
11. }
12. //rest code of the program
13. [Link]("rest of the code...");
14. }
15. }
Test it Now
Output:
Exception in thread main [Link]:/ by zero
rest of the code...
In the above example, 100/0 raises an ArithmeticException which is handled by a try-catch
block.
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. [Link]([Link]());//NullPointerException
3) A scenario where NumberFormatException occurs
The wrong formatting of any value may occur NumberFormatException. Suppose I have a
string variable that has characters, converting this variable into digit will occur
NumberFormatException.
1. String s="abc";
2. int i=[Link](s);//NumberFormatException
4) A scenario where ArrayIndexOutOfBoundsException occurs
If you are inserting any value in the wrong index, it would result in
ArrayIndexOutOfBoundsException as shown below:
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 of try block, the rest of the block code will
not execute. So, it is recommended not to keeping the code in try block that will not throw an
exception.
Java try block must be followed by either catch or finally block.
Syntax of Java try-catch
1. try{
2. //code that may throw an exception
3. }catch(Exception_class_Name ref){}
Syntax of try-finally block
1. try{
2. //code that may throw an exception
3. }
4. finally{}
Java catch block
Catch(……)
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.
Problem without exception handling
Let's try to understand the problem if we don't use a try-catch block.
Example 1
1. public class TryCatchExample1 {
2.
3. public static void main(String[] args) {
4.
5. int data=50/0; //may throw exception
6.
7. [Link]("rest of the code");
8.
9. }
10.
11. }
Test it Now
Output:
Exception in thread "main" [Link]: / 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 can be 100 lines of code after exception. So all the code after exception will not be
executed.
Solution by exception handling
Let's see the solution of the above problem by a java try-catch block.
Example 2
1. public class TryCatchExample2 {
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(ArithmeticException e)
10. {
11. [Link](e);
12. }
13. [Link]("rest of the code");
14. }
15.
16. }
Test it Now
Output:
[Link]: / by zero
rest of the code
Now, as displayed in the above example, the rest of the code is executed, i.e., the rest of the
code statement is printed.
Example 3
In this example, we also kept the code in a try block that will not throw an exception.
1. public class TryCatchExample3 {
2.
3. public static void main(String[] args) {
4. try
5. {
6. int data=50/0; //may throw exception
7. // if exception occurs, the remaining statement will not exceute
8. [Link]("rest of the code");
9. }
10. // handling the exception
11. catch(ArithmeticException e)
12. {
13. [Link](e);
14. }
15.
16. }
17.
18. }
Test it Now
Output:
[Link]: / by zero
Here, we can see that 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. [Link](e);
12. }
13. [Link]("rest of the code");
14. }
15.
16. }
Test it Now
Output:
[Link]: / by zero
rest of the code
Example 5
Let's see an example to print a custom message on exception.
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. [Link]("Can't divided by zero");
13. }
14. }
15.
16. }
Test it Now
Output:
Can't divided by zero
Example 6
Let's see an example to resolve the exception in a catch block.
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
10. }
11. // handling the exception
12. catch(Exception e)
13. {
14. // resolving the exception in catch block
15. [Link](i/(j+2));
16. }
17. }
18. }
Test it Now
Output:
25
Example 7
In this example, along with try block, we also enclose exception code in a catch block.
1. public class TryCatchExample7 {
2.
3. public static void main(String[] args) {
4.
5. try
6. {
7. int data1=50/0; //may throw exception
8.
9. }
10. // handling the exception
11. catch(Exception e)
12. {
13. // generating the exception in catch block
14. int data2=50/0; //may throw exception
15.
16. }
17. [Link]("rest of the code");
18. }
19. }
Test it Now
Output:
Exception in thread "main" [Link]: / 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.
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 ArrayIndexOutOfBoundsException
10. catch(ArrayIndexOutOfBoundsException e)
11. {
12. [Link](e);
13. }
14. [Link]("rest of the code");
15. }
16.
17. }
Test it Now
Output:
Exception in thread "main" [Link]: / by zero
Example 9
Let's see an example to handle another unchecked exception.
1. public class TryCatchExample9 {
2.
3. public static void main(String[] args) {
4. try
5. {
6. int arr[]= {1,3,5,7};
7. [Link](arr[10]); //may throw exception
8. }
9. // handling the array exception
10. catch(ArrayIndexOutOfBoundsException e)
11. {
12. [Link](e);
13. }
14. [Link]("rest of the code");
15. }
16.
17. }
Test it Now
Output:
[Link]: 10
rest of the code
Example 10
Let's see an example to handle checked exception.
1. import [Link];
2. import [Link];
3.
4. public class TryCatchExample10 {
5.
6. public static void main(String[] args) {
7.
8.
9. PrintWriter pw;
10. try {
11. pw = new PrintWriter("[Link]"); //may throw exception
12. [Link]("saved");
13. }
14. // providing the checked exception handler
15. catch (FileNotFoundException e) {
16.
17. [Link](e);
18. }
19. [Link]("File saved successfully");
20. }
21. }
Test it Now
Output:
File saved successfully
Internal working of java try-catch 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 exception is handled by the application programmer, normal flow of the application is
maintained i.e. rest of the code is executed
--
Java catch multiple exceptions
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 want to perform different tasks at the occurrence of
different exceptions, use java multi-catch block.
Points to remember
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.
Example 1
Let's see a simple example of java multi-catch block.
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. [Link]("Arithmetic Exception occurs");
12. }
13. catch(ArrayIndexOutOfBoundsException e)
14. {
15. [Link]("ArrayIndexOutOfBounds Exception occurs");
16. }
17. catch(Exception e)
18. {
19. [Link]("Parent Exception occurs");
20. }
21. [Link]("rest of the code");
22. }
23. }
Test it Now
Output:
Arithmetic Exception occurs
rest of the code
Example 2
1. public class MultipleCatchBlock2 {
2.
3. public static void main(String[] args) {
4.
5. try{
6. int a[]=new int[5];
7.
8. [Link](a[10]);
9. }
10. catch(ArithmeticException e)
11. {
12. [Link]("Arithmetic Exception occurs");
13. }
14. catch(ArrayIndexOutOfBoundsException e)
15. {
16. [Link]("ArrayIndexOutOfBounds Exception occurs");
17. }
18. catch(Exception e)
19. {
20. [Link]("Parent Exception occurs");
21. }
22. [Link]("rest of the code");
23. }
24. }
Test it Now
Output:
ArrayIndexOutOfBounds Exception occurs
rest of the code
Example 3
In this example, try block contains two exceptions. But at a time only one exception occurs
and its corresponding catch block is invoked.
1. public class MultipleCatchBlock3 {
2.
3. public static void main(String[] args) {
4.
5. try{
6. int a[]=new int[5];
7. a[5]=30/0;
8. [Link](a[10]);
9. }
10. catch(ArithmeticException e)
11. {
12. [Link]("Arithmetic Exception occurs");
13. }
14. catch(ArrayIndexOutOfBoundsException e)
15. {
16. [Link]("ArrayIndexOutOfBounds Exception occurs");
17. }
18. catch(Exception e)
19. {
20. [Link]("Parent Exception occurs");
21. }
22. [Link]("rest of the code");
23. }
24. }
Test it Now
Output:
Arithmetic Exception occurs
rest of the code
Example 4
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.
1. public class MultipleCatchBlock4 {
2.
3. public static void main(String[] args) {
4.
5. try{
6. String s=null;
7. [Link]([Link]());
8. }
9. catch(ArithmeticException e)
10. {
11. [Link]("Arithmetic Exception occurs");
12. }
13. catch(ArrayIndexOutOfBoundsException e)
14. {
15. [Link]("ArrayIndexOutOfBounds Exception occurs");
16. }
17. catch(Exception e)
18. {
19. [Link]("Parent Exception occurs");
20. }
21. [Link]("rest of the code");
22. }
23. }
Test it Now
Output:
Parent Exception occurs
rest of the code
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).
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){[Link]("common task completed");}
8. catch(ArithmeticException e){[Link]("task1 is completed");}
9. catch(ArrayIndexOutOfBoundsException e){[Link]("task 2 completed");}
10. [Link]("rest of the code...");
11. }
12. }
Test it Now
Output:
Compile-time error
Java Nested try block
The try block within a try block is known as nested try block in java.
Why use nested try block
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.
Syntax:
1. ....
2. try
3. {
4. statement 1;
5. statement 2;
6. try
7. {
8. statement 1;
9. statement 2;
10. }
11. catch(Exception e)
12. {
13. }
14. }
15. catch(Exception e)
16. {
17. }
18. ....
Java nested try example
Let's see a simple example of java nested try block.
1. class Excep6{
2. public static void main(String args[]){
3. try{
4. try{
5. [Link]("going to divide");
6. int b =39/0;
7. }catch(ArithmeticException e){[Link](e);}
8.
9. try{
10. int a[]=new int[5];
11. a[5]=4;
12. }catch(ArrayIndexOutOfBoundsException e){[Link](e);}
13.
14. [Link]("other statement);
15. }catch(Exception e){[Link]("handeled");}
16.
17. [Link]("normal flow..");
18. }
19. }
Java finally block
Java finally block is a block that is used to execute important code such as closing
connection, stream etc.
Java finally block is always executed whether exception is handled or not.
Java finally block follows try or catch block.
Note: If you don't handle exception, before terminating the program, JVM
executes finally block(if any).
Why use java finally
Finally block in java can be used to put "cleanup" code such as closing a file, closing
connection etc.
Usage of Java finally
Let's see the different cases where java finally block can be used.
Case 1
Let's see the java finally example where exception doesn't occur.
1. class TestFinallyBlock{
2. public static void main(String args[]){
3. try{
4. int data=25/5;
5. [Link](data);
6. }
7. catch(NullPointerException e){[Link](e);}
8. finally{[Link]("finally block is always executed");}
9. [Link]("rest of the code...");
10. }
11. }
Test it Now
Output:5
finally block is always executed
rest of the code...
Case 2
Let's see the java finally example where exception occurs and not handled.
1. class TestFinallyBlock1{
2. public static void main(String args[]){
3. try{
4. int data=25/0;
5. [Link](data);
6. }
7. catch(NullPointerException e){[Link](e);}
8. finally{[Link]("finally block is always executed");}
9. [Link]("rest of the code...");
10. }
11. }
Test it Now
Output:finally block is always executed
Exception in thread main [Link]:/ by zero
Case 3
Let's see the java finally example where exception occurs and handled.
1. public class TestFinallyBlock2{
2. public static void main(String args[]){
3. try{
4. int data=25/0;
5. [Link](data);
6. }
7. catch(ArithmeticException e){[Link](e);}
8. finally{[Link]("finally block is always executed");}
9. [Link]("rest of the code...");
10. }
11. }
Test it Now
Output:Exception in thread main [Link]:/ by zero
finally block is always executed
rest of the code...
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 program exits(either by calling
[Link]() or by causing a fatal error that causes the process to abort)
Java throw exception
Java throw keyword
The Java throw keyword is used to explicitly throw an exception.
We can throw either checked or uncheked exception in java by throw keyword. The throw
keyword is mainly used to throw custom exception. We will see custom exceptions later.
The syntax of java throw keyword is given below.
1. throw exception;
Let's see the example of throw IOException.
IOException obj= new IOException("sorry device error);
1. throw obj;
java throw keyword example
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. {
3. static void validate(int age){
4. if(age<18)
5. throw new ArithmeticException("not valid");
6. else
7. [Link]("welcome to vote");
8. }
9. public static void main(String args[]){
10. validate(13);
11. [Link]("rest of the code...");
12. }
13. }
Test it Now
Output:
Exception in thread main [Link]:not valid
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 [Link] is
called exception propagation.
Rule: By default Unchecked Exceptions are forwarded in calling chain
(propagated).
Program of Exception Propagation
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){[Link]("exception handled");}
12. }
13. public static void main(String args[]){
14. TestExceptionPropagation1 obj=new TestExceptionPropagation1();
15. obj.p();
16. [Link]("normal flow...");
17. }
18. }
Test it Now
Output:exception handled
normal flow...
In the above example exception occurs in m() method where it is not handled,so it is
propagated to previous n() method where it is not handled, again it is propagated to p()
method where exception is handled.
Exception can be handled in any method in call stack either in main() method,p() method,n()
method or m() method.
Rule: By default, Checked Exceptions are not forwarded in calling chain
(propagated).
Program which describes that checked exceptions are not propagated
1. class TestExceptionPropagation2{
2. void m(){
3. throw new [Link]("device error");//checked exception
4. }
5. void n(){
6. m();
7. }
8. void p(){
9. try{
10. n();
11. }catch(Exception e){[Link]("exception handeled");}
12. }
13. public static void main(String args[]){
14. TestExceptionPropagation2 obj=new TestExceptionPropagation2();
15. obj.p();
16. [Link]("normal flow");
17. }
18. }
Test it Now
Output:Compile Time Error
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 normal flow can be maintained.
Syntax of java throws
1. return_type method_name() throws exception_class_name{
2. //method code
3. }
Which exception should be declared
Ans) checked exception only, because:
unchecked Exception: under your control so correct your code.
Advantage of Java throws keyword
Now Checked Exception can be propagated (forwarded in call stack).
Java throws example
Let's see the example of java throws clause which describes that checked exceptions can be
propagated by throws keyword.
1. import [Link];
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){[Link]("exception handled");}
13. }
14. public static void main(String args[]){
15. Testthrows1 obj=new Testthrows1();
16. obj.p();
17. [Link]("normal flow...");
18. }
19. }
Test it Now
Output:
exception handled
normal flow...
Difference between throw and throws in
Java
There are many differences between throw and throws keywords. A list of differences
between throw and throws are given below:
No. throw throws
Java throw keyword is used to explicitly throw Java throws keyword is used to declare an
1)
an exception. exception.
2) Throw is followed by an instance. Throws is followed by class.
3) Throw is used within the method. Throws is used with the method signature.
You can declare multiple exceptions e.g.
4) You cannot throw multiple exceptions. public void method()throws
IOException,SQLException.
Java throw example
1. void m(){
2. throw new ArithmeticException("sorry");
3. }
Java throws example
1. void m()throws ArithmeticException{
2. //method code
3. }
Java throw and throws example
1. void m()throws ArithmeticException{
2. throw new ArithmeticException("sorry");
3. }
Difference between final, finally and
finalize
There are many differences between final, finally and finalize. A list of differences between
final, finally and finalize are given below:
No. final finally finalize
Final is used to apply restrictions on class, Finally is used to place Finalize is used to
method and variable. Final class can't be important code, it will be perform clean up
1) inherited, final method can't be executed whether processing just before
overridden and final variable value can't exception is handled or object is garbage
be changed. not. collected.
2) Final is a keyword. Finally is a block. Finalize is a method.
Java final example
1. class FinalExample{
2. public static void main(String[] args){
3. final int x=100;
4. x=200;//Compile Time Error
5. }}
Java finally example
1. class FinallyExample{
2. public static void main(String[] args){
3. try{
4. int x=300;
5. }catch(Exception e){[Link](e);}
6. finally{[Link]("finally block is executed");}
7. }}
Java finalize example
1. class FinalizeExample{
2. public void finalize(){[Link]("finalize called");}
3. public static void main(String[] args){
4. FinalizeExample f1=new FinalizeExample();
5. FinalizeExample f2=new FinalizeExample();
6. f1=null;
7. f2=null;
8. [Link]();
9. }}
Java Custom Exception
If you are creating your own Exception that is known as custom exception or user-defined
exception. Java custom exceptions are used to customize the exception according to user
need.
By the help of custom exception, you can have your own exception and message.
Java provides us facility to create our own exceptions which are basically derived classes of
Exception. For example MyException in below code extends the Exception class.
We pass the string to the constructor of the super class- Exception which is obtained using
“getMessage()” function on the object created.
Let's see a simple example of java custom exception.
1. class InvalidAgeException extends Exception{
2. InvalidAgeException(String s){
3. super(s);
4. }
5. }
1. class TestCustomException1{
2.
3. static void validate(int age)throws InvalidAgeException{
4. if(age<18)
5. throw new InvalidAgeException("not valid");
6. else
7. [Link]("welcome to vote");
8. }
9.
10. public static void main(String args[]){
11. try{
12. validate(13);
13. }catch(Exception m){[Link]("Exception occured: "+m);}
14.
15. [Link]("rest of the code...");
16. }
17. }
Test it Now
Output:Exception occured: InvalidAgeException:not valid
rest of the code...
Example 2: // class representing custom exception
1. class MyCustomException extends Exception
2. {
3.
4. }
5.
6. // class that uses custom exception MyCustomException
7. public class TestCustomException2
8. {
9. // main method
10. public static void main(String args[])
11. {
12. try
13. {
14. // throw an object of user defined exception
15. throw new MyCustomException();
16. }
17. catch (MyCustomException ex)
18. {
19. [Link]("Caught the exception");
20. [Link]([Link]());
21. }
22.
23. [Link]("rest of the code...");
24. }
25. }
Output:
// A Class that represents use-defined expception
class MyException extends Exception
{
// A Class that uses above MyException
public class setText
{
// Driver Program
public static void main(String args[])
{
try
{
// Throw an object of user defined exception
throw new MyException();
}
catch (MyException ex)
{
[Link]("Caught");
[Link]([Link]());
}
}
}
Output:
Caught
null
