Excepciones: try, catch y throw

El problema: el programa se corta a la mitad

Este programa pide un número y lo duplica:

Scanner teclado = new Scanner(System.in);
System.out.print("Escribe un número: ");
int n = Integer.parseInt(teclado.nextLine());
System.out.println("El doble es " + (n * 2));
System.out.println("Gracias por usar el programa.");

Si el usuario escribe hola, la salida es:

Escribe un número: hola
Exception in thread "main" java.lang.NumberFormatException: For input string: "hola"
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at Main.main(Main.java:5)

Ni el doble ni el “Gracias”: el programa murió en la línea 5 y las siguientes nunca se ejecutaron. Eso es una excepción sin atrapar.

Una excepción es un objeto que Java crea cuando algo sale mal, y que “lanza” hacia arriba interrumpiendo la ejecución normal. Si nadie la atrapa, sube hasta main, el programa termina, y lo que ves impreso es el stack trace: la lista de métodos por los que pasó, del más profundo al más superficial. En el ejemplo se lee de abajo hacia arriba — Main.main línea 5 llamó a Integer.parseInt, y ahí explotó.

try / catch: atrapar el problema

try se traduce como “intentar” y catch como “atrapar”, y hacen exactamente eso:

Scanner teclado = new Scanner(System.in);
System.out.print("Escribe un número: ");

try {
    int n = Integer.parseInt(teclado.nextLine());
    System.out.println("El doble es " + (n * 2));
} catch (NumberFormatException e) {
    System.out.println("Eso no era un número.");
}

System.out.println("Gracias por usar el programa.");

Escribe un número: hola
Eso no era un número.
Gracias por usar el programa.

Cómo se lee:

• try { ... } encierra el código que puede fallar. Si algo lanza una excepción ahí adentro, el resto del bloque se saltea inmediatamente.
• catch (NumberFormatException e) { ... } dice “si lo que se lanzó es de este tipo, ejecuta esto”. e es el objeto excepción, con información sobre lo que pasó.
• Después del catch, el programa sigue normalmente. Esa es la diferencia con el ejemplo anterior.

Varios catch

Un mismo try puede tener varios catch, y se evalúan en orden hasta que uno coincide:

try {
    int[] notas = {8, 6, 9};
    int indice = Integer.parseInt(teclado.nextLine());
    System.out.println(notas[indice]);
} catch (NumberFormatException e) {
    System.out.println("Eso no era un número.");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Ese índice no existe: solo hay 3 notas.");
}

finally: pase lo que pase

finally se traduce como “finalmente”, y su bloque se ejecuta siempre: haya fallado o no, se haya atrapado la excepción o no, incluso si hubo un return dentro del try.

Scanner teclado = new Scanner(System.in);
try {
    int n = Integer.parseInt(teclado.nextLine());
    System.out.println(100 / n);
} catch (ArithmeticException e) {
    System.out.println("No se puede dividir por cero.");
} finally {
    teclado.close();
    System.out.println("Listo.");
}

Su razón de ser es liberar cosas que quedarían colgando: archivos abiertos, conexiones a bases de datos, Scanner. Si el cierre estuviera solo al final del try, una excepción se lo saltearía.

Qué trae el objeto excepción

e no es decorativo. Los métodos que más vas a usar:

catch (NumberFormatException e) {
    System.out.println("Entrada inválida: " + e.getMessage());
}

try { ... } catch (Exception e) { }

Las excepciones que más vas a ver

Todas heredan de Exception, que a su vez hereda de Throwable. Es la herencia de siempre, y es lo que hace que catch (Exception e) pueda atraparlas a todas.

throw: lanzar una excepción propia

Hasta acá atrapaste excepciones ajenas. También puedes lanzarlas: es la forma correcta de que un método diga “esto que me pediste no tiene sentido” sin devolver un valor falso ni fallar en silencio.

Vuelve al setter de Encapsulación, que rechazaba las notas inválidas callándose:

public void setNota(double nuevaNota) {
    if (nuevaNota < 0 || nuevaNota > 10) {
        throw new IllegalArgumentException("La nota debe estar entre 0 y 10, llegó: " + nuevaNota);
    }
    this.nota = nuevaNota;
}

throw (“lanzar”) crea la excepción con new y corta el método ahí mismo. Quien llamó decide qué hacer:

try {
    alumno.setNota(-3);
} catch (IllegalArgumentException e) {
    System.out.println("No se pudo cargar la nota: " + e.getMessage());
}

No se pudo cargar la nota: La nota debe estar entre 0 y 10, llegó: -3.0

Compara con la versión que solo hacía if (...) { this.nota = ... }: ahí el valor inválido se descartaba sin que nadie se enterara, y el objeto quedaba con un 0.0 que nadie pidió. Con throw, el problema es imposible de ignorar.

Excepciones propias

Cuando el dominio del programa tiene un error con nombre propio, se crea una clase que herede de Exception:

public class SaldoInsuficienteException extends Exception {
    public SaldoInsuficienteException(String mensaje) {
        super(mensaje);
    }
}

public void retirar(double monto) throws SaldoInsuficienteException {
    if (monto > saldo) {
        throw new SaldoInsuficienteException("Faltan $" + (monto - saldo));
    }
    saldo -= monto;
}

Toda la clase es un constructor que le pasa el mensaje al padre con super(mensaje) — el resto lo hereda de Exception.

throws: declarar que un método puede fallar

Fíjate en la firma de arriba: public void retirar(double monto) throws SaldoInsuficienteException. throws (con s, distinto de throw) no lanza nada: avisa que este método podría lanzar esa excepción, y obliga a quien lo llame a hacerse cargo.

Eso lleva a la última distinción, la que explica por qué unas excepciones te obligan a escribir try y otras no:

Por eso Integer.parseInt("hola") compila sin try (es unchecked), pero abrir un archivo no: IOException es checked y el compilador exige atraparla o declararla con throws.

public void procesar() {
    try {
        cuenta.retirar(1000);
    } catch (SaldoInsuficienteException e) {
        System.out.println(e.getMessage());
    }
}

public void procesar() throws SaldoInsuficienteException {
    cuenta.retirar(1000);
}

Pon a prueba

try {
    System.out.println("A");
    int x = 10 / 0;
    System.out.println("B");
} catch (ArithmeticException e) {
    System.out.println("C");
} finally {
    System.out.println("D");
}

Exception in thread "main" java.lang.NullPointerException:
    Cannot invoke "String.length()" because "<local1>" is null
    at Main.contarLetras(Main.java:12)
    at Main.main(Main.java:5)

public class Main {
    public static void main(String[] args) {
        String[] nombres = new String[3];
        nombres[0] = "Ana";
        System.out.println(contarLetras(nombres[1]));
    }

    static int contarLetras(String texto) {
        return texto.length();
    }
}

static int contarLetras(String texto) {
    if (texto == null) {
        return 0;
    }
    return texto.length();
}

if (texto == null) {
    throw new IllegalArgumentException("contarLetras no acepta null");
}

public static void setEdad(int edad) {
  if (edad < 0) {
       new IllegalArgumentException("Edad negativa: " + edad);
  }
}

public static void main(String[] args) {
   {
      setEdad(-5);
  }  (IllegalArgumentException e) {
      System.out.println(e.());
  }
}

Siguiente paso

Ya cubriste el lenguaje base completo: tipos, control de flujo, métodos, colecciones, orientación a objetos y errores. Para consultar de un vistazo qué significa cada símbolo en cualquier código Java que leas, está el Repaso de sintaxis.