HOME
In this tutorial, you will see the various questions related to Exception Handling.
Example1
public class Example1 { public static void main(String[] args) { try { int a[] = new int[5]; a[5] = 30 / 0; } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } catch (Exception e) { System.out.println("Parent Exception occurs"); } System.out.println("Continue the program.."); } } Output Arithmetic Exception occurs Continue the program.. Here, we have multiple catch blocks with different type of exceptions. 30 is divided by 0 which throws ArithmeticException. So, catch block for ArithmeticException is executed. Once try-catch block is executed, now the program runs in normal flow.
Example2
public class Example2 { public static void main(String[] args) { try { int a[] = new int[5]; a[5] = 30 / 15; } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } catch (Exception e) { System.out.println("Parent Exception occurs"); } System.out.println("Continue the program.."); } } Output ArrayIndexOutOfBounds Exception occurs Continue the program.. Here, we are trying to access a[5] where index 5 is out of range which throws ArrayIndexOutOfBoundsException. So, catch block for ArrayIndexOutOfBoundsException is executed. Once try-catch block is executed, now the program runs in normal flow.
Example3
public class Example3 { public static void main(String[] args) { try { int a[] = new int[5]; System.out.println(a[7]); } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } catch (Exception e) { System.out.println("Parent Exception occurs"); } System.out.println("Continue the program.."); } } Output ArrayIndexOutOfBounds Exception occurs Continue the program.. Here, Here, we are trying to access a[7] where index 7 is out of range which throws ArrayIndexOutOfBoundsException. So, catch block for ArrayIndexOutOfBoundsException is executed. Once try-catch block is executed, now the program runs in normal flow.
Example4
public class Example4 { public static void main(String[] args) { try { int a[] = new int[5]; a[5] = 30 / 0; System.out.println(a[10]); } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } catch (Exception e) { System.out.println("Parent Exception occurs"); } System.out.println("Continue the program.."); } } Output Arithmetic Exception occurs Continue the program.. Here, try block contains two exceptions. But at a time only one exception occurs and its corresponding catch block is executed. So, first exception is 30 divided by 0 which throws ArithmeticException. So, catch block for ArithmeticException is executed. Once corresponding catch block is executed, now the program runs in normal flow.
Example5
public class Example5 { public static void main(String[] args) { try { String name = null; System.out.println(name.length()); } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } catch (Exception e) { System.out.println("Parent Exception occurs"); } System.out.println("Continue the program.."); } } Output Parent Exception occurs Continue the program.. Here, try block contains NullPointerException. But, there is no NullPointerException present in any of the catch blocks. In such case, the catch block containing the parent exception class Exception will invoked.
Example6
public class Example6 { public static void main(String[] args) { try { int a[] = new int[5]; a[5] = 30 / 0; } catch (Exception e) { System.out.println("common task completed"); } catch (ArithmeticException e) { System.out.println("Arithmetic Exception occurs"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occurs"); } System.out.println("Continue the program.."); } } Output Unresolved compilation problems: Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception Unreachable catch block for ArrayIndexOutOfBoundsException. It is already handled by the catch block for Exception Here, the order of exceptions are not maintained like most specific to general exception. Exception is the parent exception, so should be mentioned as the last exception. As a result, there is a compile time error.
Example7
class Example7 { public static void main(String args[]) { int x = 0; int y = 10; int z = y/x; } } Output Exception in thread "main" java.lang.ArithmeticException: / by zero Here, ArithmeticException is an unchecked exception that are not checked at compiled time. So the program compiles fine, but throws ArithmeticException
Example8
public class Exception8 { public static void main(String[] args) { try { int a[] = { 1, 2, 3, 4 }; for (int i = 1; i <= 4; i++) { System.out.println("a[" + i + "]=" + a[i]); } } catch (Exception e) { System.out.println("error = " + e); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occured"); } } } Output Unresolved compilation problem: Unreachable catch block for ArrayIndexOutOfBoundsException. It is already handled by the catch block for Exception Here, ArrayIndexOutOfBoundsException has been already caught by base class Exception. When a subclass exception is mentioned after base class exception, then error occurs.
Example9
public class Exception9 { public static void main(String[] args) { try { int a[] = { 1, 2, 3, 4 }; for (int i = 1; i <= 4; i++) { System.out.println("a[" + i + "]=" + a[i]); } } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBounds Exception occured"); } catch (Exception e) { System.out.println("error = " + e); } } } Output a[1]=2 a[2]=3 a[3]=4 ArrayIndexOutOfBounds Exception occured Here, try block prints a[1] to a[3] and then throws ArrayIndexOutOfBoundsException which is handled by corresponding catch block.
Example10
public class Example10 { public static void main(String[] args) { // outer try block try { // inner try and catch block 1 try { System.out.println("going to divide by 0"); int b = 40 / 0; } catch (ArithmeticException e) { System.out.println(e); } // inner try and catch block 2 try { int a[] = new int[5]; // assigning the value out of array bounds a[5] = 4; } catch (ArrayIndexOutOfBoundsException e) { System.out.println(e); } System.out.println("No more inner try catch block"); } // catch block of outer try block catch (Exception e) { System.out.println("Handled the exception of outer try"); } System.out.println("Continue the program.."); } } Output going to divide by 0 java.lang.ArithmeticException: / by zero java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5 No more inner try catch block Continue the program.. Here, first inner try catch block is executed. Then second inner try-catch block is executed and at last outer try-catch block is executed. Post all these, the program runs in normal flow.
Example11
public class Example11 { public static void main(String[] args) { // outer try block try { // inner try block 1 try { // inner try block 2 try { int x = 25 / 0; System.out.println(x); } // to handles ArrayIndexOutOfBoundsException catch (ArrayIndexOutOfBoundsException e) { System.out.println("Arithmetic exception"); System.out.println(" inner try block 2"); } } // to handle ArrayIndexOutOfBoundsException catch (ArrayIndexOutOfBoundsException e) { System.out.println("Arithmetic exception"); System.out.println("inner try block 1"); } } // to handle ArithmeticException catch (ArithmeticException e) { System.out.println(e); System.out.println("Outer try block"); } catch (Exception e) { System.out.print("Exception"); System.out.println("Handled in main try block"); } } } Output java.lang.ArithmeticException: / by zero Outer try block Here, 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) and it also 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.
Example12
public class Example12 { public static void main(String[] args) { // outer try block try { // inner try block 1 try { // inner try block 2 try { int x = 25 / 0; System.out.println(x); } // to handles ArrayIndexOutOfBoundsException catch (ArrayIndexOutOfBoundsException e) { System.out.println("Arithmetic exception"); System.out.println(" inner try block 2"); } } // to handle ArithmeticException catch (ArithmeticException e) { System.out.println("Arithmetic exception"); System.out.println("inner try block 1"); } } // to handle ArithmeticException catch (ArithmeticException e) { System.out.print(e); System.out.println("Outer try block"); } catch (Exception e) { System.out.print("Exception"); System.out.println("Handled in main try block"); } } } Output Arithmetic exception inner try block 1 Here, 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) and it does handle the exception, so catch block of inner try block 1 handles the exception.
Example13
public class Example13 { public static void main(String[] args) { try { // below code do not throw any exception int data = 25 / 5; System.out.println(data); } // catch won't be executed catch (NullPointerException e) { System.out.println(e); } // This is executed whether exception occurs or not finally { System.out.println("finally block is always executed"); } System.out.println("Continue the Program .."); } } Output 5 finally block is always executed Continue the Program .. Here, no exception is thrown, so catch block is not executed. finally block is always executed irrespective the catch block is executed or not.
Example14
public class Example14 { public static void main(String[] args) { try { System.out.println("Inside the try block"); // below code throws divide by zero exception int data = 25 / 0; System.out.println(data); } catch (NullPointerException e) { System.out.println("Exception handled"); System.out.println(e); } // executes regardless of exception occurred or not finally { System.out.println("finally block is always executed"); } System.out.println("Continue the Program .."); } } Output Inside the try block finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero Here, 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.
Example15
public class Example15 { public static void main(String[] args) { try { System.out.println("Inside try block"); // below code throws divide by zero exception int data = 25 / 0; System.out.println(data); } // handles the Arithmetic Exception catch (ArithmeticException e) { System.out.println("Exception is handled"); System.out.println(e); } // executes regardless of exception occured or not finally { System.out.println("finally block is always executed"); } System.out.println("Continue the Program .."); } } Output Inside try block Exception is handled java.lang.ArithmeticException: / by zero finally block is always executed Continue the Program .. Here, the 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.
Example16
public class Example16 { public static void main(String[] args) { try { int a = 0; System.out.println("a = " + a); int b = 20 / a; System.out.println("b = " + b); } catch (ArithmeticException e) { System.out.println("Divide by zero error"); } finally { System.out.println("inside the finally block"); } } } Output a = 0 Divide by zero error inside the finally block Here, a is printed. Then , 20 is divided by 0, which throws ArithmeticException and control goes inside the catch block. Also, the finally block is always executed whether an exception occurs or not.
Example 17
public class Exception17 { public static void main(String[] args) { int data = 50 / 0; // may throw exception System.out.println("rest of the code"); } } Output Exception in thread "main" java.lang.ArithmeticException: / by zero Here, there is no try-catch block. So, error is thrown.
Example 18
public class Exception18 { public static void main(String[] args) { try { int data1 = 50 / 0; } catch (Exception e) { // generating the exception in catch block String name = null; System.out.println(name.length()); } System.out.println("Continue the Program .."); } } Output Exception in thread "main" java.lang.NullPointerException Here, 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 19
public class Example19 { static void checkEligibilty(int age, int marks) { if (age < 18 && marks < 90) { throw new ArithmeticException("Student is not eligible for admission"); } else { System.out.println("Student Entry is Valid!!"); } } public static void main(String[] args) { System.out.println("Welcome to the Admission process!!"); checkEligibilty(17, 80); System.out.println("Continue the Program .."); } } Output Exception in thread "main" Welcome to the Admission process!! java.lang.ArithmeticException: Student is not eligible for admission Here, an unchecked exception was thrown and it is not handled, so the program halts.
Example 20
public class Example20 { public static void myMethod(int testnum) throws Exception { System.out.println("start - myMethod"); if (testnum < 100) throw new Exception(); System.out.println("end - myMethod"); return; } public static void main(String args[]) { int testnum = 90; try { System.out.println("try - first statement"); myMethod(testnum); System.out.println("try - last statement"); } catch (Exception ex) { System.out.println("An Exception"); } finally { System.out.println("finally"); } System.out.println("Out of try/catch/finally - statement"); } } Output try - first statement start - myMethod An Exception finally Out of try/catch/finally - statement Here, an exception is thrown in try block which is handled by catch block. A finally block is executed and then the program continues as usual.
Example 21
public class Example21 { public static void main(String args[]) { try { throw 10; } catch(int e) { System.out.println("Got the Exception " + e); } } } Output Unresolved compilation problems: No exception of type int can be thrown; an exception type must be a subclass of Throwable In Java only throwable objects (Throwable objects are instances of any subclass of the Throwable class) can be thrown as exception. So basic data type can no be thrown at all.
Example 22
public class Exception22 { public static void main(String[] args) { try { throw new Test(); } catch (Test t) { System.out.println("Got the Test Exception"); } finally { System.out.println("Inside finally block "); } } } Output Unresolved compilation problems: No exception of type Test can be thrown; an exception type must be a subclass of Throwable Example 23
class Base extends Exception { } class Derived extends Base { } public class Exception23 { public static void main(String[] args) { try { throw new Derived(); } catch (Base b) { System.out.println("Caught base class exception"); } catch (Derived d) { System.out.println("Caught derived class exception"); } } } Output Unresolved compilation problem: Unreachable catch block for Derived. It is already handled by the catch block for Base Example 24
public class Exception8 { String str = "a"; void A() { try { str += "b"; B(); } catch (Exception e) { str += "c"; } } void B() throws Exception { try { str += "d"; C(); } catch (Exception e) { throw new Exception(); } finally { str += "e"; } str += "f"; } void C() throws Exception { throw new Exception(); } void display() { System.out.println(str); } public static void main(String[] args) { Exception8 object = new Exception8(); object.A(); object.display(); } } Output abdec 'throw' keyword is used to explicitly throw an exception.
Call to method C() throws an exception. Thus, control goes in catch block of method B() which again throws an exception. Then finally block is always executed even when an exception occurs. Now, control goes in catch block of method A().
Example 25
public class Exception25 { void m() { int data = 50 / 0; } void n() { m(); } void p() { try { n(); } catch (Exception e) { System.out.println("Exception Handled"); } } public static void main(String args[]) { Exception9 obj = new Exception9(); obj.p(); System.out.println("Continue the program.."); } } Output Exception Handled Continue the program.. Here, 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.
Example 26
public class Exception26 { void m() { throw new IOException("device error");// checked exception } void n() { m(); } void p() { try { n(); } catch (Exception e) { System.out.println("Exception Handled"); } } public static void main(String args[]) { Exception10 obj = new Exception10(); obj.p(); System.out.println("Continue the program.."); } } Output Unresolved compilation problem: Unhandled exception type IOException Here, 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 suppose to be handled, but as it is checked Exception which can not be handled by Exception.
Example 27
public class Exception27 { void m() { throw new ArithmeticException("Arithmetic Exception occured "); } void n() { m(); } void p() { try { n(); } catch (Exception e) { System.out.println("Exception handled"); } } public static void main(String args[]) { Exception11 obj = new Exception11(); obj.p(); System.out.println("Continue the program.."); } } Output Exception handled Continue the program.. Here, exception occurs in the m() method - ArithmeticException 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.
Example 28
public class Exception28 { public static void main(String args[]) { try { int i, sum; sum = 10; for (i = -1; i < 3; ++i) sum = (sum / i); } catch (ArithmeticException e) { System.out.print("0"); } System.out.print(sum); } } Output Unresolved compilation problem: sum cannot be resolved to a variable Here, the value of variable sum is printed outside of try block, sum is declared only in try block, outside try block it is undefined.
Example 29
public class Exception29 { public static void main(String args[]) { try { String str = "beginnersbook"; System.out.println(str.length()); char c = str.charAt(0); c = str.charAt(40); System.out.println(c); } catch (StringIndexOutOfBoundsException e) { System.out.println("StringIndexOutOfBoundsException!!"); } } } Output 13 StringIndexOutOfBoundsException!! Here, exception occurred because the referenced index was not present in the String.
Example 30
public class Exception30 { public static void main(String[] args) { { try { int num = Integer.parseInt("XYZ"); System.out.println(num); } catch (StringIndexOutOfBoundsException e) { System.out.println("String IndexOutOfBounds Exception occurred!!"); } catch (NumberFormatException e) { System.out.println("Number format exception occurred"); } catch (Exception e) { System.out.println("Exception occurred"); } } } } Output Number format exception occurred Here, exception is not of type StringIndexOutOfBounds, so moved to next catch where the exception is handled.
WordPress.com
No comments:
Post a Comment
Note: Only a member of this blog may post a comment.