Manejo de excepciones con anulación de métodos en Java

Una excepción es un evento no deseado o inesperado que ocurre durante la ejecución de un programa, es decir, en tiempo de ejecución, que interrumpe el flujo normal de las instrucciones del programa. El manejo de excepciones se usa para manejar errores de tiempo de ejecución. Ayuda a mantener el flujo normal del programa. 
En cualquier lenguaje de programación orientado a objetos, Overriding es una función que permite que una subclase o clase secundaria proporcione una implementación específica de un método que ya proporciona una de sus superclases o clases principales. Cuando un método en una subclase tiene el mismo nombre, los mismos parámetros o firma, y ​​el mismo tipo de retorno (o subtipo) que un método en su superclase, entonces se dice que el método en la subclase anula el método en la superclase. -clase.

Manejo de excepciones con reemplazo de métodos
Cuando el manejo de excepciones está involucrado con el reemplazo de métodos, se produce ambigüedad. El compilador se confunde en cuanto a qué definición se debe seguir. 

Tipos de problemas:

Hay dos tipos de problemas asociados con él que son los siguientes:

1. Problema 1 : si The SuperClass no declara una excepción
2. Problema 2 : si The SuperClass declara una excepción

Discutamos diferentes casos bajo estos problemas y percibamos sus resultados.

Problema 1 : si The SuperClass no declara una excepción

En este problema, dos casos que se van a presentar son los siguientes:

• Caso 1: si SuperClass no declara ninguna excepción y la subclase declara una excepción marcada
• Caso 2: si SuperClass no declara ninguna excepción y SubClass declara una excepción no verificada

Analicemos los dos casos anteriores e interpretémoslos con la ayuda de ejemplos de la siguiente manera:

Caso 1: Si SuperClass no declara ninguna excepción y la subclase declara una excepción marcada.

Ejemplo 

// Java Program to Illustrate Exception Handling
// with Method Overriding
// Where SuperClass does not declare any exception and
// subclass declare checked exception
 
// Importing required classes
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();
  }
}

Producción:

Caso 2: si SuperClass no declara ninguna excepción y SubClass declara una excepción no verificada

Ejemplo 

// Java Program to Illustrate Exception Handling
// with Method Overriding
// Where SuperClass doesn't declare any exception and
// SubClass declare Unchecked exception
 
// Importing required classes
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();
    }
}

SubClass

Ahora, pensando en el siguiente problema asociado con eso, es si The SuperClass declara una excepción. En este problema se presentarán 3 casos de la siguiente manera:

• Caso 1: Si SuperClass declara una excepción y SubClass declara excepciones distintas a la excepción secundaria de la SuperClass declarada Exception.
• Caso 2: Si SuperClass declara una excepción y SubClass declara una excepción secundaria de la SuperClass declarada Exception.
• Caso 3: Si SuperClass declara una excepción y SubClass declara sin excepción.

Ahora interpretemos estos casos implementando e interpretando con un ejemplo. 

Caso 1: Si SuperClass declara una excepción y SubClass declara excepciones distintas a la excepción secundaria de la SuperClass declarada Exception.

Ejemplo 

// Java Program to Illustrate Exception Handling
// with Method Overriding
// Where SuperClass declares an exception and
// SubClass declares exceptions other than the child exception
// of the SuperClass declared Exception.
 
// Importing required classes
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();
  }
}

Producción:

Caso 2: Si SuperClass declara una excepción y SubClass declara una excepción secundaria de la SuperClass declarada Exception.

Ejemplo

// Java Program to Illustrate Exception Handling
// with Method Overriding
// Where SuperClass declares an exception and
// SubClass declares a child exception
// of the SuperClass declared Exception
 
// Importing required classes
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();
    }
}

SubClass

Caso 3: Si SuperClass declara una excepción y SubClass declara sin excepción.

Ejemplo

// Java Program to Illustrate Exception Handling
// with Method Overriding
// Where SuperClass declares an exception and
// SubClass declares without exception
 
// Importing required classes
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();
    }
    }
}

SubClass

Conclusiones:

Como se percibe de los 3 ejemplos anteriores para manejar tales excepciones, las siguientes conclusiones derivadas son las siguientes: 

• Si SuperClass no declara una excepción, entonces SubClass solo puede declarar excepciones no verificadas, pero no las excepciones verificadas.
• Si SuperClass declara una excepción, entonces SubClass solo puede declarar las excepciones iguales o secundarias de la excepción declarada por SuperClass y cualquier excepción de tiempo de ejecución nueva, pero no cualquier excepción verificada nueva en el mismo nivel o superior.
• Si SuperClass declara una excepción, entonces SubClass puede declarar sin excepción.