Dominando Exceções em Java: Tratando Erros Inesperados com Elegância
Uma exceção (ou evento excepcional) é um problema que surge durante a execução de um programa. Quando uma Exception ocorre, o fluxo normal é interrompido e o programa termina anormalmente, o que não é recomendado; portanto, essas exceções devem ser tratadas.
Uma exceção pode ocorrer por diversos motivos:
- Usuário inseriu dados inválidos.
- Arquivo necessário não foi encontrado.
- Conexão de rede perdida ou JVM sem memória.
Algumas são causadas por erro do usuário, outras por erro do programador, outras por falha de recursos físicos. Baseando-se nisso, existem três categorias de exceções:
Categorias de Exceções
1. Exceções Verificadas (Checked Exceptions)
São verificadas pelo compilador em tempo de compilação (também chamadas de exceções de tempo de compilação). Não podem ser ignoradas; o programador deve tratá-las.
Exemplo: Usar FileReader para ler arquivo inexistente lança FileNotFoundException.
import java.io.File;
import java.io.FileReader;
public class FilenotFound_Demo {
public static void main(String args[]) {
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
}
}
Compilação falha:
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
Nota: Métodos read() e close() de FileReader lançam IOException, então o compilador também exige tratamento de IOException.
2. Exceções Não Verificadas (Unchecked Exceptions)
Ocorrem em tempo de execução (Runtime Exceptions). Incluem bugs de programação: erros lógicos ou uso impróprio de API. São ignoradas em tempo de compilação.
Exemplo: Acessar índice 5 em array de tamanho 5 lança ArrayIndexOutOfBoundsException.
public class Unchecked_Demo {
public static void main(String args[]) {
int num[] = {1, 2, 3, 4};
System.out.println(num[5]);
}
}
Saída:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
3. Erros (Errors)
Não são exceções, mas problemas fora do controle do usuário/programador. Geralmente ignorados no código pois raramente se pode fazer algo. Ex.: StackOverflowError, OutOfMemoryError. Também ignorados em compilação.
Hierarquia de Exceções
Todas as classes de exceção são subtipos de java.lang.Exception. A classe Exception é subclasse de Throwable. Outra subclasse de Throwable é Error.
A classe Exception tem duas subclasses principais: IOException e RuntimeException.
Métodos Importantes da Classe Throwable
| Nº | Método e Descrição |
|---|---|
| 1 | public String getMessage() — Retorna mensagem detalhada sobre a exceção. |
| 2 | public Throwable getCause() — Retorna a causa da exceção. |
| 3 | public String toString() — Retorna nome da classe concatenado com getMessage(). |
| 4 | public void printStackTrace() — Imprime stack trace em System.err. |
| 5 | public StackTraceElement[] getStackTrace() — Retorna array com elementos do stack trace. |
| 6 | public Throwable fillInStackTrace() — Preenche stack trace com trace atual. |
Capturando Exceções (try-catch)
Um método captura exceção usando try e catch. Bloco try/catch envolve código que pode gerar exceção.
Sintaxe
try {
// Código protegido
} catch (ExceptionName e1) {
// Bloco catch
}
Exemplo
// File Name: ExcepTest.java
import java.io.*;
public class ExcepTest {
public static void main(String args[]) {
try {
int a[] = new int[2];
System.out.println("Acessar elemento três: " + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exceção lançada: " + e);
}
System.out.println("Fora do bloco");
}
}
Saída:
Exceção lançada: java.lang.ArrayIndexOutOfBoundsException: 3
Fora do bloco
Múltiplos Blocos Catch
Um bloco try pode ser seguido por vários catch:
try {
// Código protegido
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}
Se exceção ocorre, é lançada para o primeiro catch. Se o tipo corresponde, é capturado lá; senão, passa para o próximo, e assim por diante.
Capturando Múltiplos Tipos (Java 7+)
Desde Java 7, pode-se tratar mais de uma exceção em um único catch:
catch (IOException | FileNotFoundException ex) {
logger.log(ex);
throw ex;
}
Palavras-chave throws / throw
Se um método não trata uma exceção verificada, deve declará-la com throws na assinatura.
Use throw para lançar explicitamente uma exceção (nova ou recém-capturada).
Diferença: throws adia o tratamento; throw invoca explicitamente.
Exemplo: throws
import java.io.*;
public class ClassName {
public void deposit(double amount) throws RemoteException {
throw new RemoteException();
}
}
Múltiplas exceções:
public void withdraw(double amount) throws RemoteException, InsufficientFundsException {
// implementação
}
Bloco finally
O bloco finally segue try ou catch e sempre executa, independentemente de exceção. Útil para limpeza (fechar arquivos, conexões).
Sintaxe
try {
// Código protegido
} catch (ExceptionType1 e1) {
// Catch
} finally {
// Sempre executa
}
Exemplo
public class ExcepTest {
public static void main(String args[]) {
int a[] = new int[2];
try {
System.out.println("Acessar elemento três: " + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exceção lançada: " + e);
} finally {
a[0] = 6;
System.out.println("Primeiro elemento: " + a[0]);
System.out.println("Bloco finally executado");
}
}
}
Saída:
Exceção lançada: java.lang.ArrayIndexOutOfBoundsException: 3
Primeiro elemento: 6
Bloco finally executado
Regras:
- Catch não pode existir sem try.
- Finally não é obrigatório.
- Try não pode existir sem catch ou finally.
- Nenhum código entre try, catch, finally.
try-with-resources (Java 7+)
Mecanismo de gerenciamento automático de recursos que fecha automaticamente recursos declarados nos parênteses do try.
Sintaxe
try (FileReader fr = new FileReader("file path")) {
// use o recurso
} catch (IOException e) {
// tratamento
}
Exemplo
import java.io.FileReader;
import java.io.IOException;
public class Try_withDemo {
public static void main(String args[]) {
try (FileReader fr = new FileReader("E://file.txt")) {
char[] a = new char[50];
fr.read(a);
for (char c : a) System.out.print(c);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Pontos importantes:
- A classe deve implementar
AutoCloseable. - Pode declarar múltiplas classes; fecham em ordem reversa.
- Recurso é instanciado antes do bloco try.
- Recurso é implicitamente
final.
Exceções Definidas pelo Usuário
Você pode criar suas próprias exceções:
- Todas devem ser filhas de
Throwable. - Para checked exception: estenda
Exception. - Para runtime exception: estenda
RuntimeException.
Exemplo: InsufficientFundsException
// File Name: InsufficientFundsException.java
import java.io.*;
public class InsufficientFundsException extends Exception {
private double amount;
public InsufficientFundsException(double amount) {
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
Exemplo: CheckingAccount
// File Name: CheckingAccount.java
import java.io.*;
public class CheckingAccount {
private double balance;
private int number;
public CheckingAccount(int number) {
this.number = number;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException {
if (amount <= balance) {
balance -= amount;
} else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance() { return balance; }
public int getNumber() { return number; }
}
Exemplo: BankDemo
// File Name: BankDemo.java
public class BankDemo {
public static void main(String[] args) {
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositando $500...");
c.deposit(500.00);
try {
System.out.println("\nSacando $100...");
c.withdraw(100.00);
System.out.println("\nSacando $600...");
c.withdraw(600.00);
} catch (InsufficientFundsException e) {
System.out.println("Desculpe, mas você está sem $" + e.getAmount());
e.printStackTrace();
}
}
}
Saída:
Depositando $500...
Sacando $100...
Sacando $600...
Desculpe, mas você está sem $200.0
InsufficientFundsException at CheckingAccount.withdraw(CheckingAccount.java:25)
at BankDemo.main(BankDemo.java:13)
Exceções Comuns
- JVM Exceptions — Lançadas pela JVM:
NullPointerException,ArrayIndexOutOfBoundsException,ClassCastException. - Programmatic Exceptions — Lançadas explicitamente pela aplicação/API:
IllegalArgumentException,IllegalStateException.
Java
- Dominando Operadores Java: Tipos, Sintaxe e Exemplos Práticos
- Comentários em Java: Tipos, Uso e Boas Práticas
- Dominando o Loop for Aprimorado em Java: Sintaxe, Exemplos e Boas Práticas
- Dominando Strings em Java: Criação, Métodos e Boas Práticas
- Dominando Tratamento de Exceções em Java: Try, Catch, Finally, Throw e Throws Explicados
- Java throw vs throws: Dominando Tratamento de Exceções com Exemplos Práticos
- Dominando Tratamento Multi-Exceção em Java
- Dominando Try-With-Resources em Java: Gerenciamento Automático de Recursos Explicado
- Anotações em Java Explicadas: Tipos, Posicionamento e Exemplos Práticos
- Asserções em Java: Guia Prático para Detectar Bugs e Garantir Confiabilidade do Código