Exceções em Java (exceção Java)

Na vida cotidiana, às vezes surgem situações que não planejamos. Por exemplo, você acorda para trabalhar de manhã, procura um carregador para o seu telefone, mas não há. Você vai ao banheiro lavar o rosto - a água foi desligada. Entrei no carro e ele não pegava. Mas uma pessoa é capaz de lidar facilmente com essas situações imprevistas. Tentaremos descobrir como os programas Java lidam com eles neste artigo.

O que são exceções java

No mundo da programação, a ocorrência de erros e situações inesperadas durante a execução do programa é chamada de exceção. Em um programa, exceções podem ocorrer como resultado de ações incorretas do usuário, falta de um recurso necessário no disco ou perda de conexão com o servidor pela rede. Exceções durante a execução do programa também podem ser causadas por erros de programação ou uso incorreto da API. Ao contrário do nosso mundo, o programa deve saber claramente o que fazer em tal situação. Java fornece um mecanismo de exceção para esse propósito.

Resumidamente sobre as palavras-chave tentar, pegar, finalmente, jogar

O tratamento de exceções em Java é baseado no uso das seguintes palavras-chave no programa:

• try – define um bloco de código no qual pode ocorrer uma exceção;
• catch – define o bloco de código no qual a exceção é tratada;
• finalmente – define um bloco de código que é opcional, mas se presente, é executado de qualquer maneira, independentemente dos resultados do bloco try.

Essas palavras-chave são usadas para criar construções de processamento especiais no código do programa: try{}catch, try{}catch{}finally, try{}finally{}.

• throw – usado para gerar uma exceção;
• throws – usado em assinaturas de métodos para avisar que o método pode lançar uma exceção.

Um exemplo de uso de palavras-chave em um programa Java:

//method reads a string from the keyboard

