· Blocos Try
· Blocos Catch
· Blocos Finalmente
· Juntando tudo
· Blocos try aninhados
· Captura múltiplas exceções

Tente Blocos

Os blocos try são a primeira parte dos blocos try/catch. Eles contêm qualquer código que possa causar uma exceção. Em Java, quando não temos certeza sobre o resultado de uma instrução, podemos colocar essas instruções dentro desse bloco try. Um bloco try pode ser usado em um método ou outro bloco try.

O bloco try é sempre seguido por um bloco catch , que trata a exceção que ocorre no bloco try associado.

Para IOExceptions, coloque qualquer código que esteja criando, lendo, gravando ou fechando um arquivo dentro de um bloco try

Sintaxe

A primeira etapa na construção de um manipulador de exceção é incluir o código que pode gerar uma exceção em um bloco try . Em geral, um bloco try se parece com o seguinte:

try {
    code
}
catch and finally blocks . . .

Exemplo

Para construir um manipulador de exceção para o método writeList da classe ListOfNumbers, inclua as instruções de lançamento de exceção do método writeList em um bloco try . Há mais de uma maneira de fazer isso. Você pode colocar cada linha de código que pode lançar uma exceção dentro de seu próprio bloco try e fornecer manipuladores de exceção separados para cada um. Ou você pode colocar todo o código writeList em um único bloco try e associar vários manipuladores a ele. A listagem a seguir usa um bloco try para todo o método porque o código em questão é muito curto.

private List<Integer> list;
private static final int SIZE = 10;

public void writeList() {
    PrintWriter out = null;
    try {
        System.out.println("Entered try statement");
        FileWriter f = new FileWriter("OutFile.txt");
        out = new PrintWriter(f);
        for (int i = 0; i < SIZE; i++) {
            out.println("Value at: " + i + " = " + list.get(i));
        }
    }
    catch and finally blocks  . . .
}

Tente Bloquear Notas Laterais

• Juntamente com o código que pode acionar uma exceção, os blocos try podem (mas não precisam) também conter código que não causa exceções.
• Os programas podem conter mais de um bloco try. Além disso, é possível ter um bloco try dentro de outro bloco try.

Blocos de captura

A última metade de um bloco try/catch é o bloco catch. Enquanto os blocos try contêm código que causa uma exceção, os blocos catch contêm o código que lida com uma exceção.

Em Java, o bloco catch é usado para tratar a exceção que é capturada do bloco try. O bloco catch inclui o código e é executado se ocorrer uma exceção dentro do bloco try. Se o sistema encontrar uma exceção ao executar as instruções em um bloco try, ele pula o restante das instruções e transfere o controle para o bloco catch correspondente.

O bloco catch captura e manipula as exceções do bloco try declarando o tipo de exceção dentro do parâmetro. A exceção declarada no bloco catch deve ser a exceção da classe pai (isto é, Exception) ou o tipo de exceção gerada. No entanto, a melhor abordagem é declarar o tipo de exceção gerado.

O bloco catch sempre seguirá o bloco try. Depois que o controle sai do bloco try, não há como recuperá-lo para o bloco try.

Sintaxe

Você associa manipuladores de exceção a um bloco try fornecendo um ou mais blocos catch diretamente após o bloco try . Nenhum código pode estar entre o final do bloco try e o início do primeiro bloco catch .

try {
  
} catch (ExceptionType name) {

}

O bloco catch contém código que é executado se e quando o manipulador de exceção é invocado. O sistema de tempo de execução chama o manipulador de exceção quando o manipulador é o primeiro na pilha de chamadas cujo ExceptionType corresponde ao tipo da exceção lançada. O sistema considera uma correspondência se o objeto lançado puder ser atribuído legalmente ao argumento do manipulador de exceção.

Capturar argumentos do bloco

Os blocos catch recebem um argumento, o tipo de exceção que eles devem capturar (manipular). Esses argumentos podem variar de um tipo muito específico de exceção a uma categoria geral de exceções abrangente

Exemplo

A seguir estão dois manipuladores de exceção para o método writeList :

try {

} catch (IndexOutOfBoundsException e) {
    System.err.println("IndexOutOfBoundsException: " + e.getMessage());
} catch (IOException e) {
    System.err.println("Caught IOException: " + e.getMessage());
}

Capturar o conteúdo do bloco

