Java try-catch: Trate exceções sem travar o programa

Capturar uma exceção em vez de travar

Você já sabe que, quando algo dá errado, o Java lança uma exceção, e uma exceção não tratada interrompe o programa com um stack trace. Um bloco try-catch é como você assume o controle: você envolve o código arriscado em try e, se ele lançar uma exceção, o Java pula para o bloco catch correspondente em vez de travar.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;          // lança ArithmeticException
            System.out.println(result);   // nunca é alcançado
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program keeps running");
    }
}

No instante em que 10 / 0 lança a exceção, o resto do bloco try é ignorado e o controle passa para o catch. Depois que o catch termina, a execução continua normalmente: o programa não morre.

A variável do catch guarda a exceção

O e em catch (ArithmeticException e) é um objeto de verdade. Ele carrega informações sobre o que deu errado, sendo a mais útil uma mensagem:

public class Main {
    public static void main(String[] args) {
        try {
            int n = Integer.parseInt("not a number");
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Bad input: " + e.getMessage());
        }
    }
}

e.getMessage() retorna uma descrição curta. Durante a depuração, e.printStackTrace() despeja o rastreamento completo mostrando exatamente de onde veio a exceção; recorra a ele quando só uma mensagem não for suficiente para encontrar a causa.

Capture o tipo específico, não tudo

Um bloco catch só captura exceções que correspondem ao seu tipo declarado (ou a uma subclasse). O maior erro de iniciante é capturar Exception para fazer um problema "sumir":

// Não faça isso: esconde bugs reais
try {
    doWork();
} catch (Exception e) {
    // engole NullPointerException, erros de digitação, erros de lógica... tudo
}

Capture o tipo mais restrito que você realmente consegue tratar. Se você espera uma entrada numérica inválida, capture NumberFormatException. Qualquer coisa que você não previu deve poder se propagar, para que você de fato fique sabendo dela em vez de continuar silenciosamente em um estado quebrado.

Tratar vários tipos de exceção

Você pode empilhar vários blocos catch. O Java os verifica de cima para baixo e executa o primeiro que corresponde, então ordene-os do mais específico para o mais geral:

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "oops", null};

        for (String s : inputs) {
            try {
                int n = Integer.parseInt(s);
                System.out.println("Parsed: " + n);
            } catch (NumberFormatException e) {
                System.out.println("Not a number: " + s);
            } catch (NullPointerException e) {
                System.out.println("Got a null value");
            }
        }
    }
}

Quando dois tipos compartilham o mesmo tratamento, use um único multi-catch com | em vez de duplicar o bloco:

public class Main {
    public static void main(String[] args) {
        try {
            Object[] words = {"a", "b"};
            System.out.println(words[5]);   // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Bad access: " + e.getClass().getSimpleName());
        }
    }
}

Uma armadilha: um tipo mais geral precisa vir depois dos específicos. Colocar catch (Exception e) primeiro torna os blocos seguintes, mais específicos, inalcançáveis, e o compilador rejeita isso.

finally sempre é executado

Um bloco finally é executado depois do try e de qualquer catch, independentemente do que aconteceu: sucesso, uma exceção capturada ou até um return antecipado. É onde fica a limpeza que sempre precisa acontecer.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // lança uma exceção
            System.out.println("Working");  // ignorado
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // executa aconteça o que acontecer
        }
    }
}

"Closing resource" é impresso quer a exceção seja lançada ou não. Evite, porém, fazer return de dentro do finally: isso pode descartar silenciosamente uma exceção ou sobrescrever um valor retornado pelo bloco try.

try-with-resources fecha as coisas por você

Quando você trabalha com algo que precisa ser fechado (um arquivo, uma conexão de rede, um statement de banco de dados), declará-lo dentro de try (...) o fecha automaticamente quando o bloco termina, mesmo que uma exceção seja lançada. Funciona com qualquer tipo que implemente AutoCloseable.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner implementa AutoCloseable, então fecha automaticamente
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

Isso substitui o antigo padrão de abrir no try e fechar no finally, e é menos sujeito a erros porque você não pode esquecer de fechar. Prefira-o sempre que estiver lidando com um recurso que pode ser fechado.

Não use exceções para o fluxo de controle normal

try-catch é para situações excepcionais, não para condições comuns. Capturar uma exceção é mais caro do que uma verificação simples, e deixa o código mais difícil de ler. Se você consegue testar a condição antes, faça isso:

// Evite: usar um catch para testar uma chave ausente
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // tratar a chave ausente
}

// Prefira: verificar explicitamente
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

Reserve o catch para coisas genuinamente fora do seu controle: entrada de usuário inválida, arquivos ausentes, falhas de rede.

A seguir: NullPointerException

A exceção mais comum que você vai capturar (e causar) em Java é a NullPointerException: ela aparece no instante em que você chama um método em algo que acabou sendo null. A seguir, vamos investigar exatamente o que a dispara, como ler o stack trace dela e os hábitos que evitam que ela aconteça desde o começo.