Java: manejo de excepciones con constructores en herencia

Java proporciona un mecanismo para manejar excepciones. Para obtener información sobre el manejo de excepciones, puede consultar las excepciones en Java . En este artículo, analizamos el manejo de excepciones con constructores cuando se trata de herencia . En Java, si el constructor de la clase principal genera una excepción comprobada, el constructor de la clase secundaria puede generar la misma excepción o sus clases principales. No hay problema si la clase principal o el constructor de la clase secundaria arrojan excepciones no verificadas. El constructor de la clase secundaria puede generar cualquier excepción no verificada sin buscar un constructor de la clase principal.

Comprender el comportamiento de las llamadas al constructor

Cada vez que otro método llama a un método que arroja alguna excepción, el método que llama es responsable de manejar esa excepción (el método que llama es el método que contiene la llamada real; el método llamado es el método que se llama). En el caso de los constructores, el constructor de la clase secundaria llama al constructor de la clase principal. Significa que el constructor de la clase secundaria es responsable de manejar la excepción lanzada por el constructor de la clase principal. 

Ahora, para manejar una excepción hay dos formas, una es atrapar la excepción y otra es lanzarla. Pero en el caso del constructor, no podemos manejarlo usando el mecanismo try-catch . La razón es que adjuntamos nuestro código que puede generar una excepción en el bloque de prueba y luego atraparlo. La excepción se genera debido a una llamada al constructor de la clase principal, como super(). Significa que si queremos manejar la excepción usando try-catch se muestra en la siguiente ilustración.

Ilustración 1

Child() {

    // Try- catch block 
    try 
    {
        super();
    } 
    
    catch (FileNotFoundException exc) 
    {
      // Handling exception(code)
    }
}