O conteúdo de um bloco catch é o que você deseja que aconteça quando ocorrer uma exceção (por exemplo, quando o arquivo que está sendo acessado não existe). Você pode imprimir uma mensagem ou ter um código que faça algo para corrigir o erro (por exemplo, solicitar o nome do arquivo novamente.

Catch Block Messages (exibindo uma descrição de uma exceção)

Você pode imprimir qualquer mensagem que desejar dentro de um bloco catch.

Usando toString()

Throwable substitui o método toString( ) (definido por Object) para que retorne uma string contendo uma descrição da exceção. Você pode exibir essa descrição em uma instrução println( ) simplesmente passando a exceção como um argumento. Por exemplo, o bloco catch no programa anterior pode ser reescrito assim

catch (ArithmeticException e) {
    System.out.println("Exception: " + e);
    a = 0; // set a to zero and continue
  }

Exception: java.lang.ArithmeticException: / by zero

• getMessage() : retorna uma mensagem de erro específica para cada tipo de exceção. Emparelhe isso com uma instrução println.
• printStackTrace() : imprime o tipo de erro e onde ele ocorreu no programa Esses métodos são especialmente úteis para depurar e encontrar o motivo de uma exceção

• Cada bloco try precisa de pelo menos um bloco catch.
• Os blocos try podem ter vários blocos catch. Veja o exemplo à direita.
• Os blocos catch devem vir diretamente após o bloco try com o qual estão emparelhados.

Blocos Finalmente

Uma palavra-chave finalmente é usada para criar um bloco de código que segue um bloco try. Um bloco de código final sempre é executado independentemente de uma exceção ter ocorrido ou não. Usando um bloco final, ele permite que você execute qualquer instrução de tipo de limpeza que deseja executar, não importa o que aconteça no código protegido. Um bloco final aparece no final do bloco catch. Finalmente, os blocos são usados ​​para anular as referências de objeto e fechar os fluxos de E/S.

O bloco final sempre é executado quando o bloco try sai. Isso garante que o bloco final seja executado mesmo se ocorrer uma exceção inesperada. Mas, finalmente, é útil para mais do que apenas manipulação de exceções - permite que o programador evite que o código de limpeza seja ignorado acidentalmente por um return , continue ou break . Colocar o código de limpeza em um bloco final é sempre uma boa prática, mesmo quando nenhuma exceção é prevista.

O sistema de tempo de execução sempre executa as instruções dentro do bloco final , independentemente do que aconteça no bloco try . Por isso, é o local ideal para realizar a limpeza.

Sintaxe

finally {
  // cleanup code
  }

O bloco finalmente a seguir para o método writeList limpa e fecha PrintWriter e FileWriter .

finally {
    if (out != null) { 
        System.out.println("Closing PrintWriter");
        out.close(); 
    } else { 
        System.out.println("PrintWriter not open");
    } 
    if (f != null) {
	    System.out.println("Closing FileWriter");
	    f.close();
	}	
}

• Finalmente os blocos são uma adição opcional aos blocos try/catch.
• Por fim, os blocos são usados ​​para o código que você deseja executar, não importa o que aconteça excepcionalmente com seu código.
• Eles são a última coisa a ser executada e serão executados toda vez que você executar seu programa.
• Um uso de um bloco final seria garantir que um arquivo seja fechado no final de um programa.

private List<Integer> list;
private static final int SIZE = 10;

public void writeList() {
    PrintWriter out = null;
    try {
        System.out.println("Entered try statement");
        FileWriter f = new FileWriter("OutFile.txt");
        out = new PrintWriter(f);
        for (int i = 0; i < SIZE; i++) {
            out.println("Value at: " + i + " = " + list.get(i));
        }
    } 
    // catch blocks
    catch (IndexOutOfBoundsException e) {
        System.err.println("IndexOutOfBoundsException: " + e.getMessage());
    } 
    catch (IOException e) {
        System.err.println("Caught IOException: " + e.getMessage());
    }
    // finally block
  finally {
    if (out != null) { 
        System.out.println("Closing PrintWriter");
        out.close(); 
    } else { 
        System.out.println("PrintWriter not open");
    } 
    if (f != null) {
     System.out.println("Closing FileWriter");
     f.close();
 } 
}
}

Quando blocos try aninhados são usados, o bloco try interno é executado primeiro. Qualquer exceção lançada no bloco try interno é capturada no bloco catch correspondente. Se um bloco catch correspondente não for encontrado, o bloco catch do bloco try externo será inspecionado. Esse processo continua até que todas as instruções try aninhadas sejam esgotadas. Se nenhum bloco catch correspondente for encontrado, o programa será encerrado de forma anormal.

visite o bloco try-catch aninhado .

Capturar várias exceções

Como você deve saber em java, podemos usar vários blocos catch para lidar com várias exceções

Exemplo :

catch (IOException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
catch (SQLException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Exemplo :

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Bom aprendizado

Junte-se ao Grupo Mouad Oumous Java WhatsApp PARTICIPE

Junte-se ao canal de telegrama Mouad Oumous PARTICIPE

Apoie nossa publicação seguindo-a

Introdução ao Spring Boot: Um Tutorial Abrangente para Iniciantes Spring Boot Security | SSO | OAuth2 com Okta Pergunta de entrevista baseada em fluxo Java8 mais comum - Parte 2 Guia para mapeamento de objetos com ModelMapper em Java Codificação: nivelar uma matriz em Javascript Pergunta de entrevista baseada em fluxo Java8 mais comum - Parte 1