Guía Detallada sobre la Diferencia entre throw y throws en Java

En Java, el manejo de excepciones es una parte crucial para crear programas robustos. Las palabras clave throw y throws están directamente relacionadas con las excepciones, pero se utilizan en diferentes contextos y con propósitos distintos. Esta guía está diseñada para explicar estas dos palabras clave de manera clara y concisa, ideal para principiantes en Java.

1. ¿Qué es una excepción en Java?

Antes de entrar en los detalles de throw y throws, es importante comprender qué es una excepción. En Java, una excepción es un evento que interrumpe el flujo normal de ejecución de un programa. Las excepciones pueden ocurrir por varios motivos, como errores en la entrada de datos, falta de recursos, operaciones ilegales, entre otros.

Java ofrece mecanismos para manejar estas excepciones de manera controlada, utilizando las palabras clave throw y throws.

2. ¿Qué es la palabra clave throw?

La palabra clave throw se utiliza en Java para lanzar una excepción explícitamente. Cuando usas throw, estás creando una excepción en el flujo de ejecución del programa. Esta excepción puede ser una instancia de cualquier clase que extienda de la clase Throwable, que es la clase base para todas las excepciones y errores en Java.

Sintaxis:

throw new ExceptionType("Mensaje de error");

• ExceptionType: Es el tipo de la excepción que deseas lanzar (puede ser cualquier tipo de excepción en Java, como IOException, NullPointerException, etc.).
• “Mensaje de error”: Es un mensaje opcional que describe el error.

Ejemplo de uso de throw:

public class TestThrow {
    public static void main(String[] args) {
        try {
            checkAge(15); // Llamada a una función que verifica la edad
        } catch (Exception e) {
            System.out.println(e.getMessage()); // Imprime el mensaje de la excepción
        }
    }

    public static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("La edad debe ser mayor o igual a 18");
        }
        System.out.println("Edad válida.");
    }
}

Explicación:

• En el código anterior, la función checkAge lanza una excepción IllegalArgumentException si la edad es menor a 18.
• La excepción se maneja en el bloque catch, donde el mensaje de error se imprime.

3. ¿Qué es la palabra clave throws?

La palabra clave throws se usa en la firma de un método para declarar que un método puede lanzar una o más excepciones. Al utilizar throws, el programador indica que el método no manejará la excepción internamente, sino que permitirá que la excepción sea manejada por el método que llame a ese método.

Sintaxis:

public void metodo() throws ExceptionType {
    // Código que puede lanzar una excepción
}

• ExceptionType: Es el tipo de excepción que el método podría lanzar. Si el método puede lanzar varias excepciones, se listan todas, separadas por comas.

Ejemplo de uso de throws:

public class TestThrows {
    public static void main(String[] args) {
        try {
            readFile(); // Llamada a un método que puede lanzar una excepción
        } catch (Exception e) {
            System.out.println("Error al leer el archivo: " + e.getMessage());
        }
    }

    public static void readFile() throws Exception {
        // Simulación de un error al leer un archivo
        throw new Exception("Archivo no encontrado");
    }
}

Explicación:

• El método readFile declara que puede lanzar una excepción Exception usando la palabra clave throws.
• En el main, llamamos a readFile(), y la excepción que lanza es manejada dentro del bloque catch.

4. Diferencias clave entre throw y throws

Característica	throw	throws
Propósito	Se usa para lanzar una excepción dentro de un método.	Se usa para declarar que un método puede lanzar una excepción.
Dónde se usa	Dentro del cuerpo de un método.	En la firma del método, después de los parámetros.
Ejemplo	throw new Exception("Mensaje de error");	public void metodo() throws Exception;
Manejo de excepciones	El programador lanza la excepción manualmente.	El programador declara que el método puede lanzar una excepción, pero no la maneja.
Obligatorio	No es obligatorio usar throw en todos los métodos.	Es obligatorio declarar con throws si el método puede lanzar excepciones verificadas.

5. Excepciones verificadas y no verificadas

En Java, las excepciones se dividen en dos categorías principales: excepciones verificadas (checked exceptions) y no verificadas (unchecked exceptions).

• Excepciones verificadas: Son excepciones que Java obliga a manejar o declarar, como IOException, SQLException, entre otras. Estas excepciones deben ser declaradas usando throws en la firma del método.

• Excepciones no verificadas: Son excepciones que no es necesario manejar o declarar, como NullPointerException, ArrayIndexOutOfBoundsException, etc. No necesitan ser declaradas con throws, pero pueden ser lanzadas con throw.

Ejemplo con excepción verificada:

public class EjemploChecked {
    public static void main(String[] args) {
        try {
            leerArchivo();
        } catch (IOException e) {
            System.out.println("Error al leer el archivo: " + e.getMessage());
        }
    }

    public static void leerArchivo() throws IOException {
        // Simulación de un error de lectura de archivo
        throw new IOException("Archivo no encontrado");
    }
}

Explicación: La excepción IOException es una excepción verificada, por lo que el método leerArchivo debe declararla con throws.

6. Ejercicios

A continuación, te dejo algunos ejercicios para practicar. No los resolveré para que puedas intentarlos por ti mismo.

1. Ejercicio 1: Crea un método llamado checkDivision que acepte dos parámetros enteros. Si el divisor es cero, lanza una excepción ArithmeticException usando throw. Asegúrate de que el método que llama a checkDivision maneje la excepción con un bloque try-catch.

2. Ejercicio 2: Crea un programa con dos métodos. El primer método debe lanzar una excepción verificada FileNotFoundException, y el segundo método debe manejar esta excepción usando throws.

3. Ejercicio 3: Diseña un programa que tenga un método validateInput que reciba un número. Si el número es negativo, lanza una excepción IllegalArgumentException usando throw. Asegúrate de que el método que llama a validateInput capture la excepción.

7. Conclusión

En resumen, throw y throws son dos palabras clave en Java que se utilizan para manejar excepciones, pero con propósitos diferentes:

• throw se usa para lanzar explícitamente una excepción en el cuerpo de un método.
• throws se usa en la firma de un método para declarar que dicho método puede lanzar una o más excepciones.

Ambas son esenciales para crear programas robustos que manejen los errores de manera adecuada. Como principiante, es importante practicar el uso de estas palabras clave y entender cuándo y cómo emplearlas.