Tentativa de Java - Captura

Podem ocorrer erros durante a execução do programa. É um problema comum para todo programador, desde um iniciante até um verdadeiro profissional. Nem todos os erros surgem por culpa do desenvolvedor. Alguns deles são difíceis de prever e às vezes não são possíveis. Por exemplo, durante o download de um programa, a conexão de rede pode cair repentinamente ou a energia pode acabar. Tais situações são chamadas de exceções. Try and catch são as partes da construção usadas para lidar com exceções.

Java tente e pegue o bloco

Quando ocorre um erro, o Java geralmente para e gera uma mensagem de erro. Este processo é chamado de "Java lança uma exceção". Java fornece recursos especiais para lidar com exceções. Uma delas é tentar... pegar... finalmente construção. Aqui está a sintaxe do bloco try, bloco catch e finalmente bloco.

//try block
try {
  // Block of code to try
}
//try catch
catch(Exception e) {
  // Block of code to handle errors
}
finally {
 // Optional block of code
          }

Quando ocorre uma exceção no bloco try, o controle passa para o bloco catch, que pode tratar a exceção. Se tal bloco não for encontrado, uma mensagem de exceção não tratada será exibida ao usuário e a execução adicional do programa será interrompida. É para evitar essa parada de emergência que você precisa usar o bloco try..catch.

Resumidamente sobre try, catch, finalmente, lança palavras-chave

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

• try — define um bloco de código no qual uma exceção pode ocorrer;
• 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 e try catch finalmente}.

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

Exemplo fácil de construção try-catch

Digamos que temos um programa com algum array.

public class TryTest {
   public static void main(String[] args) {
       int[] myArray = new int[5];
       myArray[7] = 8;
       System.out.println(myArray[7]);
   }
}

Como estamos tentando acessar um elemento do array com um índice inexistente, o programa sairá com um erro: Vamos modificar este programa e tratar esta exceção com um try-catch. Primeiro vem o bloco try, depois o bloco catch.

//try catch example
public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
           System.out.println("The exception was handled...");
       }

       System.out.println("This is the end of the program...");
   }
}

Agora a saída mudou: Neste caso, o programa foi concluído corretamente, nossa mensagem será exibida na tela. O encerramento correto do programa é sinalizado pelo código 0 no final do processo, enquanto incorreto — 1. Ao usar um bloco try...catch, todas as instruções entre as instruções try e catch são executadas primeiro. Se ocorrer uma exceção no bloco try, a ordem de execução normal para e prossegue para a instrução catch. Portanto, quando a execução do programa atinge os números[7]=8; linha, o programa irá parar e irá para o bloco catch. No nosso caso, declaramos a variável myEx com o tipo Exception. Esta é a classe base para todas as exceções e, portanto, elas podem ser diferentes. Por exemplo, existem exceções que são responsáveis ​​por stack overflows, indo além da indexação do array, como no nosso caso, apontando para Null, e assim por diante. Se não tivéssemos adivinhado o tipo de exceção, o programa também teria terminado incorretamente. Porém, escolhemos o tipo Exception pela simplicidade do exemplo, e é a classe base para todas as exceções. Portanto, a instrução catch (Exception myEx) tratará quase todas as exceções. Lidando com a exceção neste caso Após a conclusão do bloco catch, o programa continua seu trabalho, executando todas as outras instruções após o bloco catch. Se quiser ver as exceções ocorridas, você pode fazer com que o programa imprima um rastreamento de pilha de chamadas de método. Isto é o que a JVM faz quando ocorre uma exceção não detectada: ela interrompe a execução do programa e imprime um rastreamento de pilha após a execução do código do bloco final, se presente.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {

         myEx.printStackTrace();
       }

       System.out.println("This is the end of the program...");
   }
}

O tratamento da exceção, neste caso, resume-se à impressão da pilha de rastreamento de erros no console usando o método printStackTrace() definido na classe Exception . No entanto, o programa foi encerrado corretamente.

Finalmente! Depois de pegar

No exemplo e nas definições das palavras-chave para tratamento de exceções, mencionamos o bloco final. É opcional, mas se presente, será executado independentemente dos resultados do bloco try. Vamos alterar o tipo de exceção para NullPointerException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (NullPointerException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Aqui está a saída: A propósito, podemos especificar o tipo de exceção como correto. Aqui está IndexOutOfBoundsException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (IndexOutOfBoundsException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Neste caso, a saída será a seguinte:

Como funcionam as exceções?

A questão é que todas essas palavras —catch, throw, throws só podem ser usadas com java.lang.Throwable ou seus descendentes. Por exemplo, você pode fazer isso:

public class MyClass {
    public static void main(String[] args) {
        try {
        } catch (Throwable thr) {
}
    }
}

No entanto, você não pode fazer assim:

public class MyClass {
public static void main(String[] args) {
        try {
        } catch (String thr) {
}
    }
}