El enigma de la calculadora

Excepciones

El lenguaje de programación Java usa excepciones para manejar errores y otros eventos excepcionales.

Qué es una excepción

Una excepción es un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de las instrucciones. En Java, las excepciones se lanzan de forma explícita; el acto de lanzarlas se llama lanzar una excepción y el de manejarlas, capturar una excepción.

En Java, todas las excepciones son subclases de la clase Exception, que a su vez es subclase de Throwable.

Java distingue dos tipos de excepciones:

1. Excepciones verificadas
2. Excepciones no verificadas

Excepciones verificadas

Las excepciones verificadas son condiciones excepcionales que una aplicación debería anticipar y de las que debería recuperarse. Un ejemplo de excepción verificada es FileNotFoundException, que ocurre cuando un método intenta leer un archivo que no existe.

Este tipo de excepción se verifica en tiempo de compilación: los métodos que lanzan excepciones verificadas deben indicarlo en su firma, y el código que llama a un método que podría lanzar una excepción verificada está obligado a manejarla, o el código no compilará.

Todas las excepciones verificadas son subclases de Exception que no extienden RuntimeException.

Excepciones no verificadas

Las excepciones no verificadas son condiciones excepcionales que una aplicación por lo general no puede anticipar ni de las que no puede recuperarse. Un ejemplo de excepción no verificada es NullPointerException, que ocurre cuando un método que espera un valor no nulo recibe null.

Este tipo de excepción no se verifica en tiempo de compilación: los métodos que lanzan excepciones no verificadas no están obligados a indicarlo en su firma, y el código que llama a un método que podría lanzar una excepción no verificada no está obligado a manejarla.

Todas las excepciones no verificadas heredan de RuntimeException, que a su vez extiende Exception.

Lanzar excepciones

Un método en Java puede lanzar una excepción usando la sentencia throw.

Lanzar una excepción verificada

Cuando se lanza una excepción verificada desde un método, es obligatorio indicarlo en la firma del método usando la palabra clave throws, como se muestra en el ejemplo a continuación. Esto obliga al código que hace la llamada a anticipar que podría lanzarse una excepción y a manejarla en consecuencia.

public class InsufficientBalanceException extends Exception {

}

public class BankAccount {
  public void withdraw(double amount) throws InsufficientBalanceException {
    if (balance < amount) {
      throw new InsufficientBalanceException();
    }

    // rest of the method implementation
  }
}

Lanzar una excepción no verificada

Cuando se lanza una excepción no verificada desde un método, no es obligatorio indicarlo en la firma del método, aunque es posible hacerlo.

public class BankAccount {
  public void withdraw(double amount) {
    if (amount < 0) {
      throw new IllegalArgumentException("Cannot withdraw a negative amount");
    }

    // rest of the method implementation
  }
}

Manejar excepciones

El manejo de excepciones en Java se hace con las palabras clave try, catch y finally.

• Las sentencias de código que podrían lanzar una excepción deben ir dentro de un bloque try.
• Al bloque try le siguen uno o más bloques catch que capturan las excepciones lanzadas en el bloque try.
• Opcionalmente, a los bloques catch les sigue un bloque finally que siempre se ejecuta después del bloque try, sin importar si se lanzó una excepción o no.

El siguiente ejemplo muestra cómo funcionan estas palabras clave:

public class ATM {
  public void withdraw(BankAccount bankAccount, double amount) {
    try {
      System.out.println("Withdrawing " + amount);
      bankAccount.withdraw(amount);
      System.out.println("Withdrawal succeeded");
    } catch (InsufficientBalanceException) {
      System.out.println("Withdrawal failed: insufficient balance");
    } catch (RuntimeException e) {
      System.out.println("Withdrawal failed: " + e.getMessage());
    } finally {
      System.out.println("Current balance: " + bankAccount.getBalance());
    }
  }
}

En este ejemplo, cuando no se lanza ninguna excepción, se imprime lo siguiente:

Withdrawing 10.0
Withdrawal succeeded
Current balance: 5.0

Sin embargo, si la sentencia bankAccount.withdraw(amount) lanza una InsufficientBalanceException, se imprime lo siguiente:

Withdrawing 10.0
Withdrawal failed: insufficient balance
Current balance: 5.0

O bien, en caso de que bankAccount.withdraw(amount) lance una excepción no verificada, se imprime lo siguiente:

Withdrawing -10.0
Withdrawal failed: Cannot withdraw a negative amount
Current balance: 5.0

Errores

Java también tiene una categoría aparte llamada errores, que son problemas graves externos a la aplicación. Un ejemplo de error es OutOfMemoryError, que ocurre cuando una aplicación intenta usar más memoria de la que está disponible en el sistema.

Al igual que las excepciones no verificadas, los errores no se verifican en tiempo de compilación. La diferencia es que representan problemas a nivel del sistema y, por lo general, los lanza la máquina virtual de Java o el entorno, y no la aplicación. Por lo general, las aplicaciones no deberían intentar capturarlos ni manejarlos.

Todos los errores en Java heredan de la clase Error.