palavra-chave throw em Java

A palavra-chave throw em Java é usada para lançar explicitamente uma exceção de um método ou de qualquer bloco de código. É uma parte essencial do mecanismo de tratamento de exceções do Java, permitindo que os desenvolvedores criem e gerenciem condições de erro de forma controlada.

Uso

A palavra-chave throw é normalmente usada para lançar exceções verificadas ou não verificadas. Quando uma exceção é lançada, o fluxo normal do programa é interrompido e o controle é transferido para o bloco try-catch mais próximo que possa tratar a exceção.

Sintaxe

throw new ExceptionType("Error message");

• ExceptionType: O tipo de exceção a ser lançada (por exemplo, ArithmeticException, NullPointerException).
• "Error message": Uma mensagem de cadeia de caracteres que fornece detalhes sobre a exceção.

Exemplos

Exemplo 1: Lançamento de uma exceção verificada

public class ThrowExample {
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    static void checkAge(int age) throws Exception {
        if (age < 18) {
            throw new Exception("Age must be 18 or older.");
        }
    }
}

Neste exemplo, o método checkAge lança um Exception se a idade fornecida for menor que 18 anos. O método main chama checkAge em um bloco try e captura a exceção, imprimindo a mensagem de erro.

Exemplo 2: Lançamento de uma exceção não verificada

public class ThrowExample {
    public static void main(String[] args) {
        try {
            divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }

    static void divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Division by zero is not allowed.");
        }
        System.out.println(a / b);
    }
}

Aqui, o método divide lança um ArithmeticException se o divisor for zero. O método main captura a exceção e imprime a mensagem de erro.

Exemplo 3: Exceção personalizada

class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class ThrowExample {
    public static void main(String[] args) {
        try {
            validate(0);
        } catch (CustomException e) {
            System.out.println(e.getMessage());
        }
    }

    static void validate(int number) throws CustomException {
        if (number <= 0) {
            throw new CustomException("Number must be greater than zero.");
        }
    }
}

Este exemplo demonstra como você pode lançar uma exceção personalizada. O método validate lança um CustomException se o número for menor ou igual a zero, e o método main o captura e trata.

Dicas e práticas recomendadas

• Use mensagens significativas: Sempre forneça mensagens significativas e descritivas ao lançar exceções para facilitar a depuração.

  throw new IllegalArgumentException("Parameter 'x' cannot be negative.");

• Verificado vs. Exceções não verificadas: Use exceções verificadas para condições recuperáveis e exceções não verificadas (exceções de tempo de execução) para erros de programação.
• Exceções personalizadas: Crie exceções personalizadas para representar condições de erro específicas em seu aplicativo. Isso torna seu código mais legível e de fácil manutenção.
• Evite o uso excessivo: Não use exceções em excesso para o fluxo de controle. Eles devem ser usados para condições excepcionais, não para verificações condicionais regulares.
• Exceções de documentos: Sempre documente as exceções que um método pode lançar usando a tag @throws Javadoc.

  /**
   * @throws IllegalArgumentException if the parameter is invalid
   */
  public void someMethod(int param) {
      if (param < 0) {
          throw new IllegalArgumentException("Parameter cannot be negative.");
      }
  }