Sintaxe de try- catch

1. Para que serve try-catch?

Como você já sabe, em programação os erros acontecem o tempo todo: divisão por zero, entrada incorreta, ausência de arquivo etc. Se tais situações não forem tratadas, o programa terminará com erro (de forma abrupta).
A construção try-catch permite “capturar” a exceção e evitar a queda do programa, tratando o erro com cuidado.

Sintaxe da construção try-catch

try 
{
    // Código que pode lançar uma exceção
} 
catch (TipIsklyucheniya imyaPeremennoy) 
{
    // Código para tratar a exceção
}

Explicação:

• try — “tente executar este código”.
• catch — “se ocorrer uma exceção do tipo indicado, trate-a aqui”.

Como isso funciona?

Se uma exceção ocorrer dentro do bloco try, a execução desse bloco é interrompida imediatamente e o controle passa para o primeiro bloco catch compatível. Se nenhuma exceção ocorrer — o bloco catch é ignorado.

2. Exemplo: divisão por zero

Sem tratamento de exceção

int a = 10;
int b = 0;
int result = a / b; // Aqui o programa terminará com erro!
System.out.println("Resultado: " + result); // Não chegaremos até aqui

Resultado:

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Main.main(Main.java:3)

Com tratamento via try-catch

int a = 10;
int b = 0;

try 
{
    int result = a / b; // Aqui pode ocorrer uma exceção
    System.out.println("Resultado: " + result);
} 
catch (ArithmeticException e) 
{
    System.out.println("Erro: divisão por zero não é possível!");
}

System.out.println("O programa continuou a execução.");

Resultado:

Erro: divisão por zero não é possível!
O programa continuou a execução.

Explicação:

1. Assim que o Java encontra uma divisão por zero, ele lança uma exceção.
2. O try é interrompido e o controle passa para o catch.
3. Depois de tratar o erro, o programa continua a execução.

3. Como funciona o bloco catch

Entre parênteses após catch é indicado o tipo da exceção (por exemplo, ArithmeticException) e o nome da variável (geralmente e).

Dentro do bloco catch você pode obter detalhes sobre o erro:

• e.getMessage() — descrição curta do erro.
• e.printStackTrace() — informações detalhadas (para depuração).

Exemplo:

try 
{
    int[] arr = new int[2];
    int x = arr[10]; // Erro: índice inexistente
} 
catch (ArrayIndexOutOfBoundsException e) 
{
    System.out.println("Erro: " + e.getMessage()); // Exibimos a mensagem do erro
    e.printStackTrace();                             // Imprimimos no console todas as informações sobre o erro
}

4. Fluxo de execução em caso de exceção

Se no bloco try não houver erros — o bloco catch é ignorado.

Se no bloco try ocorrer um erro — a execução do bloco é interrompida no ponto da falha, e o controle passa imediatamente para o primeiro catch compatível. Tudo o que vier depois do erro no try não será executado!

Ilustração:

try 
{
    System.out.println("1. Início do try");
    int a = 10 / 0;                        // Erro!
    System.out.println("2. Após a divisão"); // Não será executado
} 
catch (ArithmeticException e) 
{
    System.out.println("3. No bloco catch");
}
System.out.println("4. Após o try-catch");

Resultado:

1. Início do try
3. No bloco catch
4. Após o try-catch

5. Erros comuns ao usar try-catch

Erro nº 1: catch amplo demais.
Se você usar catch (Exception e), pode acabar capturando um monte de erros inesperados que você não sabe tratar corretamente.
Solução: capture apenas as exceções que realmente são esperadas nesse ponto (por exemplo, IOException, SQLException).

Erro nº 2: catch vazio.
Escrever catch (Exception e) {} — significa esconder o problema. O programa pode falhar em outro lugar ou se comportar de forma estranha.
Solução: pelo menos registre o erro (e.printStackTrace() ou um logger).

Erro nº 3: acreditar que try-catch resolve qualquer problema.
Se o erro estiver na lógica do programa (por exemplo, divisão por zero, algoritmo incorreto) — nenhum try-catch vai ajudar.
Solução: use try-catch apenas para situações realmente esperadas, e não para mascarar bugs.