public String input() throws MyException {//warn with throws,
// that the method can throw MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// in the try block we enclose the code in which an exception can occur, in this
// if the compiler tells us that the readLine() method of the class
// BufferedReader may throw an I/O exception
    try {
        s = reader.readLine();
// in the catch block we enclose the code for handling the IOException exception
    } catch (IOException e) {
        System.out.println(e.getMessage());
// close the read stream in the finally block
    } finally {
// when closing the stream, an exception is also possible, for example, if it was not opened, so we “wrap” the code in a try block
        try {
            reader.close();
// write exception handling when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// we decided that an empty string could disrupt the work of our program in the future, for example, on the result of this method, we need to call the substring(1,2) method, so we are forced to interrupt the program execution with the generation of our exception type MyException using throw
        throw new MyException("String can not be empty!");
    }
    return s;
}

Por que precisamos de um mecanismo de exceção?

Vejamos um exemplo do mundo real. Imagine que existe um trecho de uma rodovia com uma ponte de emergência com capacidade de carga limitada. Se um veículo com uma massa superior à capacidade de carga da ponte passar por ela, esta poderá ruir e a situação para o condutor poderá tornar-se, para dizer o mínimo, excepcional. Para evitar que isso aconteça, o serviço rodoviário instala antecipadamente sinais de alerta na estrada. O motorista do carro, olhando a placa de alerta, comparará o peso do seu carro com o peso permitido para circular na ponte. Se ultrapassar, ele fará um desvio. Graças à atuação do serviço rodoviário, os caminhoneiros, em primeiro lugar, tiveram a oportunidade de alterar antecipadamente o seu percurso, em segundo lugar, foram avisados ​​​​sobre o perigo no percurso principal e, por último, foram avisados ​​​​sobre a impossibilidade de utilizar a ponte sob certas condições. A capacidade de prevenir e resolver uma exceção em um programa para que ele possa continuar é uma das razões para usar exceções em Java. O mecanismo de exceção também permite proteger o código que você escreve (interface de programação) contra uso indevido pelo usuário, validando (verificando) os dados recebidos. Agora vamos ser a polícia de trânsito por um segundo. Primeiro, você deve conhecer os locais onde os motoristas podem ter problemas. Em segundo lugar, você precisa preparar e instalar sinais de alerta. Finalmente, é necessário fornecer rotas de desvio em caso de perigo na rota principal. Em Java, o mecanismo de exceção funciona de maneira semelhante. No estágio de desenvolvimento do programa, “protegemos” seções perigosas do código contra exceções usando o bloco try{}, fornecemos caminhos de “backup” usando o bloco catch{} e, no bloco finalmente{}, escrevemos o código que é executado no programa para qualquer resultado. Nos casos em que não possamos fornecer uma “rota de emergência” ou queiramos deliberadamente deixar a escolha ao usuário, devemos pelo menos alertá-lo do perigo. Por que? Imagine a indignação de um motorista que chega a uma ponte de emergência que você não pode atravessar sem ver uma única placa de alerta no caminho! Na programação, ao escrever nossas classes e métodos, nem sempre podemos prever o contexto de sua utilização por outros desenvolvedores em seus programas, portanto não podemos prever a forma 100% correta de resolver uma exceção. Ao mesmo tempo, é uma boa prática alertar os usuários do nosso código sobre a possibilidade de uma exceção. O mecanismo de exceção do Java nos permite fazer isso usando throws — essencialmente declarando o comportamento geral do nosso método para lançar uma exceção, deixando assim para o usuário do método escrever o código para tratar a exceção em Java.

Aviso de "problema"

Quando você não planeja tratar uma exceção em seu método, mas deseja alertar os usuários do método sobre possíveis situações de exceção, use a palavra-chave throws. Esta palavra-chave na assinatura de um método significa que sob certas condições o método pode lançar uma exceção. Este aviso faz parte da interface do método e dá ao usuário o direito de personalizar a implementação do manipulador de exceções. Após os lançamentos indicamos o tipo de exceção que está sendo lançada. Geralmente são descendentes da classe Java Exception . Como Java é uma linguagem orientada a objetos, todas as exceções em Java são objetos.

Hierarquia de exceções Java

Quando ocorre um erro durante a execução do programa, o tempo de execução da JVM cria um objeto do tipo necessário da hierarquia de exceções Java - o conjunto de possíveis exceções herdadas de um “ancestral” comum - a classe Throwable. As situações excepcionais que ocorrem num programa podem ser divididas em dois grupos:

1. Situações em que a restauração da operação normal do programa é impossível
2. A recuperação é possível.

O primeiro grupo inclui situações em que ocorrem exceções herdadas da classe Error . Esses são erros que ocorrem durante a execução do programa como resultado de uma falha da JVM, estouro de memória ou falha do sistema. Eles geralmente indicam problemas sérios que não podem ser resolvidos com software. Este tipo de exceção em Java é classificado como desmarcado na fase de compilação. Este grupo também inclui RuntimeException - exceções, herdeiras da classe Exception , geradas pela JVM durante a execução do programa. Freqüentemente, são causados ​​​​por erros de programação. Essas exceções também são desmarcadas em tempo de compilação, portanto, não é necessário escrever código para lidar com elas. O segundo grupo inclui situações excepcionais que estão previstas na fase de escrita do programa e para as quais deve ser escrito código de processamento. Essas exceções são verificadas. A maior parte do trabalho de um desenvolvedor Java ao lidar com exceções é lidar com tais situações.

Criando uma exceção

Durante a execução do programa, uma exceção é lançada pela JVM ou manualmente usando a instrução throw . Isso cria um objeto de exceção na memória e interrompe a execução do código do programa principal enquanto o manipulador de exceções da JVM tenta encontrar uma maneira de tratar a exceção.

Manipulação de exceção

A criação de blocos de código para os quais fornecemos tratamento de exceções em Java é feita no programa usando as construções try{}catch, try{}catch{}finally, try{}finally{}. Quando uma exceção é gerada em um bloco try, o manipulador de exceção é procurado no bloco catch seguinte. Se o catch contiver um manipulador para esse tipo de exceção, o controle passará para ele. Caso contrário, a JVM procura um manipulador para esse tipo de exceção na cadeia de chamadas de método até que uma captura adequada seja encontrada. Depois que o bloco catch é executado, o controle é passado para um bloco final opcional . Se um bloco catch adequado não for encontrado, a JVM interrompe a execução do programa e exibe uma pilha de chamadas de método - rastreamento de pilha , tendo executado previamente o código do bloco final, se presente. Exemplo de tratamento de exceção:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside method print: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s:list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception was processed. Program continues");
            }
            finally {
                System.out.println("Inside bloсk finally");
            }
            System.out.println("Go program....");
            System.out.println("-----------------");
        }

    }
    }

Os resultados do método principal :

Inside method print: first step
Inside bloсk finally
Go program....
-----------------
Exception: s is null!
Exception was processed. Program continues
Inside bloсk finally
Go program....
-----------------
Inside method print: second step
Inside bloсk finally
Go program....
-----------------

O bloco finallygeralmente é usado para fechar fluxos abertos no bloco try ou para liberar recursos. Porém, ao escrever um programa, nem sempre é possível acompanhar o fechamento de todos os recursos. Para facilitar nossas vidas, os desenvolvedores Java nos ofereceram uma construção try-with-resourcesque fecha automaticamente os recursos abertos em um bloco try. Nosso primeiro exemplo pode ser reescrito assim try-with-resources:

public String input() throws MyException {
    String s = null;
    try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")){
        throw new MyException ("String can not be empty!");
    }
    return s;
}

Graças às capacidades do Java, a partir da versão 7, também podemos combinar a captura de diferentes tipos de exceções em um único bloco, tornando o código mais compacto e legível. Por exemplo:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("String can not be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Resultados

O uso de exceções em Java nos permite aumentar a tolerância a falhas do programa através do uso de caminhos de “backup”, separar a lógica do código principal do código de tratamento de exceções através do uso de blocos catch e também nos dá a oportunidade de delegar tratamento de exceções para o usuário do nosso código usando throws.