El manejo de errores en Java se vuelve mucho más poderoso cuando aprendes a crear excepciones personalizadas que reflejan la lógica de tu propio dominio. Con esta técnica puedes lanzar errores específicos, como una película duplicada en una plataforma, y controlarlos sin que tu aplicación se detenga. Es un recurso clave para desarrolladores backend que quieren escribir código robusto y mantenible.

¿Qué tipos de excepciones existen en Java?

Java divide el manejo de errores en dos grandes familias, y entender la diferencia te ahorra horas de depuración.

Las checked exceptions son aquellas que el compilador te obliga a manejar de forma explícita con un bloque try catch. Aparecen cuando trabajas con recursos externos donde algo puede salir mal sin que sea culpa del código en sí.

• IOException: ocurre al leer o escribir archivos.
• FileNotFoundException: se lanza cuando el archivo que buscas no existe.
• ParseException: aparece al fallar la interpretación de una fecha, un número o un dato especial.

Las unchecked exceptions, en cambio, no te obligan a manejarlas, pero pueden tumbar tu programa en tiempo de ejecución si las ignoras.

• NullPointerException: la más famosa, ocurre al acceder a una variable que es null.
• NumberFormatException: se lanza al intentar convertir un texto a número.
• IndexOutOfBoundsException: aparece al acceder a una posición inválida en una lista.
• IllegalArgumentException: se dispara cuando se pasa un argumento no válido a un método.

¿Cuál es la diferencia entre checked y unchecked exceptions? Las checked obligan a manejarlas con try catch en tiempo de compilación. Las unchecked extienden de RuntimeException y no requieren manejo explícito, aunque pueden romper la aplicación si no las controlas.

¿Cómo crear una excepción personalizada en Java?

Java te permite definir tus propias excepciones para representar errores de tu dominio. Esto hace que el código sea más expresivo y los errores más fáciles de rastrear [02:00].

El primer paso es organizar el proyecto. Crea un nuevo paquete dentro de tu estructura, por ejemplo platzi.play.excepcion, para mantener el código limpio.

Dentro de ese paquete, declara una clase pública que extienda de RuntimeException. Esa palabra clave extends es lo que convierte una clase común en una excepción lanzable.

java public class PeliculaExistenteException extends RuntimeException { public PeliculaExistenteException(String titulo) { super("La película con título " + titulo + " ya existe"); } }

La llamada a super envía el mensaje a la clase padre, que en este caso es RuntimeException. Aquí ya estás tocando un concepto de herencia: this referencia al objeto actual y super referencia a la clase de la que heredas.

¿Por qué extender de RuntimeException?

RuntimeException es una de las clases base más comunes para construir excepciones personalizadas. Representa errores que ocurren durante la ejecución del programa, lo que la hace ideal para validaciones de negocio como datos duplicados o estados inválidos.

¿Cómo lanzar y controlar una excepción personalizada?

Una vez creada la clase, el siguiente paso es lanzarla en el momento adecuado. En este caso, dentro del método agregar de una plataforma, antes de insertar una película nueva validas si ya existe [03:30].

java public void agregar(Pelicula pelicula) { Pelicula contenido = this.buscarPorTitulo(pelicula.getTitulo()); if (contenido != null) { throw new PeliculaExistenteException(pelicula.getTitulo()); } // resto de la lógica }

La palabra reservada throw es la que dispara la excepción. Se acompaña de new para instanciar la clase de error. No necesitas un else después, porque throw funciona igual que un return: detiene la ejecución del método en ese punto.

¿Qué hace la palabra throw en Java? Lanza una excepción y corta inmediatamente la ejecución del método actual. El control salta al bloque catch que pueda capturarla, o termina el programa si nadie la maneja.

Si solo lanzas la excepción y no la capturas, tu aplicación se detiene. Para evitarlo, envuelves la llamada en un bloque try catch desde donde se invoca el método, por ejemplo en el main:

java try { plataforma.agregar(pelicula); } catch (PeliculaExistenteException e) { System.out.println(e.getMessage()); }

Podrías capturar RuntimeException y también funcionaría, pero atrapar la excepción específica te da control granular y mensajes más claros para el usuario.

¿Por qué conviene lanzar excepciones en lugar de dejar fallar el sistema?

Lanzar y controlar excepciones es preferible a permitir que el sistema falle silenciosamente. Cuando defines errores explícitos con nombres descriptivos, cualquier persona que lea los logs entiende qué pasó y dónde. Tu aplicación deja de comportarse como una caja negra y se vuelve depurable.

En el ejemplo, intentar agregar la película Coco dos veces dispara el mensaje claro de que ya existe, sin corromper la lista interna ni romper el flujo del programa [05:30].

¿Has creado excepciones personalizadas en tus proyectos? Cuéntanos en los comentarios qué errores de dominio sueles modelar.