En realidad, no es correcto ya que una llamada a super debe ser la primera declaración en el constructor de la clase secundaria (consulte super en java  , ya que se puede percibir en la siguiente ilustración de la siguiente manera:

Ilustración 2

Child() {
   super(); // either called explicitly or added by the compiler in case of default constructor
   try {
       // your code 
      }
      catch(FileNotFoundException exc) {
       // handling code;  
      }
  }

y, por lo tanto, la excepción no se puede capturar (ya que no está dentro del bloque de prueba) y no podemos manejarla usando el mecanismo de captura de prueba. Es por eso que necesitamos lanzar la excepción. El siguiente código se compilará bien y aparecerá de la siguiente manera:

// parent class constructor throws FileNotFoundException 
Child() throws FileNotFoundException  {
  super(); // either called explicitly or added by the compiler in case of default constructor
  try {
      // your code
     }
     catch(FileNotFoundException exc) {
      // handling code;  
     }
 }

Diferentes casos de uso:

1. El constructor de la clase principal no lanza ninguna excepción marcada
2. El constructor de la clase principal arroja una excepción comprobada

Ahora analicemos cada caso en detalle junto con la justificación a través de programas java limpios.

Caso 1: el constructor de la clase principal no genera ninguna excepción comprobada

Si el constructor de la clase principal no lanza ninguna excepción, la clase secundaria puede lanzar cualquier excepción o no lanzar nada.

Ejemplo 1

// Java Program to Illustrate Exception handling with
// Constructors in inheritance where Parent class
// constructor does not throw any checked exception
 
// Class 1
// Parent class
class Parent {
 
    // Constructor of Parent class
    // Not throwing any checked exception
    Parent()
    {
 
        // Print statement whenever parent class
        // constructor is called
        System.out.println("parent class constructor");
    }
}
 
// Class 2
// Child class
public class Child extends Parent {
 
    // Constructor of child class
    Child()
    {
 
        // Print statement whenever child class
        // constructor is called
        System.out.println("child class constructor");
    }
 
    // main driver method
    public static void main(String[] args)
    {
 
        // Creating object of child class inside main()
        Child child = new Child();
    }
}

parent class constructor
child class constructor

Ejemplo 2 

// Java Program to Illustrate Exception handling with
// Constructors in inheritance where Parent class
// constructor does not throw any checked exception
 
// Class 1
// Parent class
class Parent {
 
    // Constructor of parent class
    // Not throwing any checked exception
    Parent()
    {
 
        // Print statement when constructor of
        // parent class is called
        System.out.println("parent class constructor");
    }
}
 
// Class 2
// Child class
public class Child extends Parent {
    Child() throws Exception
    {
 
        // Print statement when constructor of
        // child class is called
        System.out.println(
            "child class constructor throwing Exception");
    }
 
    // Main driver method
    public static void main(String[] args) throws Exception
    {
 
        // Creating object of child class
        Child child = new Child();
    }
}

parent class constructor
child class constructor throwing Exception

Caso 2: el constructor de la clase principal arroja una excepción comprobada

Si el constructor de la clase principal genera una excepción comprobada, el constructor de la clase secundaria puede generar la misma excepción o su excepción de superclase. Ahora, en este punto, los constructores de clases secundarias deben lanzar la excepción.

Ejemplo 

// Java Program to Illustrate Exception handling with
// Constructors in inheritance where Child class constructor
// Not throwing exception of same type or its parent classes
 
// Importing I/O classes
import java.io.*;
 
// Class 1
// Parent class
class Parent {
 
    // Constructor of parent class
    // Throwing checked exception
    Parent() throws FileNotFoundException
    {
 
        // Print statement when
        // parent class constructor is called
        System.out.println(
            "parent class constructor throwing exception");
    }
}
 
// Class 2
// Child class
class Child extends Parent {
 
    // Constructor of child class
    Child()
    {
        // Print statement when
        // child class constructor is called
        System.out.println("child class constructor");
    }
 
    // Main driver method
    public static void main(String[] args) throws Exception
    {
        // Creating object of child class inside main()
        Child child = new Child();
    }
}

Producción 

error: unreported exception FileNotFoundException; must be caught or declared to be thrown
    Child() {
            ^

Para resolver el error, debemos declarar las excepciones que se lanzarán. Estas excepciones pueden ser de la misma clase o de la clase principal.

Ejemplo 1 

// Java Program to Illustrate Exception handling with Constructors
// in Inheritance where we Resolve the Error we Need to
// Declare the Exceptions to be Thrown
 
// Importing I/O classes
import java.io.*;
 
// Parent class
class Parent {
   
    // throwing checked exception
    Parent() throws FileNotFoundException {
       
        System.out.println("parent class constructor throwing checked exception");
    }
}
 
public class Child extends Parent {
   
    Child() throws FileNotFoundException {
       
        System.out.println("child class constructor throwing same exception");
    }
 
    public static void main(String[] args) throws Exception {
       
        Child child = new Child();
    }
}

Producción 

parent class constructor throwing checked exception
child class constructor throwing same exception

Ejemplo 2 

// Java Program to Illustrate Exception handling with
// Constructors in Inheritance where we Resolve the Error we
// Need to Declare the Exceptions to be Thrown
 
// Importing I/O classes
 
// Importing package
package package1;
// Importing required I/O classes
import java.io.*;
 
// Class 1
// Parent class
class Parent {
 
    // throwing checked exception
    Parent() throws FileNotFoundException
    {
        System.out.println(
            "parent class constructor throwing checked exception");
    }
}
 
// Class 2
// Child class
public class Child extends Parent {
 
    // It can also throw same exception or its parent
    // classes exceptions
    Child() throws IOException
    {
 
        System.out.println(
            "child class constructor throwing super-class exception");
    }
 
    // Main driver method
    public static void main(String[] args) throws Exception
    {
 
        // Creating object of child class
        // inside main() method
        Child child = new Child();
    }
}

Producción 

parent class constructor throwing checked exception
child class constructor throwing super-class exception