Exception Handling in Method Overriding

• Exception Rules for Overriding Methods

  When it comes to exception handling in method overriding, there are certain rules to follow:
  An overriding method is not allowed to throw any checked exceptions that are not declared in the overridden method's exception list. An overriding method can throw any unchecked exception, regardless of whether the overridden method declares it or not. If the overridden method throws a checked exception, the overriding method can choose not to throw any exception or can throw a subtype of the exception declared in the superclass.



• Checked Exceptions and Overriding Methods

  When dealing with checked exceptions, the overriding method must adhere to the exception handling rules: It can choose not to throw any exception, even if the overridden method declares a checked exception. It can throw the same exception declared in the superclass or its subtype. It is not allowed to throw a new or broader checked exception that is not declared in the overridden method.



• Unchecked Exceptions and Overriding Methods

  For unchecked exceptions, such as RuntimeExceptions, the overriding method has more flexibility: It can choose not to throw any exception, regardless of whether the overridden method throws an unchecked exception or not. It can throw the same unchecked exception declared in the superclass or its subtype. It can also throw new unchecked exceptions that are not declared in the overridden method.



• Covariant Return Types and Exception Handling

  In method overriding, it is possible to have covariant return types, where the overriding method returns a subtype of the return type of the overridden method. However, when it comes to exception handling, the same rules still apply. The overriding method must adhere to the exception handling rules mentioned earlier and cannot throw checked exceptions that are not declared in the overridden method.

Best Practices for Exception Handling in Method Overriding

• Follow the Principle of Least Surprise

  When overriding a method, it is important to maintain consistency with the exception handling behavior of the superclass method. If the superclass method throws certain exceptions, the overriding method should follow the same behavior or throw a subtype of those exceptions.



• Document Exception Handling Expectations

  Properly document the exceptions that the overriding method may throw. This helps other developers understand the expected exception behavior and handle them accordingly when using the subclass.



• Use Specific Exception Types Whenever Possible

  When throwing exceptions in an overriding method, it is best to use specific exception types instead of general ones. This provides more precise information about the exceptional condition and allows for better error handling and debugging.



• Preserve or Rethrow Exceptions Appropriately

  When catching exceptions in an overriding method, carefully consider whether to handle the exception within the method or propagate it further up the call stack. Preserve the original exception context or rethrow it using the throw keyword if necessary.



• Avoid Swallowing Exceptions

  Avoid catching exceptions in an overriding method without proper handling or logging. Swallowing exceptions can lead to silent failures and make debugging and error resolution challenging.

Exception Handling with Method Overriding

Exception Handling with Method Overriding Where SuperClass does not declare any exception and subclass declare checked exception

package DockerTpoint;
import java.io.*;    
class ParentClass{   
  void message() {  
    System.out.println("parent Class message method");  
    }    
}        
public class Child extends ParentClass{    
    // overriding the method in child class so compile time give error 
  void message() throws IOException {    
    System.out.println("Child Class message method");    
  }  
  
  public static void main(String args[]) {    
    ParentClass parent = new Child ();    
    parent.message();    
  }    
} 

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Exception IOException is not compatible with throws clause in ParentClass.message()

	at HELLO/DockerTpoint.Child.message(Child.java:11)
	at HELLO/DockerTpoint.Child.child(Child.java:17) 

If Super class doesn't declare any exception

If SubClass declares Unchecked exception and SuperClass does not declare any exception

package DockerTpoint;
import java.io.*;    
class ParentClass{   
  void message() {  
    System.out.println("parent Class message method");  
    }    
}        
public class Child extends ParentClass{    
  void message() throws ArithmeticException{
        // Because ArithmeticException is an Unchecked Exception, the compiler will not generate an error.
        System.out.println("Child Class");
  } 
  public static void main(String args[]) {    
    ParentClass parent = new Child();    
    parent.message();    
  }    
} 

Child Class 

Example : subclass overridden method declares parent exception

package DockerTpoint;
import java.io.*;    
class ParentClass{   
  void message()throws ArithmeticException {  
    System.out.println("parent Class message method");  
    }    
}        
public class Child extends ParentClass{    
  void message() throws Exception{
        System.out.println("Child Class");
  } 
  public static void main(String args[]) {    
    ParentClass parent = new Child();    
    try {
    	parent.message();    
     } 
     catch (Exception e) {
	 e.printStackTrace();
    }
  }    
}

 Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Exception Exception is not compatible with throws clause in ParentClass.message()

	at HELLO/DockerTpoint.Child.message(Child.java:12)
	at HELLO/DockerTpoint.Child.main(Child.java:18)
 

Example : when the same exception is declared by a subclass's overridden method

package DockerTpoint;
import java.io.*;    
class ParentClass{   
  void message()throws Exception {  
    System.out.println("parent Class message method");  
    }    
}        
public class Child extends ParentClass{    
  void message() throws Exception{
        System.out.println("Child Class");
  } 
  public static void main(String args[]) {    
    ParentClass parent = new Child();    
    try {
    	parent.message();    
     } 
     catch (Exception e) {
	 e.printStackTrace();
    }
  }    
}

Child Class
 

Example : when a method in a subclass is overridden but does not declare an exception

package DockerTpoint;
import java.io.*;    
class ParentClass{   
  void message()  {  
    System.out.println("parent Class message method");  
    }    
}        
public class Child extends ParentClass{    
  void message()  {
        System.out.println("Child Class");
  } 
  public static void main(String args[]) {    
    ParentClass parent = new Child();    
    parent.message();    
  }    
}

Child Class
 

Example : when a method that is overridden by a subclass declares a subclass exception

package DockerTpoint;
import java.io.*;    
class ParentClass{   
  void message()  {  
    System.out.println("parent Class message method");  
    }    
}        
public class Child extends ParentClass{    
  void message() throws ArithmeticException {
        System.out.println("Child Class");
  } 
  public static void main(String args[]) {    
    ParentClass parent = new Child();    
    try {
    	parent.message();    
     } 
     catch (Exception e) {
	 e.printStackTrace();
    }
  }    
}

Child Class