coderz.py

Exception Handling with Method Overriding:

Ambiguity arises when method overriding and exception handling are combined. Which definition should be followed confuses the compiler.

Problem categories:

It has two different kinds of issues, which are as follows:

• Problem 1: If The SuperClass doesn’t declare an exception
• Problem 2: If The SuperClass declares an exception

If The SuperClass does not declare an exception:

Two scenarios that will occur in this issue are as follows:

• Case 1: If a subclass declares a checked exception and the superclass doesn’t
• Case 2: In the event that SuperClass doesn’t declare any exceptions and SubClass does

Let’s talk about the two cases mentioned above and interpret them using the following examples:

Case 1: If the SuperClass doesn’t declare any exceptions and the checked exceptions are declared by the subclass.

Example:

import java.io.*;

class SuperClass {

// SuperClass doesn't declare any exception
void method() {
 System.out.println("SuperClass");
}
}

// SuperClass inherited by the SubClass
class SubClass extends SuperClass {

// method() declaring Checked Exception IOException
void method() throws IOException {

 // IOException is of type Checked Exception
 // so the compiler will give Error

 System.out.println("SubClass");
}

// Driver code
public static void main(String args[]) {
 SuperClass s = new SubClass();
 s.method();
}
}

Output:

void method() throws IOException {
     ^
  overridden method does not throw IOException
1 error

Case 2: In the event that SuperClass doesn’t declare any exceptions and SubClass does

Example:

import java.io.*;

class SuperClass {

 // SuperClass doesn't declare any exception
 void method()
 {
  System.out.println("SuperClass");
 }
}

// SuperClass inherited by the SubClass
class SubClass extends SuperClass {

 // method() declaring Unchecked Exception ArithmeticException
 void method() throws ArithmeticException
 {

  // ArithmeticException is of type Unchecked Exception
  // so the compiler won't give any error

  System.out.println("SubClass");
 }

 // Driver code
 public static void main(String args[])
 {
  SuperClass s = new SubClass();
  s.method();
 }
}

Output:

SubClass

Now let’s focus on the subsequent issue that arises from that, which occurs if The SuperClass declares an exception. Three cases will present themselves in this issue:

• Case 1: When a SuperClass declares an exception and a SubClass declares an exception that is not the SuperClass’s declared exception’s child exception.
• Case 2: When a child exception of a SuperClass declared exception is declared by a SubClass.
• Case 3: When a SuperClass declares an exception but a SubClass does not.

Example for Case 1:

import java.io.*;

class SuperClass {

// SuperClass declares an exception
void method() throws RuntimeException {
 System.out.println("SuperClass");
}
}

// SuperClass inherited by the SubClass
class SubClass extends SuperClass {

// SubClass declaring an exception
// which are not a child exception of RuntimeException
void method() throws Exception {

 // Exception is not a child exception
 // of the RuntimeException
 // So the compiler will give an error

 System.out.println("SubClass");
}

// Driver code
public static void main(String args[]) {
 SuperClass s = new SubClass();
 s.method();
}
}

Output:

void method() throws Exception {
     ^
  overridden method does not throw Exception
1 error

Example for Case 2:

import java.io.*;

class SuperClass {

 // SuperClass declares an exception
 void method() throws RuntimeException
 {
  System.out.println("SuperClass");
 }
}

// SuperClass inherited by the SubClass
class SubClass extends SuperClass {

 // SubClass declaring a child exception
 // of RuntimeException
 void method() throws ArithmeticException
 {

  // ArithmeticException is a child exception
  // of the RuntimeException
  // So the compiler won't give an error
  System.out.println("SubClass");
 }

 // Driver code
 public static void main(String args[])
 {
  SuperClass s = new SubClass();
  s.method();
 }
}

Output:

SubClass

Example for Case 3:

import java.io.*;

class SuperClass {

 // SuperClass declares an exception
 void method() throws IOException
 {
  System.out.println("SuperClass");
 }
}

// SuperClass inherited by the SubClass
class SubClass extends SuperClass {

 // SubClass declaring without exception
 void method()
 {
  System.out.println("SubClass");
 }

 // Driver code
 public static void main(String args[])
 {
  SuperClass s = new SubClass();
 try {
  s.method();
 } catch (IOException e) {
  e.printStackTrace();
 }
 }
}

Output:

SubClass

Note: also read about the Interface vs Abstract class

Follow Me

If you like my post, please follow me to read my latest post on programming and technology.

https://www.instagram.com/coderz.py/

https://www.facebook.com/coderz.py