throw - throws

En Java, throw y throws son dos mecanismos utilizados para manejar excepciones de manera diferente, pero ambos están relacionados con el lanzamiento y la declaración de excepciones. Aunque ambos se refieren a la forma en que las excepciones son manejadas, tienen propósitos y usos diferentes.

Diferencia entre throw y throws

Concepto	throw	throws
Propósito	Se usa para lanzar una excepción.	Se usa para declarar que un método puede lanzar excepciones.
Uso	Se usa dentro de un método o bloque de código.	Se usa en la firma de un método, justo antes de su cuerpo.
Manejo de Excepciones	Lanza una excepción específica.	Declara una o más excepciones que el método puede lanzar.
Excepciones	Puede lanzar tanto excepciones verificadas como no verificadas.	Solo se usa para excepciones verificadas (checked exceptions).

1. throw

El throw se utiliza para lanzar explícitamente una excepción en el código. Es una palabra clave que se usa dentro de un método o bloque de código para generar una excepción de manera controlada. Se puede lanzar tanto excepciones predefinidas como excepciones personalizadas.

Sintaxis básica de throw:

throw new ExcepcionTipo("Mensaje de error");

• ExcepcionTipo: El tipo de la excepción que quieres lanzar, como IOException, ArithmeticException, etc.
• "Mensaje de error": Un mensaje opcional que describe el error.

Ejemplo de uso de throw:

public class ThrowExample {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (IllegalArgumentException e) {
            System.out.println("Excepción capturada: " + e.getMessage());
        }
    }

    public static void validateAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Edad no válida. Debes ser mayor de 18 años.");
        } else {
            System.out.println("Edad válida: " + age);
        }
    }
}

En este ejemplo:

• El método validateAge(int age) lanza una IllegalArgumentException si la edad es menor a 18 años.
• La excepción es capturada en el bloque catch en el método main, lo que evita que el programa termine abruptamente.

Características de throw:

• Se usa para lanzar una excepción en un bloque de código o método.
• Puede lanzar cualquier tipo de excepción (verificada o no verificada).
• El flujo de ejecución del programa se detiene cuando se lanza una excepción con throw, a menos que la excepción sea capturada en un bloque catch.

---

2. throws

El throws es utilizado para declarar que un método puede lanzar una excepción. Especifica las excepciones que un método puede generar, pero no las maneja internamente. Al usar throws, el programador está indicando que la responsabilidad de manejar la excepción recae sobre el método que llama a este método. Esto es especialmente útil cuando trabajamos con excepciones verificadas (checked exceptions).

Sintaxis básica de throws:

public void metodo() throws ExcepcionTipo1, ExcepcionTipo2 {
    // Código que puede generar ExcepcionTipo1 o ExcepcionTipo2
}

• ExcepcionTipo1, ExcepcionTipo2: Son las excepciones que el método puede lanzar.
• metodo: El nombre del método que puede lanzar excepciones.

Ejemplo de uso de throws:

import java.io.IOException;

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

    // Declaramos que este método puede lanzar IOException
    public static void readFile(String fileName) throws IOException {
        if (fileName.equals("example.txt")) {
            throw new IOException("Archivo no encontrado.");
        }
        System.out.println("Archivo leído correctamente.");
    }
}

En este ejemplo:

• El método readFile(String fileName) declara que puede lanzar una excepción IOException mediante el uso de throws.
• El método main es el que captura la excepción utilizando un bloque catch, lo que permite manejar el error cuando se lanza la excepción.

Características de throws:

• Se utiliza en la declaración de un método para indicar que el método puede lanzar una o varias excepciones verificadas.
• No maneja la excepción, solo la declara para que el llamador del método sea responsable de gestionarla.
• Es necesario usar throws si el método maneja excepciones verificadas (checked exceptions), ya que no puedes dejar que una excepción verificable quede sin manejarse.

---

---

Ejemplo combinado de throw y throws

A continuación, se muestra un ejemplo donde se usa tanto throw como throws:

import java.io.*;

public class ThrowThrowsExample {
    public static void main(String[] args) {
        try {
            processFile("test.txt");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    // Declaramos que este método puede lanzar IOException
    public static void processFile(String fileName) throws IOException {
        if (fileName == null) {
            throw new IllegalArgumentException("El nombre del archivo no puede ser nulo");
        }

        readFile(fileName);
    }

    // Método que lanza una excepción de tipo IOException
    public static void readFile(String fileName) throws IOException {
        if (fileName.equals("test.txt")) {
            throw new IOException("Archivo no encontrado.");
        }
        System.out.println("Archivo leído correctamente.");
    }
}

En este ejemplo:

• El método processFile declara que puede lanzar IOException usando throws, lo que significa que el llamador del método (en este caso, main) debe manejar la excepción.
• El método readFile también declara que puede lanzar IOException.
• El método processFile usa throw para lanzar una IllegalArgumentException si el nombre del archivo es nulo.