Java tentar... pegar

Neste tutorial, aprenderemos sobre a instrução try catch em Java com a ajuda de exemplos.

O try...catch bloco em Java é usado para lidar com exceções e evita o encerramento anormal do programa.

Aqui está a sintaxe de um try...catch bloco em Java.

try{
  // code
}
catch(exception) {
  // code
}

O try block inclui o código que pode gerar uma exceção.

O catch bloco inclui o código que é executado quando ocorre uma exceção dentro do try quadra.

Exemplo:Java try...catch bloco

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

    try {
      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 acima, observe a linha,

int divideByZero = 5 / 0;

Aqui, estamos tentando dividir um número por zero . Nesse caso, ocorre uma exceção. Portanto, incluímos este código dentro do try quadra.

Quando o programa encontra este código, ArithmeticException ocorre. E a exceção é capturada pelo catch bloco e executa o código dentro do catch quadra.

O catch o bloco só é executado se existir uma exceção dentro do try quadra.

Observação :Em Java, podemos usar um try bloco sem um catch quadra. No entanto, não podemos usar um catch bloco sem um try quadra.

Java try...finally block

Também podemos usar o try bloco junto com um bloco finalmente.

Nesse caso, o bloco finally é sempre executado, independentemente de haver ou não uma exceção dentro do bloco try.

Exemplo:Java try...finally block

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

    finally {
      System.out.println("Finally block is always executed");
    }
  }
}

Saída

Finally block is always executed
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at Main.main(Main.java:4)

No exemplo acima, usamos o try bloco junto com o finally quadra. Podemos ver que o código dentro do try bloco está causando uma exceção.

No entanto, o código dentro do finally bloco é executado independentemente da exceção.

Java try...catch...finally block

Em Java, também podemos usar o bloco finally após o try...catch quadra. Por exemplo,

import java.io.*;

class ListOfNumbers {

  // create an integer array
  private int[] list = {5, 6, 8, 9, 2};

  // method to write data from array to a fila
  public void writeList() {
    PrintWriter out = null;

    try {
      System.out.println("Entering try statement");

      // creating a new file OutputFile.txt
      out = new PrintWriter(new FileWriter("OutputFile.txt"));

      // writing values from list array to Output.txt
      for (int i = 0; i < 7; i++) {
        out.println("Value at: " + i + " = " + list[i]);
      }
    }
    
    catch (Exception e) {
      System.out.println("Exception => " + e.getMessage());
    }
    
    finally {
      // checking if PrintWriter has been opened
      if (out != null) {
        System.out.println("Closing PrintWriter");
        // close PrintWriter
        out.close();
      }
      
      else {
        System.out.println("PrintWriter not open");
      }
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}

Saída

Entering try statement
Exception => Index 5 out of bounds for length 5
Closing PrintWriter

No exemplo acima, criamos um array chamado list e um arquivo chamado output.txt . Aqui, estamos tentando ler os dados do array e armazenar no arquivo.

Observe o código,

for (int i = 0; i < 7; i++) {
  out.println("Value at: " + i + " = " + list[i]);
}

Aqui, o tamanho do array é 5 e o último elemento do array está em list[4] . No entanto, estamos tentando acessar elementos em a[5] e a[6] .

Portanto, o código gera uma exceção que é capturada pelo bloco catch.

Desde o finally bloco é sempre executado, incluímos código para fechar o PrintWriter dentro do bloco finalmente.

É uma boa prática usar o bloco finally para incluir código de limpeza importante, como fechar um arquivo ou conexão.

Observação :Existem alguns casos em que um finally bloco não executa:

Uso de System.exit() método
Ocorre uma exceção no finally bloquear
A morte de um tópico

Vários blocos de captura

Para cada try bloco, pode haver zero ou mais catch blocos. Vários catch blocos nos permitem tratar cada exceção de forma diferente.

O tipo de argumento de cada catch bloco indica o tipo de exceção que pode ser tratada por ele. Por exemplo,

class ListOfNumbers {
  public int[] arr = new int[10];

  public void writeList() {

    try {
      arr[10] = 11;
    }
    
    catch (NumberFormatException e1) {
      System.out.println("NumberFormatException => " + e1.getMessage());
    }
    
    catch (IndexOutOfBoundsException e2) {
      System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
    }

  }
}

class Main {
  public static void main(String[] args) {
    ListOfNumbers list = new ListOfNumbers();
    list.writeList();
  }
}

Saída

IndexOutOfBoundsException => Index 10 out of bounds for length 10

Neste exemplo, criamos um array inteiro chamado arr de tamanho 10 .

Como o índice da matriz começa em 0 , o último elemento da matriz está em arr[9] . Observe a afirmação,

arr[10] = 11;

Aqui, estamos tentando atribuir um valor ao índice 10 . Portanto, IndexOutOfBoundException ocorre.

Quando ocorre uma exceção no try quadra,

A exceção é lançada para o primeiro catch quadra. O primeiro catch bloco não lida com um IndexOutOfBoundsException , então é passado para o próximo catch bloquear.
O segundo catch bloco no exemplo acima é o manipulador de exceção apropriado porque manipula um IndexOutOfBoundsException . Portanto, ele é executado.

Capturando várias exceções

A partir do Java SE 7 e posterior, agora podemos capturar mais de um tipo de exceção com um catch quadra.

Isso reduz a duplicação de código e aumenta a simplicidade e a eficiência do código.

Cada tipo de exceção que pode ser tratado pelo catch bloco é separado usando uma barra vertical | .

Sua sintaxe é:

try {
  // code
} catch (ExceptionType1 | Exceptiontype2 ex) { 
  // catch block
}

Para saber mais, visite Java capturando várias exceções.

Instrução Java try-with-resources

O experimentar com recursos declaração é uma declaração try que tem uma ou mais declarações de recursos.

Sua sintaxe é:

try (resource declaration) {
  // use of the resource
} catch (ExceptionType e1) {
  // catch block
}

O recurso é um objeto a ser fechado no final do programa. Ele deve ser declarado e inicializado na instrução try.

Vamos dar um exemplo.

try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt")) {
  // use of the resource
}

O experimentar com recursos A instrução também é chamada de gerenciamento automático de recursos . Essa instrução fecha automaticamente todos os recursos no final da instrução.

Para saber mais, visite a instrução java try-with-resources.

Manipulação de Exceções Java Java joga e joga

Java