Entendendo o Bloco try-catch em Java

O bloco try-catch é uma funcionalidade que permite que o programador lide com exceções que ocorram, controlando o fluxo de execução do código em situações imprevistas.

Caso ocorra alguma exceção dentro do bloco try, a execução do código será desviada para dentro do bloco catch correspondente permitindo um maior controle do fluxo do código sendo executado.

Sintaxe básica

A sintaxe básica do bloco try-catch em java é a seguinte

 try{
   // Código que pode gerar uma exceção
  }

catch(TipoDeExcecao nomeDaExcecao){
    // Código para lidar com a exceção
    }   
    
finally{
      // Código a ser executado independentemente de ocorrer ou não uma exceção. O finally é opcional.
        } 

try: Esse é o local onde você deve inserir o código suscetível a erros.

catch: Este bloco é usado para capturar as exceções que ocorrerem dentro do bloco try. Você pode ter vários blocos catch para capturar diferentes exceções de um mesmo bloco try.

Finally (opcional): O bloco finally é opcional e é usado para especificar código que deve ser executado independentemente de ocorrer ou não uma exceção dentro do bloco try.

Tipos de Exceções

Existem dois tipos de exceções :

Exceções Verificadas: Estas são exceções que o compilador Java exige que você trate explicitamente usando um bloco try-catch ou declarando-as na assinatura do método. Exemplos incluem IOException, SQLException, entre outras.

Não verificadas: Estas são exceções que ocorrem durante a execução do programa e não são verificadas pelo compilador. Exemplos incluem NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException e etc.

Hierarquia das Exceções em Java

Fonte:( https://www.linkedin.com/pulse/mastering-error-exception-handling-deep-dive-reliable-singh-m7nef/ )

Exemplo Prático

Exemplo 1:

 // Inicia o bloco try, onde colocamos o código que pode gerar uma exceção
try {

   // Cria um objeto BufferedReader para ler o arquivo "arquivo.txt"
  BufferedReader br = new BufferedReader(new FileReader("arquivo.txt")); 

   // declaração de variável 
   String linha;

   // Loop que lê cada linha do arquivo até que não haja mais linhas (linha = null)
   while ((linha = br.readLine()) != null) { 
         System.out.println(linha); 
                                           }


          br.close(); // Fecha o BufferedReader para liberar os recursos

  // Captura uma exceção do tipo IOException, que pode ocorrer durante a leitura 
      } catch (IOException e) { 


          System.err.println("Erro ao ler o arquivo: " + e.getMessage()); // Imprime uma mensagem de erro específica para a exceção.
   
 } finally { // Bloco opcional que sempre é executado, independentemente de ocorrer uma exceção ou não


          System.out.println("Finalizando programa..."); 
      }

No exemplo acima, tentamos ler linhas de um arquivo. Se acontecer uma exceção durante a leitura do arquivo, ela é capturada pelo bloco catch, e uma mensagem de erro é exibida. O bloco finally garante que o BufferedReader seja fechado corretamente, independentemente de ocorrer uma exceção ou não.

Exemplo 2:

try {
    int resultado = dividir(50, 0); 
     System.out.println("Resultado da divisão: " + resultado); 
      } catch (ArithmeticException e) { 
          System.err.println("Erro: Divisão por zero."); 
      }
  }
  public static int dividir(int a, int b) { 
      return a / b;
  }

Neste exemplo, tentamos realizar uma operação de divisão de dois números inteiros dentro do método dividir(). Se o divisor for zero, uma exceção do tipo ArithmeticException será lançada. Esta exceção é capturada no bloco catch, onde uma mensagem de erro específica é impressa no console. Isso evita que o programa seja interrompido abruptamente devido à exceção não tratada. 

Boas Práticas 

Trate Exceções Específicas: Sempre que possível, capture exceções específicas em vez de usar um bloco catch genérico. Isso permite um tratamento mais adequado e específico para cada tipo de exceção.

Mantenha Blocos Catch Curtos: Evite colocar muito código dentro de um bloco catch. Mantenha-os concisos e focados apenas no tratamento da exceção.

Evite Capturar Exceções Demais: Evite capturar exceções demais em um único bloco try-catch. Isso pode obscurecer erros reais e dificultar a depuração.

Conclusão 

O uso de blocos try-catch deve ser implementado quando algum trecho de código pode gerar exceções e desejamos que essas exceções tenham um tratamento específico. Isso ajuda a manter a estabilidade e manutenção do seu código.