El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Throw y Throws

Siguiente ►
►

En Java, el manejo de excepciones es una parte crucial para crear aplicaciones robustas y confiables. Dos palabras clave importantes en este contexto son throw y throws. Aunque suenan similares, tienen propósitos y usos diferentes.

Conceptos Clave

Throw

  • Propósito: La palabra clave throw se utiliza para lanzar una excepción explícitamente desde un bloque de código.
  • Sintaxis: throw new ExceptionType("Mensaje de error");
  • Uso: Se utiliza dentro de un método o bloque de código para indicar que ha ocurrido una condición excepcional.

Throws

  • Propósito: La palabra clave throws se utiliza en la declaración de un método para indicar que este método puede lanzar una o más excepciones.
  • Sintaxis: public void metodo() throws ExceptionType1, ExceptionType2 { ... }
  • Uso: Se coloca en la firma del método para informar a los llamadores del método que deben manejar o declarar las excepciones especificadas.

Ejemplos Prácticos

Ejemplo de throw

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

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

Explicación:

  • El método checkAge verifica si la edad es menor de 18.
  • Si la condición se cumple, se lanza una IllegalArgumentException con un mensaje específico.
  • En el método main, se llama a checkAge dentro de un bloque try-catch para manejar la excepción.

Ejemplo de throws

public class ThrowsExample {
    public static void main(String[] args) {
        try {
            divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Excepción capturada: " + e.getMessage());
        }
    }

    public static void divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("División por cero no permitida");
        } else {
            System.out.println("Resultado: " + (a / b));
        }
    }
}

Explicación:

  • El método divide declara que puede lanzar una ArithmeticException utilizando la palabra clave throws.
  • Si el divisor b es cero, se lanza una ArithmeticException.
  • En el método main, se llama a divide dentro de un bloque try-catch para manejar la excepción.

Ejercicio Práctico

Ejercicio 1: Validación de Entrada

Descripción: Crea un método llamado validateInput que tome un número entero como parámetro. Si el número es negativo, el método debe lanzar una IllegalArgumentException con el mensaje "El número no puede ser negativo". Si el número es positivo, el método debe imprimir "Número válido".

Código Inicial:

public class ValidateInputExample {
    public static void main(String[] args) {
        // Llama al método validateInput con diferentes valores para probar
    }

    public static void validateInput(int number) {
        // Implementa la lógica aquí
    }
}

Solución:

public class ValidateInputExample {
    public static void main(String[] args) {
        try {
            validateInput(10);
            validateInput(-5);
        } catch (IllegalArgumentException e) {
            System.out.println("Excepción capturada: " + e.getMessage());
        }
    }

    public static void validateInput(int number) {
        if (number < 0) {
            throw new IllegalArgumentException("El número no puede ser negativo");
        } else {
            System.out.println("Número válido");
        }
    }
}

Explicación:

  • El método validateInput verifica si el número es negativo.
  • Si es negativo, lanza una IllegalArgumentException.
  • En el método main, se llama a validateInput dentro de un bloque try-catch para manejar la excepción.

Resumen

  • throw se utiliza para lanzar una excepción explícitamente desde un bloque de código.
  • throws se utiliza en la declaración de un método para indicar que este método puede lanzar una o más excepciones.
  • Es importante manejar las excepciones adecuadamente para crear aplicaciones robustas y evitar fallos inesperados.

Con estos conceptos y ejemplos, deberías estar preparado para manejar excepciones en Java utilizando throw y throws. ¡Continúa practicando para dominar estas técnicas!

◄ Anterior
◄
Siguiente ►
►

Curso de Programación en Java

Módulo 1: Introducción a Java

Módulo 2: Flujo de Control

Módulo 3: Programación Orientada a Objetos

Módulo 4: Programación Orientada a Objetos Avanzada

Módulo 5: Estructuras de Datos y Colecciones

Módulo 6: Manejo de Excepciones

Módulo 7: Entrada/Salida de Archivos

Módulo 8: Multihilo y Concurrencia

Módulo 9: Redes

Módulo 10: Temas Avanzados

Módulo 11: Frameworks y Librerías de Java

Módulo 12: Construcción de Aplicaciones del Mundo Real

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados