Exceção de lançamento Java

Onde quer que vamos, acontecimentos imprevisíveis nos aguardam. Terremotos, ações irracionais de pessoas, meteoritos... ou algo mais simples: uma lâmpada queima, um cartão de banco desmagnetiza, um medidor de gasolina quebra. Não podemos desativar acontecimentos imprevisíveis, mas podemos, pelo menos, estar parcialmente preparados para eles. Ou seja, devemos preparar certos mecanismos para lidar com eles. No mundo da programação, especificamente na linguagem Java, os eventos que impedem um programa de funcionar normalmente são chamados de exceções, e os mecanismos para evitar travamentos do programa são chamados de tratamento de exceções. Portanto, quando ocorre um evento inesperado em um programa, como uma divisão por zero, ele deve “lançar” uma exceção. O tratamento de exceções é um aspecto importante da programação Java que ajuda os desenvolvedores a gerenciar erros e exceções que podem ocorrer durante a execução de um programa. Neste artigo, focaremos em um dos conceitos fundamentais do tratamento de exceções: a palavra-chave Java throw e como usá-la para lançar uma exceção.

O que é uma exceção em Java?

Uma exceção é um evento que ocorre durante a execução de um programa e interrompe o fluxo normal das instruções do programa. Quando ocorre uma exceção, a execução do programa é interrompida e a mensagem de erro é exibida no console. Em Java, existem dois tipos de exceções: verificadas e não verificadas. As exceções verificadas são verificadas em tempo de compilação e o compilador garante que elas sejam capturadas ou declaradas pelo método de chamada. Por outro lado, exceções não verificadas não são verificadas em tempo de compilação e podem ser capturadas ou deixadas sem captura. Aqui está um exemplo de código no qual pode ocorrer um erro, mas o compilador o ignora.

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Aqui está a saída do programa:

1-4249290049419214848

O programa foi encerrado corretamente, mas produziu um resultado incorreto. No primeiro caso, porque o argumento da função era negativo e o fatorial não funciona para números negativos. No segundo caso, o resultado estava errado, pois o número é muito grande para contar seu fatorial no intervalo do tipo longo. Aqui está outro exemplo. Vamos escrever um programa no qual dividiremos um número por outro.

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

Neste exemplo, uma ArithmeticException será lançada porque a variável b é zero. No entanto, esse erro não é tratado e o programa é encerrado com um status incorreto.

Como lançar uma exceção em Java

Em Java, as exceções também são objetos, portanto, uma exceção é lançada da mesma forma que um novo objeto Exception criado. Uma exceção é lançada em um programa usando a instrução throw. Normalmente, essas duas operações (criação de objeto e lançamento de exceção) são combinadas em uma:

throw new Exception("error…");

A palavra-chave throw em Java é usada para lançar uma exceção de um método ou bloco de código quando ocorre um erro ou condição excepcional que o programa não consegue tratar em tempo de execução. O fluxo do programa é redirecionado para o bloco catch mais próximo. Este bloco pode gerenciar a exceção.

Exemplo de uso da palavra-chave 'throw'

Para ilustrar a funcionalidade da palavra-chave throw em Java, vamos dar um exemplo. Vamos escrever um método para calcular o fatorial de um número. Se o número for negativo, ele não poderá ser calculado, portanto, uma exceção deverá ser lançada. Da mesma forma, se o número for muito grande, o resultado fatorial excederá o tamanho máximo de um tipo longo e outra exceção será lançada. Aqui temos uma implementação do método:

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

Neste exemplo, se o valor de number for negativo, a palavra-chave throw será usada para lançar uma instância da classe IllegalArgumentException . Se você executar o programa, a mensagem “O argumento não é legal” será exibida no console. A execução do programa será interrompida.

Chega de erros: capturando um exemplo de exceção

Agora vamos relembrar o segundo exemplo, com divisão por zero, e executá-lo com tratamento de exceções.

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Neste exemplo, adicionamos uma construção try-catch para lidar com a exceção de divisão por zero. Resumidamente, try-catch-finally é uma construção da linguagem de programação Java que permite lidar com exceções e executar código, independentemente de uma exceção ter ocorrido ou não. try-catch-finally consiste em três blocos:

O bloco de tentativa . Código potencialmente perigoso está sendo executado aqui. Esse é o código que pode gerar uma exceção. Se ocorrer uma exceção em um bloco try , a execução do código nesse bloco será abortada e o controle será transferido para o bloco catch.
O bloco de captura . Aqui a exceção lançada é tratada. No bloco catch , você pode especificar qual exceção capturar e qual lógica executar quando for capturada.

último

final

A construção try-catch-finally permite um controle mais preciso sobre a execução do programa no caso de situações excepcionais e ajuda a evitar o encerramento inesperado do programa no caso de erros. Agora, vamos voltar ao nosso exemplo. Se a divisão por zero ocorrer durante o método divide, uma ArithmeticException será lançada, que é capturada pelo bloco catch. No bloco catch , simplesmente imprimimos uma mensagem de erro no console. Se não ocorrer nenhuma exceção, o programa continuará sua execução.

lança palavra-chave

A palavra-chave throws é usada na assinatura do método. Se sim, significa que uma exceção está sendo lançada no método. Isso pode propagar exceções na pilha de chamadas e indicar que as exceções não precisam ser tratadas no método atual. Em Java, “throws” também pode ser usado para se referir a exceções personalizadas definidas em um programa. Por exemplo, um método pode realizar uma divisão de dois números, mas lançar uma IllegalArgumentException se o segundo argumento for zero:

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Este método usa a palavra-chave throws para indicar que uma IllegalArgumentException pode ser lançada se o segundo argumento for nulo. Se tal exceção ocorrer durante a execução do método, ela será passada para o método chamador para processamento. Exemplo de chamada de método:

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

Neste exemplo, o método divide() é chamado com os argumentos 10 e 0, o que lançará uma IllegalArgumentException devido à divisão por zero ser impossível. A exceção será capturada por um bloco try-catch e uma mensagem de erro será exibida. O programa resultará em um valor zero, pois a exceção encerra a execução do método divide() .