index

Disclaimer

O conteúdo desse estudo foi feito durante o Curso de Desenvolvimento Java, lecionado pela Giuliana Silva Bezerra.

Aconselho veemente que você utilize este material como um complemento ao curso, e não como substituto do mesmo. A didática dela é incrível e você aprenderá muito mais seguindo o curso oficial.

Curso Oficial (Udemy) Canal Giu Bezerra

Trabalhando com Exceptions

Referência: Curso de Desenvolvimento Java, Giuliana Silva Bezerra (Udemy)

Este estudo aborda os conceitos fundamentais de exceções em Java, incluindo:

o que são exceções
como tratá-las
como lançá-las
diferenças entre checked e unchecked exceptions
criação de exceções personalizadas
boas práticas

O que são exceções?

Quando escrevemos um programa, precisamos nos preparar para algo dar errado: erro de programação, entrada inválida do usuário, falhas externas (rede/IO), etc. Em Java, essas falhas são representadas por exceções.

Exemplo simples (usando List, não “array”):

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class App {
5
  public static void main(String[] args) {
6
    List<String> nomes = new ArrayList<>();
7
    nomes.add("Pedro");
8

9
    System.out.println(nomes.get(1)); // índice inválido -> IndexOutOfBoundsException
10
  }
11
}

Nesse caso, o programa tenta acessar uma posição inexistente da lista, resultando em uma exceção em tempo de execução.

Tratando com try/catch (exemplo correto e compilável)

Para evitar que o programa seja interrompido, podemos tratar a exceção usando try/catch.

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class App {
5

6
  public static void main(String[] args) {
7
    List<String> nomes = getNomes();
8

9
    try {
10
      System.out.println(nomes.get(1));
11
    } catch (IndexOutOfBoundsException e) {
12
      System.out.println("O índice informado não é válido.");
13
    }
14
  }
15

16
  private static List<String> getNomes() {
17
    List<String> nomes = new ArrayList<>();
18
    nomes.add("Pedro");
19
    return nomes;
20
  }
21
}

O bloco try contém o código que pode gerar erro, enquanto o catch captura e trata a exceção.

Stack Trace

Quando uma exceção não é tratada, o Java imprime no console o stack trace, que mostra:

qual exceção ocorreu
onde ocorreu
a sequência de chamadas até o erro

Em aplicações reais, o stack trace deve ser registrado em logs, e não apenas exibido no console.

Capturando exceções específicas

Sempre que possível, capture exceções específicas em vez de usar Exception genérico.

1
try {
2
  System.out.println(nomes.get(1));
3
} catch (IndexOutOfBoundsException e) {
4
  System.out.println("O índice informado não é válido.");
5
}

Isso torna o código mais legível e previsível.

Múltiplos blocos catch

É possível tratar diferentes exceções de forma independente.

1
try {
2
  System.out.println(nomes.get(1)); // IndexOutOfBoundsException
3

4
  int resultado = 10 / 0;           // ArithmeticException
5
  System.out.println(resultado);
6
} catch (IndexOutOfBoundsException e) {
7
  System.out.println("O índice informado não é válido.");
8
} catch (ArithmeticException e) {
9
  System.out.println("Erro em operação aritmética.");
10
}

Multi-catch

Quando o tratamento é o mesmo, é possível usar multi-catch:

1
try {
2
  // código
3
} catch (IndexOutOfBoundsException | ArithmeticException e) {
4
  System.out.println("Erro ao executar operação.");
5
}

throw vs throws

throw é usado para lançar explicitamente uma exceção.
throws é usado na assinatura do método para declarar que ele pode lançar uma exceção.

Exceções checked

Subclasses de Exception (exceto RuntimeException)
Devem ser tratadas ou declaradas
Normalmente usadas para falhas recuperáveis

Exemplo:

1
public class App {
2

3
  public static void main(String[] args) {
4
    try {
5
      System.out.println(dividir(10, 0));
6
    } catch (Exception e) {
7
      System.out.println(e.getMessage());
8
    }
9
  }
10

11
  private static int dividir(int i, int j) throws Exception {
12
    if (j == 0) {
13
      throw new Exception("Não é possível realizar divisão por zero.");
14
    }
15
    return i / j;
16
  }
17
}

Exceções unchecked

Subclasses de RuntimeException
Não exigem declaração em throws
Normalmente indicam erro de programação

Exemplo:

1
private static int dividir(int i, int j) {
2
  if (j == 0) {
3
    throw new IllegalArgumentException("Não é possível realizar divisão por zero.");
4
  }
5
  return i / j;
6
}

Exceções personalizadas

Criar exceções personalizadas melhora a semântica do código e a clareza do domínio.

Exemplo de exceção customizada (unchecked):

1
public class DivisaoPorZeroException extends RuntimeException {
2

3
  public DivisaoPorZeroException(String message) {
4
    super(message);
5
  }
6

7
  public DivisaoPorZeroException(String message, Throwable cause) {
8
    super(message, cause);
9
  }
10
}

Uso:

1
private static int dividir(int i, int j) {
2
  if (j == 0) {
3
    throw new DivisaoPorZeroException("Não é possível realizar divisão por zero.");
4
  }
5
  return i / j;
6
}

Boas práticas

Evite catch (Exception e) genérico sem necessidade
Nunca deixe um catch vazio
Preserve a causa original da exceção:

1
catch (IOException e) {
2
  throw new MinhaException("Erro ao processar arquivo", e);
3
}

Não use exceções como controle de fluxo
Prefira exceções específicas e bem nomeadas
Em APIs, trate exceções em um ponto central (ex.: camada de controller)

Conclusão

Exceções são um mecanismo essencial para tornar aplicações Java mais seguras, previsíveis e fáceis de manter. Saber quando tratar, lançar ou propagar uma exceção é parte fundamental do desenvolvimento profissional em Java.

Trabalhando com Exceptions - Java