Manipulação de Exceções Java

Tratamento de exceção Java

No tutorial, aprenderemos sobre diferentes abordagens de tratamento de exceções em Java com a ajuda de exemplos.

No último tutorial, aprendemos sobre exceções Java. Sabemos que as exceções encerram anormalmente a execução de um programa.

É por isso que é importante lidar com exceções. Aqui está uma lista de diferentes abordagens para lidar com exceções em Java.

• tente...capturar bloco
• finalmente bloquear
• lançar e lançar palavra-chave

---

1. Java try...catch bloco

O bloco try-catch é usado para tratar exceções em Java. Aqui está a sintaxe de try...catch quadra:

try {
  // code
}
catch(Exception e) {
  // code
}

Aqui, colocamos o código que pode gerar uma exceção dentro do try quadra. A cada try bloco é seguido por um catch quadra.

Quando ocorre uma exceção, ela é capturada pelo catch quadra. O catch bloco não pode ser usado sem o try quadra.

Exemplo:tratamento de exceção usando try...catch

class Main {
  public static void main(String[] args) {

    try {

      // code that generate exception
      int divideByZero = 5 / 0;
      System.out.println("Rest of code in try block");
    }
    
    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
  }
}

Saída

ArithmeticException => / by zero

No exemplo, estamos tentando dividir um número por 0 . Aqui, esse código gera uma exceção.

Para lidar com a exceção, colocamos o código, 5 / 0 dentro do try quadra. Agora, quando ocorre uma exceção, o restante do código dentro do try bloco é ignorado.

O catch block captura a exceção e as instruções dentro do bloco catch são executadas.

Se nenhuma das instruções no try bloco gera uma exceção, o catch bloco é ignorado.

---

2. Java finalmente bloqueia

Em Java, o finally bloco é sempre executado, não importa se há uma exceção ou não.

O finally bloco é opcional. E, para cada try bloco, pode haver apenas um finally quadra.

A sintaxe básica de finally bloco é:

try {
  //code
}
catch (ExceptionType1 e1) { 
  // catch block
}
finally {
  // finally block always executes
}

Se ocorrer uma exceção, o finally bloco é executado após o try...catch quadra. Caso contrário, ele é executado após o bloco try. Para cada try bloco, pode haver apenas um finally quadra.

---

Exemplo:Manipulação de Exceções Java usando o bloco finally

class Main {
  public static void main(String[] args) {
    try {
      // code that generates exception
      int divideByZero = 5 / 0;
    }

    catch (ArithmeticException e) {
      System.out.println("ArithmeticException => " + e.getMessage());
    }
    
    finally {
      System.out.println("This is the finally block");
    }
  }
}

Saída

ArithmeticException => / by zero
This is the finally block

No exemplo acima, estamos dividindo um número por 0 dentro do try quadra. Aqui, este código gera um ArithmeticException .

A exceção é capturada pelo catch quadra. E, em seguida, o finally bloco é executado.

Observação :É uma boa prática usar o finally quadra. É porque pode incluir códigos de limpeza importantes como,

• código que pode ser ignorado acidentalmente ao retornar, continuar ou interromper
• fechar um arquivo ou conexão

---

3. Java throw and throws palavra-chave

O Java throw palavra-chave é usada para lançar explicitamente uma única exceção.

Quando throw uma exceção, o fluxo do programa se move do try bloco para o catch quadra.

Exemplo:tratamento de exceção usando Java throw

class Main {
  public static void divideByZero() {

    // throw an exception
    throw new ArithmeticException("Trying to divide by 0");
  }

  public static void main(String[] args) {
    divideByZero();
  }
}

Saída

Exception in thread "main" java.lang.ArithmeticException: Trying to divide by 0
        at Main.divideByZero(Main.java:5)
        at Main.main(Main.java:9)

No exemplo acima, estamos lançando explicitamente o ArithmeticException usando o throw palavra-chave.

Da mesma forma, o throws A palavra-chave é usada para declarar o tipo de exceção que pode ocorrer dentro do método. É usado na declaração do método.

Exemplo:Java lança palavra-chave

import java.io.*;

class Main {
  // declareing the type of exception
  public static void findFile() throws IOException {

    // code that may generate IOException
    File newFile = new File("test.txt");
    FileInputStream stream = new FileInputStream(newFile);
  }

  public static void main(String[] args) {
    try {
      findFile();
    }
    catch (IOException e) {
      System.out.println(e);
    }
  }
}

Saída

java.io.FileNotFoundException: test.txt (The system cannot find the file specified)

Quando executamos este programa, se o arquivo test.txt não existe, FileInputStream lança um FileNotFoundException que estende o IOException classe.

O findFile() especifica que um IOException pode ser jogado. O main() O método chama esse método e trata a exceção se for lançada.

Se um método não trata exceções, o tipo de exceção que pode ocorrer dentro dele deve ser especificado no throws cláusula.

Para saber mais, visite Java throw and throws.