Dominando Tratamento de Exceções em Java: Try-Catch, Finally e Hierarquia de Classes

O que é Exceção em Java?

Exceção em Java é evento que interrompe execução de instruções do programa, perturbando fluxo normal de controle. É objeto que encapsula informação de erro surgida dentro de método e passada ao sistema de runtime. Em Java, exceções sinalizam principalmente condições de erro que não podem ser tratadas por fluxo de controle padrão.

Neste tutorial você aprenderá:

• O que é exceção
• Por que exceções importam
• Como tratá-las efetivamente
• Construto try-catch
• Hierarquia de classes de exceção do Java
• Papel do bloco finally

Erros em Java dividem-se em duas categorias amplas:

1. Erros de tempo de compilação
2. Erros de tempo de execução

Erros de compilação subdividem-se em:

• Erros de sintaxe
• Erros semânticos

Exemplo de erro de sintaxe:

Declarar int a; está correto, mas escrever in a; fará compilador reportar erro.

Por exemplo, declarar int a; uma vez e depois tentar redeclarar int a; depois no mesmo escopo disparará erro de compilador, destacado durante build.

Exemplo de erro de runtime

Erros de runtime manifestam-se como exceções, eventos que interrompem fluxo normal de execução. Exemplos típicos incluem ArithmeticException, NullPointerException e divisão por zero.

Essas exceções surgem de condições além do controle direto do desenvolvedor.

Por que Precisamos de Tratamento de Exceções?

Considere programa acessando servidor remoto. Durante desenvolvimento, servidor está acessível e código roda suavemente. Em produção, servidor pode estar down, causando exceção quando programa tenta conectar.

Confiar apenas no fluxo natural do código é insuficiente. Programas robustos antecipam condições excepcionais e recuperam graciosamente.

Como Tratar Exceções

Tratamento de exceções é prática de antecipar condições excepcionais e prover lógica de fallback. Estratégia comum é tentar operação primária e, em falha, redirecionar para backup.

Usar construtos if-else tradicionais para tratar múltiplos tipos de exceção torna-se rapidamente difícil:

class Conectar {
    if (servidorEstaUp()) {
        // conectar servidor primário
    } else {
        // conectar servidor backup
    }
}

Bloco Try-Catch

Java provê mecanismos built-in para tratamento de exceções. Código que pode lançar exceção fica dentro de bloco try, e código de recuperação correspondente em um ou mais blocos catch.

Por exemplo, bloco try pode tentar conectar servidor primário, enquanto bloco catch trata lógica de fallback.

Quando servidor está up, bloco catch é pulado; quando down, exceção é lançada e bloco catch executa.

Sintaxe para par try-catch:

try {
    // statements que podem lançar
} catch (TipoExcecao nome) {
    // statements de recuperação
}

Exemplo Prático

Passo 1: Copie código abaixo no seu IDE.

class ExcecaoJava {
    public static void main(String args[]) {
        int d = 0;
        int n = 20;
        int fracao = n / d; // lançará ArithmeticException
        System.out.println("Fim do Main");
    }
}

Passo 2: Compile e execute. Programa lança ArithmeticException e termina na linha 5.

Passo 3: Modifique código para usar try-catch:

class ExcecaoJava {
    public static void main(String args[]) {
        int d = 0;
        int n = 20;
        try {
            int fracao = n / d;
            System.out.println("Esta linha não será executada");
        } catch (ArithmeticException e) {
            System.out.println("Exceção capturada: " + e);
        }
        System.out.println("Fim do Main");
    }
}

Passo 4: Compile e execute novamente. Saída mostra exceção tratada graciosamente, e programa continua para print final.

Objeto ArithmeticException capturado e contém informação detalhada para logging ou recuperação.

Hierarquia de Classes de Exceção

Hierarquia de exceção do Java origina-se da classe Throwable, que tem duas subclasses diretas: Error e Exception. Error representa condições irrecuperáveis (ex.: OutOfMemoryError), enquanto Exception cobre condições tratáveis programaticamente.

• RuntimeException (ex.: NullPointerException, ArithmeticException) – exceções não verificadas não detectadas em tempo de compilação.
• IOException – problemas durante operações de entrada/saída.
• InterruptedException – lançada quando thread é interrompida.

Exemplo Try-Catch Aninhado

Copie código seguinte:

class ExcecaoJava {
    public static void main(String args[]) {
        try {
            int d = 1;
            int n = 20;
            int fracao = n / d;
            int g[] = {1};
            g[20] = 100; // ArrayIndexOutOfBoundsException
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException capturada: " + e);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBoundsException capturada: " + e);
        }
        System.out.println("Fim do Main");
    }
}

Quando d é 1, código lança ArrayIndexOutOfBoundsException. Mudando d para 0 dispara ArithmeticException. Descomentando catch (Exception e) amplo causaria erro de compilação pois sombrearia handlers mais específicos.

Bloco Finally

Bloco finally executa independentemente de exceção ocorrer, ideal para tarefas de limpeza.

try {
    // operações arriscadas
} catch (TipoExcecao e) {
    // tratamento de erro
} finally {
    // ações de limpeza
}

Exemplo:

class ExcecaoJava {
    public static void main(String args[]) {
        try {
            int d = 0;
            int n = 20;
            int fracao = n / d;
        } catch (ArithmeticException e) {
            System.out.println("Exceção capturada: " + e);
        } finally {
            System.out.println("Dentro do bloco finally");
        }
    }
}

Executando este programa imprime mensagem do bloco finally mesmo com exceção lançada. Mudando d para 1 elimina exceção; bloco finally ainda roda.

Resumo:

• Uma exceção é erro de runtime que interrompe fluxo normal do programa.
• Erros dividem-se em compile-time (sintaxe, semântica) e runtime (exceções).
• Aplicações robustas devem tratar todas exceções antecipadas para manter estabilidade.
• Mecanismo try-catch do Java é forma padrão de interceptar e recuperar de erros.
• Bloco try contém código que pode lançar; catch trata erro; finally garante limpeza.