Excepciones en

Acerca de 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 generan de forma explícita, y el acto de generarlas se llama lanzar una excepción. El acto de manejar una excepción se llama capturar una excepción.

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

Java distingue dos tipos de excepciones:

1. Excepciones comprobadas
2. Excepciones no comprobadas

Excepciones comprobadas

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

Este tipo de excepción se comprueba en tiempo de compilación: los métodos que lanzan excepciones comprobadas deben especificarlo en la firma del método, y el código que llama a un método que podría lanzar una excepción comprobada debe manejarla, o el código no compilará.

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

Excepciones no comprobadas

Las excepciones no comprobadas son condiciones excepcionales que una aplicación normalmente no puede anticipar ni de las que puede recuperarse. Un ejemplo de excepción no comprobada es la NullPointerException, que ocurre cuando un método que espera un valor no nulo recibe null.

Este tipo de excepción no se comprueba en tiempo de compilación: los métodos que lanzan excepciones no comprobadas no están obligados a especificarlo en la firma del método, y el código que llama a un método que podría lanzar una excepción no comprobada no está obligado a manejarla.

Todas las excepciones no comprobadas heredan de RuntimeException, que a su vez es una extensión de Exception.

Lanzar excepciones

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

Lanzar una excepción comprobada

Cuando se lanza una excepción comprobada desde un método, es obligatorio especificarlo 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 llama 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 comprobada

Cuando se lanza una excepción no comprobada desde un método, no es obligatorio especificarlo en la firma del método, aunque sí está permitido.

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 envolverse en un bloque try.
• Al bloque try le siguen uno o más bloques catch, que capturan las excepciones lanzadas en el bloque try.
• Después de los bloques catch puede haber, de forma opcional, un bloque finally que siempre se ejecuta después del bloque try, independientemente de 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, en caso de que la llamada bankAccount.withdraw(amount) lance una excepción no comprobada, 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 y externos a la aplicación. Un ejemplo de error es el OutOfMemoryError, que ocurre cuando una aplicación intenta usar más memoria de la disponible en el sistema.

Al igual que las excepciones no comprobadas, los errores no se comprueban 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, en lugar de 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.

Cuándo no usar excepciones

Como se dijo antes, las excepciones son eventos que interrumpen el flujo normal de las instrucciones y se usan para manejar eventos excepcionales. Por lo tanto, no se recomienda usar excepciones para el control de flujo en tu aplicación.