Exception in Java

Error:

• Error is subclass of throwable class and it terminates the program if there is a problem related to system or resources. It signifies a serious problem in the application and are mostly abnormal conditions.

• Error does not occur because of the programmer’s mistakes, but when system is not working properly or a resource is not allocated properly.

• Memory out of bound exception, stack overflow etc., are examples of Error.

• Only object of this class or one of its subclasses can be the argument type in a catch block.

• It is common to make errors while developing or typing a program and this may cause the program to produce unexpected results. It is therefore necessary to detect and manage the error conditions in the program so that the program doesn’t terminate during the execution.

• Sun Microsystems has categorized all exceptions in different categories. For example, for all arithmetic operations are under class called ArithmaticException.java

• For all sql type of exceptions, they created a class called SQLExcption.java, and so on.

Internal Flow by JVM:

1. Take a look at the above class ExceptionDivideByZero.java [in the beginning of this chapter]

2. When the interpreter reads the line int a=1/0;

3. The control goes to JVM and it searches for a category of exception. In this case it is Arithmetic exception.

4. The JVM creates an Object of that class, then it comes back to the same line again with a reference variable of ArithmaticException class.

5. It does check if this line is in the try block.

6. If No, then it goes to the console and prints a message by the getMessage method of ArithmaticException class.

7. The program terminates and won’t come back to our program again.

8. If Yes, refers to the program given below with try and catch

package com.javabykiran.Exception;
/**
@author Java By Kiran
*/
public class ExceptionWithTryCatch { 
  public static void main(String[] args) {   
    System.out.println("111");   
    System.out.println("222");
  try {
    System.out.println("before divide");    
      int a = 1 / 0; 
    System.out.println("after divide");
  } 
  catch (Exception e) {  
    System.out.println("I am in catch block");
    }
    System.out.println("333");   
    System.out.println("444");
   } 
}

    Output:
     111
     222
     before divide
     I am in catch block 
     333
     444
  

9. In this case, it looks for the corresponding catch block and then it sees which class is there in this case (Exception).

10. In this case, the compiler assigns Arithmetic class’s object to Exception reference variable.

11. Exception e = new ArithmeticException();

12. If the above (11) is correct, then it enters in the catch block.

13. If it is not correct, then it considers that the try catch is not written and goes back to console and prints error. Point : 5

14. After executing catch block, the cursor goes to the next line and the execution continues 333 then 444.

15. This is because as soon the interpreter see the exception, it goes for catch block, not in between sentences. In our case it is ‘after divide’
    Some rules are below:

    • Try should be followed by only catch or only finally block or multiple catch or multiple catch and single finally

    • When exception is not raised in the try block statements then catch block will not be executed

    • You can write multiple try-catch blocks

    • When you are writing a multiple catch block, then order or exception must first be subclass and then superclass

    • When exception is raised in the try block statements then only one matching catch block will be executed

    • You should not write any statement between try block and catch block

    • We can write this combination anywhere inside the method. Given below are various combinations that are allowed

Syntax

// Not Allowed as try must followed by catch or finally
   try {
}

// Allowed 
try {
  }
catch(Exception e){
  }
finally{
  }

// Not Allowed 
try {
}
catch(Exception e){
}
Finally {
  }catch(Exception e){
 }

// Allowed 
try {
}catch(NullPointerException npe) {
} catch(ArithmeticException e) {
} catch(Exception e){
}

// Not allowed – Reason: The bigger exception cannot be in the 
// first catch because it will accommodate all exceptions and there
//  will be no chance to reach the second catch of NullpointerException 
try{
}
catch(Exception e) {
}
catch(NullPointerException npe) {
}

void m1(){
   for ( int i=0;i<100;i++){
   try{
     //Insertion Logic
   }catch(Exception e){
     //Student name with error for loop continues
     //again for other students
   }
  }// for loop end
}// m1 ends

Business Use

If we have a requirement of inserting 100 students to DB subject to the condition that if there is any issue in insertion for any student, it should not impact the other students. Now,the requirement is to Add 100 student but if any student fails, other students should not get inserted

void m1(){
    try{
      for (int i=0;i<100;i++){
    //Insertion Logic, if fails should go to catch block
      }// for loop end
    }catch(Exception e){
    //Student name with error; after this it will not go in 
    //for loop again
    }
} // m1 ends

Finally

The finally block is used when an important part of the code needs to be executed. It is always executed whether or not the exceptions are handled.

• Finally block will always get executed until we shut down JVM. To shut down JVM in java we call System.exit (); or we have infinite loop in try block.

• Occurs irrespective of any exception.

• Occurs irrespective of any return value in try or catch.

• Normally, finally block contains the code to release resources like DB connections, IO streams etc.

• You can also write resource cleanup code inside the finalize() method. But finally block is recommended rather than the finalize method for resource cleanup.

