Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Java

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:

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
1public String getMessage() — Retorna mensagem detalhada sobre a exceção.
2public Throwable getCause() — Retorna a causa da exceção.
3public String toString() — Retorna nome da classe concatenado com getMessage().
4public void printStackTrace() — Imprime stack trace em System.err.
5public StackTraceElement[] getStackTrace() — Retorna array com elementos do stack trace.
6public 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:

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:

Exceções Definidas pelo Usuário

Você pode criar suas próprias exceções:

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

Java

  1. Dominando Operadores Java: Tipos, Sintaxe e Exemplos Práticos
  2. Comentários em Java: Tipos, Uso e Boas Práticas
  3. Dominando o Loop for Aprimorado em Java: Sintaxe, Exemplos e Boas Práticas
  4. Dominando Strings em Java: Criação, Métodos e Boas Práticas
  5. Dominando Tratamento de Exceções em Java: Try, Catch, Finally, Throw e Throws Explicados
  6. Java throw vs throws: Dominando Tratamento de Exceções com Exemplos Práticos
  7. Dominando Tratamento Multi-Exceção em Java
  8. Dominando Try-With-Resources em Java: Gerenciamento Automático de Recursos Explicado
  9. Anotações em Java Explicadas: Tipos, Posicionamento e Exemplos Práticos
  10. Asserções em Java: Guia Prático para Detectar Bugs e Garantir Confiabilidade do Código