package com.javabykiran.Exception;
/**
* @author Java By Kiran
*/
public class FinallyTest { 
int m1() {
  try {
    return 10;
  } catch (Exception e) { 
      return 20;
  } finally { 
      return 30;
  }
  return 40;
  }
}

int m1() {
   try {
    return 10;
   } catch (Exception e) { 
      return 20;
   } finally { 
      return 30;
   }
}

Throw and Throws:

Why are they needed?
To delegate exception from one class to another we use throw and throws.
Consider the case below:

class A{
   // calls m1 of class B
}
class B{
   // calls m2 of class C
}
class C{
   // calls m3 of class D
}
class D{
   // some logic
}

• Consider the above code where A is sending a request to B and

• then to C and then to D

• If the exception occurs at class C m3 method, then what message will A get? Nothing,Program will get terminated at C class

• If we use try and catch at every class and every method then exceptions will get handled but message will not be transferred in the reverse direction, which is from C to B and then to A

• So, to delegate these types of exceptions to caller of the method we use throw and throws from one class to another

• Here, C will delegate its exception to B’s m2 and then B’s m2 will delegate to A’s m1 (); there we will write try and catch and will give an user friendly message

• This scenario is more appropriate when there is remote calling. For example, FLIPKART calls to ICICI bank then ICICI to AIRTEL for sms and to mastercard for authorisation

• In this case, the whole infrastructure is different. This means that there is different ram and different hard disk for every entity. So, if we click a button in FLIPKART and something happens at the ICICI’s end, we will just keep waiting. But by using throw, throws we will get a message that is delegated by ICICI

Runtime / Unchecked Exception

RuntimeException is a superclass of exceptions that may be thrown in the regular course of operation of JVM. Runtime exceptions and its subclasses are known as unchecked exceptions.

• This exception occurs at runtime. Actually, even checked exception occurs at runtime

• All exceptions under runtime exception class are called runtime exceptions or unchecked exceptions

• In the industry, it is not expected that the developer leave these exceptions in the program 1/0 operation … developer should check before this that whether no is zero

  if( b > 0 ){
      int c=a/b 
   }
  

• If any method throws runtime exception, then the caller is not restricted to handle that exception.

package com.javabykiran.Exception; 
  public class RuntimeEx {
    void m1() throws NullPointerException { 
    }
    void m2(){
      m1(); // no error as m1 throws 
      //runtime exception
   }
}

Compile time / Checked Exception

All exceptions which are not runtime exceptions are compile time exceptions.
They are checked at compile time.

• These exceptions are those which are not under runtime exception class hierarchy

• If thrown from any method, they must be handled by caller of the method otherwise it gives compile time error

• The most confusing thing is that some people say it occurs at compile time. That is wrong; exception always occurs at runtime only

• If any method throws runtime exception, then the caller is not restricted to handle that exception.

package com.javabykiran.Exception; 
public class RuntimeEx {
    void m1() throws ClassNotFoundException {
  }
    void m2(){
      m1(); // Error as m1 throws compile time exception
  }
}

OR

package com.javabykiran.Exception; 
 public class RuntimeEx {
  void m1() throws ClassNotFoundException {
  }
  void m2() throws ClassNotFoundException{ 
    m1();
  }
}

package com.javabykiran.Exception; 
  public class ThrowsTest {
       void m1() throws ArithmeticException,ArrayIndexOutOfBoundsException {
    try { 
        m2();
    } catch (ArrayIndexOutOfBoundsException e) { 
    if (1 == 2) {
       throw new ArrayIndexOutOfBoundsException();
    } else {
       throw new ArithmeticException("Don’t do");
    }
}
    return null;
}
     void m2()throws ArrayIndexOutOfBoundsException {   
        System.out.println("its ok");
   // void m3()throws ArrayIndexOutOfBoundsException {} 
     try {
         m4();
     } catch (ArithmeticException e) { 
         System.out.println("m3-ok-ok");
         throw new ArrayIndexOutOfBoundsException();
       }	
}
      void m4() throws ArithmeticException { 
          m5();
      }
      void m5() throws ArithmeticException { 
         int x = 10 / 0;
      }
   }
 }
package com.javabykiran.Exception;
  public class ExceptionLab3 {
    public static void  main(String[] args) { 
     try {
         ThrowsTest ex = new ThrowsTest(); 
         ex.m1();
      } catch (Exception e) { 
            System.out.println(e);         
            System.out.println(e.getMessage());
            e.printStackTrace();
       }
   }
}

    Output:
     its ok
     java.lang.ArithmeticException: Don’t do
                                     at 
     com.javabykiran.Exception.ThrowsTest.m1(ThrowsTest.java:12)
                                     at 
     com.javabykiran.Exception.ExceptionLab3.main(ExceptionLab3.java:7) m3-ok-ok
     java.lang.ArithmeticException: Don’t do 
     Don’t do