☕

Exceptions
Disciplina: Programação Orientada a Objeto
Professor: Dr. Camilo Barreto
Curso: Grande Área de Computação
UNIUBE

1. Introdução
Em Java, uma exceção, ou exception, representa uma situação anormal que ocorre durante a execução
de um programa. Essa situação interrompe o fluxo normal das instruções e precisa ser tratada de alguma
forma para que o sistema não seja encerrado de maneira inesperada ou produza comportamentos
incorretos.
Em um programa simples, é comum imaginar que todas as entradas do usuário serão válidas, que todos
os arquivos existirão, que todos os cálculos serão possíveis e que todos os objetos estarão corretamente
inicializados. Porém, na prática, os sistemas estão sujeitos a falhas, dados inválidos e situações
inesperadas. Um usuário pode digitar texto no lugar de um número, um arquivo pode não existir, uma
conexão com banco de dados pode falhar, um objeto pode estar nulo ou uma regra de negócio pode
impedir uma operação.
As exceções existem para permitir que o programador lide com esses problemas de forma organizada.
Em vez de deixar o programa simplesmente parar, Java permite detectar a situação de erro, capturar a
exceção, executar uma ação alternativa e, quando possível, continuar a execução do sistema.
De forma resumida, uma exceção responde à seguinte pergunta:
O que o programa deve fazer quando algo inesperado acontece durante a execução?
Por exemplo:
se o usuário digitar uma idade inválida, o sistema pode solicitar a digitação novamente;
se uma divisão por zero for tentada, o sistema pode exibir uma mensagem de erro;

Exceptions 1
 se um arquivo não for encontrado, o sistema pode informar o usuário e cancelar apenas aquela
operação;
se uma conta bancária não tiver saldo suficiente, o sistema pode impedir o saque e explicar o motivo;
se uma conexão com banco de dados falhar, o sistema pode registrar o problema e tentar novamente
depois.

2. O que são exceções em Java

Em Java, uma exceção é representada por um objeto. Esse objeto contém informações sobre o problema
ocorrido, como o tipo da exceção, a mensagem descritiva e o ponto do código em que o problema
aconteceu.
Como Java é uma linguagem orientada a objetos, as exceções também fazem parte de uma hierarquia de
classes. A classe base para problemas lançados durante a execução é Throwable . A partir dela, existem
duas grandes categorias: Error e Exception .
A classe Error representa problemas graves, normalmente relacionados à máquina virtual Java ou ao
ambiente de execução. Em geral, o programador não deve tentar tratar esse tipo de problema no código
comum da aplicação. Exemplos incluem falta de memória ou erro interno da JVM.
A classe Exception , por outro lado, representa situações que podem ser previstas e tratadas pelo
programador. É nessa categoria que estão as exceções utilizadas no desenvolvimento cotidiano de
sistemas Java.
Exemplo de algumas exceções comuns:
ArithmeticException : ocorre em erros aritméticos, como divisão inteira por zero;
NullPointerException : ocorre ao tentar acessar um objeto que está com valor null ;
ArrayIndexOutOfBoundsException : ocorre ao acessar uma posição inexistente de um vetor;
NumberFormatException : ocorre ao tentar converter um texto inválido para número;
IOException : ocorre em problemas de entrada e saída, como leitura de arquivos;
FileNotFoundException : ocorre quando um arquivo esperado não é encontrado.

3. Exemplo inicial sem tratamento de exceção

Observe o exemplo abaixo. O programa solicita dois números inteiros ao usuário e realiza uma divisão.

import [Link];

public class ExemploDivisao {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Digite o primeiro número: ");

int numero1 = [Link]();

[Link]("Digite o segundo número: ");

int numero2 = [Link]();

int resultado = numero1 / numero2;

Exceptions 2
 [Link]("Resultado: " + resultado);

[Link]();
}
}

Esse código funciona corretamente se o usuário informar, por exemplo, os valores 10 e 2 . Nesse caso, o
resultado será 5 .
No entanto, se o usuário informar 10 e 0 , ocorrerá uma exceção, pois não é possível realizar divisão
inteira por zero em Java. O programa será interrompido e exibirá uma mensagem parecida com esta:

Exception in thread "main" [Link]: / by zero

Essa mensagem indica que ocorreu uma exceção do tipo ArithmeticException . O problema não está na
sintaxe do código, mas em uma situação inválida durante a execução.

4. Tratando exceções com try e catch

Para tratar exceções em Java, utiliza-se a estrutura try e catch . O bloco try contém o código que pode
gerar uma exceção. O bloco catch contém o código que será executado caso uma exceção específica
aconteça.
A estrutura básica é:

try {
// Código que pode gerar uma exceção.
} catch (TipoDaExcecao nomeDaExcecao) {
// Código executado quando a exceção acontece.
}

Aplicando ao exemplo da divisão, o código pode ser reescrito da seguinte forma:

import [Link];

public class ExemploDivisaoTratada {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Digite o primeiro número: ");

int numero1 = [Link]();

[Link]("Digite o segundo número: ");

int numero2 = [Link]();

try {
int resultado = numero1 / numero2;
[Link]("Resultado: " + resultado);
} catch (ArithmeticException exception) {
[Link]("Erro: não é possível dividir por zero.");
}

Exceptions 3
 [Link]();
}
}

Nesse exemplo, a divisão é colocada dentro do bloco try , pois é a operação que pode gerar uma
exceção. Caso numero2 seja igual a zero, Java lança uma ArithmeticException , e o bloco catch
correspondente é executado.
Com isso, o programa não termina de forma abrupta. Ele exibe uma mensagem mais compreensível para
o usuário.

5. Fluxo de execução do try/catch

Quando uma exceção ocorre dentro do bloco try , Java interrompe imediatamente a execução daquele
bloco e procura um bloco catch compatível com o tipo da exceção lançada.
Observe o exemplo:

public class ExemploFluxoTryCatch {

public static void main(String[] args) {
try {
[Link]("Início do bloco try.");

int resultado = 10 / 0;

[Link]("Esta linha não será executada.");

} catch (ArithmeticException exception) {
[Link]("Ocorreu uma divisão por zero.");
}

[Link]("O programa continua após o tratamento.");

}
}

A linha que contém 10 / 0 gera uma exceção. A partir desse ponto, o restante do bloco try não é
executado. O controle do programa passa para o bloco catch . Depois que o catch termina, o programa
continua normalmente após a estrutura de tratamento.
Esse comportamento é importante porque mostra que o try/catch não corrige automaticamente o erro. Ele
apenas permite que o programador defina uma resposta adequada para aquela situação.

6. Capturando informações da exceção

O objeto da exceção pode guardar informações importantes sobre o erro ocorrido. Uma das informações
mais utilizadas é a mensagem da exceção, obtida pelo método getMessage() .
Exemplo:

public class ExemploMensagemExcecao {

public static void main(String[] args) {
try {
int resultado = 10 / 0;
[Link](resultado);

Exceptions 4
 } catch (ArithmeticException exception) {
[Link]("Tipo de erro: " + [Link]().getSimple
Name());
[Link]("Mensagem original: " + [Link]());
}
}
}

A chamada retorna o nome da classe da exceção. A chamada

[Link]().getSimpleName()

[Link]() retorna a mensagem associada ao erro.

Em programas didáticos, é comum exibir essas informações no console. Em sistemas reais, normalmente
essas informações são registradas em logs para que os desenvolvedores possam diagnosticar o
problema sem expor detalhes técnicos ao usuário final.

7. Múltiplos blocos catch

Um mesmo bloco try pode gerar diferentes tipos de exceções. Por isso, Java permite utilizar múltiplos
blocos catch , cada um responsável por tratar um tipo específico de problema.
Exemplo:

import [Link];

public class ExemploMultiplosCatch {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

try {
[Link]("Digite um número inteiro: ");
int numero = [Link]([Link]());

int resultado = 100 / numero;

[Link]("Resultado: " + resultado);

} catch (NumberFormatException exception) {
[Link]("Erro: o valor digitado não é um número inteiro v
álido.");
} catch (ArithmeticException exception) {
[Link]("Erro: não é possível dividir por zero.");
}

[Link]();
}
}

Nesse exemplo, podem acontecer pelo menos duas exceções diferentes. Se o usuário digitar um texto
como abc , a conversão para inteiro falhará e será lançada uma NumberFormatException . Se o usuário digitar
0 , a conversão funcionará, mas a divisão por zero lançará uma ArithmeticException .

A ordem dos blocos catch deve ir do tipo mais específico para o tipo mais genérico. Isso evita que uma
exceção genérica capture o erro antes que uma exceção mais específica tenha a chance de tratá-lo.

Exceptions 5
 8. O bloco finally
O bloco finally é utilizado para executar um trecho de código independentemente de uma exceção
acontecer ou não. Ele é muito usado para liberar recursos, fechar arquivos, encerrar conexões ou finalizar
objetos que precisam ser encerrados corretamente.
A estrutura é:

try {
// Código que pode gerar uma exceção.
} catch (TipoDaExcecao exception) {
// Tratamento da exceção.
} finally {
// Código executado sempre.
}

Exemplo:

public class ExemploFinally {

public static void main(String[] args) {
try {
int resultado = 10 / 0;
[Link]("Resultado: " + resultado);
} catch (ArithmeticException exception) {
[Link]("Erro: divisão por zero.");
} finally {
[Link]("Finalizando a operação.");
}
}
}

Mesmo que a exceção aconteça, o bloco finally será executado. Se a exceção não acontecer, ele
também será executado.
No contexto de entrada de dados, por exemplo, o finally pode ser usado para fechar o Scanner . Porém,
em programas simples executados no console, é comum fechar o Scanner apenas ao final do método
main .

9. Exceções verificadas e não verificadas

Em Java, as exceções podem ser classificadas em checked exceptions e unchecked exceptions.
As checked exceptions, ou exceções verificadas, são aquelas que o compilador obriga o programador a
tratar ou declarar. Elas geralmente representam problemas externos ao programa, como falhas ao ler
arquivos, problemas de rede ou erros de entrada e saída.
Exemplo de checked exception:

import [Link];
import [Link];
import [Link];

public class ExemploCheckedException {

public static void main(String[] args) {

Exceptions 6
 try {
BufferedReader leitor = new BufferedReader(new FileReader("[Link]
t"));

String linha = [Link]();

[Link](linha);

[Link]();
} catch (IOException exception) {
[Link]("Erro ao ler o arquivo: " + [Link]
());
}
}
}

Nesse exemplo, operações de leitura de arquivo podem lançar IOException . Como essa exceção é
verificada, o Java exige que ela seja tratada com try/catch ou declarada no método com throws .
As unchecked exceptions, ou exceções não verificadas, são exceções que ocorrem em tempo de
execução e não precisam obrigatoriamente ser tratadas pelo compilador. Elas normalmente indicam
problemas de lógica, validação ou uso incorreto de objetos.
Exemplo de unchecked exception:

public class ExemploUncheckedException {

public static void main(String[] args) {
String nome = null;

[Link]([Link]());
}
}

Nesse caso, ocorre uma NullPointerException , pois o código tenta chamar o método length() em uma
variável que não aponta para nenhum objeto.

10. Diferença entre throw e throws

Em Java, existem duas palavras muito importantes no tratamento de exceções: throw e throws .
A palavra throw é utilizada para lançar uma exceção manualmente. Isso significa que o próprio
programador identifica uma situação inválida e cria uma exceção para representar o problema.
Exemplo:

public class ExemploThrow {

public static void main(String[] args) {
int idade = -5;

if (idade < 0) {
throw new IllegalArgumentException("A idade não pode ser negativ
a.");
}

[Link]("Idade: " + idade);

Exceptions 7
 }
}

Nesse exemplo, a idade negativa não faz sentido para o sistema. Por isso, o programador lança uma
exceção do tipo IllegalArgumentException .
A palavra throws , por outro lado, é utilizada na assinatura de um método para informar que aquele método
pode lançar uma exceção. Assim, quem chamar esse método deverá tratar ou repassar a exceção.
Exemplo:

import [Link];
import [Link];
import [Link];

public class ExemploThrows {

public static void main(String[] args) {
try {
String primeiraLinha = lerPrimeiraLinha("[Link]");
[Link](primeiraLinha);
} catch (IOException exception) {
[Link]("Erro ao acessar o arquivo.");
}
}

public static String lerPrimeiraLinha(String caminho) throws IOException {

BufferedReader leitor = new BufferedReader(new FileReader(caminho));
String linha = [Link]();
[Link]();
return linha;
}
}

Nesse exemplo, o método lerPrimeiraLinha declara throws IOException . Isso indica que o método pode lançar
uma exceção de entrada e saída. O método main , ao chamar lerPrimeiraLinha , precisa lidar com essa
possibilidade.
De forma resumida:
throw : lança uma exceção;
throws : declara que um método pode lançar uma exceção.

11. Criando exceções personalizadas

Além das exceções prontas da linguagem Java, o programador pode criar suas próprias exceções. Isso é
útil quando queremos representar erros específicos das regras de negócio do sistema.
Por exemplo, em um sistema bancário, tentar sacar um valor maior do que o saldo disponível não é um
erro técnico como uma falha de arquivo ou uma divisão por zero. É uma regra de negócio. Nesse caso,
podemos criar uma exceção chamada SaldoInsuficienteException .
Exemplo de exceção personalizada:

Exceptions 8
 public class SaldoInsuficienteException extends Exception {
public SaldoInsuficienteException(String mensagem) {
super(mensagem);
}
}

Nesse exemplo, a classe SaldoInsuficienteException herda de Exception . Como ela herda diretamente de
Exception , ela será uma checked exception. Isso significa que o método que puder lançá-la deverá

declarar throws SaldoInsuficienteException , e quem chamar esse método deverá tratar a exceção.

12. Exemplo didático com classe ContaBancaria

A seguir, temos um exemplo mais próximo da Programação Orientada a Objetos. O sistema possui uma
classe ContaBancaria , com atributos privados, métodos de acesso, construtor e métodos para depositar e
sacar valores.

public class ContaBancaria {

private String titular;
private double saldo;

public ContaBancaria(String titular, double saldoInicial) {

[Link] = titular;
[Link] = saldoInicial;
}

public String getTitular() {

return titular;
}

public void setTitular(String titular) {

[Link] = titular;
}

public double getSaldo() {

return saldo;
}

public void depositar(double valor) {

if (valor <= 0) {
throw new IllegalArgumentException("O valor do depósito deve ser mai
or que zero.");
}

saldo += valor;
}

public void sacar(double valor) throws SaldoInsuficienteException {

if (valor <= 0) {
throw new IllegalArgumentException("O valor do saque deve ser maior
que zero.");

Exceptions 9
 }

if (valor > saldo) {

throw new SaldoInsuficienteException("Saldo insuficiente para realiz
ar o saque.");
}

saldo -= valor;
}
}

Nesse código, o método depositar lança uma IllegalArgumentException quando o valor informado é inválido.
Essa exceção é uma unchecked exception, pois representa o uso incorreto do método.
O método sacar , além de validar o valor, também verifica se existe saldo suficiente. Caso o saldo não seja
suficiente, ele lança uma SaldoInsuficienteException , que foi criada para representar uma regra específica
do sistema bancário.
Observe que a validação das regras fica dentro da própria classe ContaBancaria . Isso é importante em
Programação Orientada a Objetos, pois a classe deve proteger seus próprios dados e garantir que seus
objetos permaneçam em um estado válido.

13. Classe principal usando try/catch

A classe principal pode criar um objeto ContaBancaria e tratar as exceções geradas pelas operações.

import [Link];

public class ProgramaPrincipal {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

ContaBancaria conta = new ContaBancaria("Camila", 500.00);

[Link]("Titular: " + [Link]());

[Link]("Saldo inicial: R$ " + [Link]());

try {
[Link]("Digite o valor do saque: ");
double valorSaque = [Link]();

[Link](valorSaque);

[Link]("Saque realizado com sucesso.");

[Link]("Saldo atual: R$ " + [Link]());
} catch (SaldoInsuficienteException exception) {
[Link]("Erro na operação: " + [Link]());
} catch (IllegalArgumentException exception) {
[Link]("Valor inválido: " + [Link]());
}

[Link]();

Exceptions 10
 }
}

Nesse exemplo, a classe ProgramaPrincipal não precisa conhecer todos os detalhes internos da conta. Ela
apenas chama o método sacar e trata as exceções que podem acontecer.
Essa separação é importante. A classe ContaBancaria concentra as regras do objeto, enquanto a classe
principal decide como apresentar o resultado ao usuário.

14. Validação com exceções

As exceções também podem ser usadas para validar dados recebidos por métodos e construtores. Isso
ajuda a evitar que objetos sejam criados em estado inválido.
Observe o exemplo:

public class Aluno {

private String nome;
private double nota;

public Aluno(String nome, double nota) {

setNome(nome);
setNota(nota);
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

if (nome == null || [Link]()) {
throw new IllegalArgumentException("O nome do aluno é obrigatóri
o.");
}

[Link] = nome;
}

public double getNota() {

return nota;
}

public void setNota(double nota) {

if (nota < 0 || nota > 10) {
throw new IllegalArgumentException("A nota deve estar entre 0 e 1
0.");
}

[Link] = nota;
}
}

Exceptions 11
 Nesse exemplo, o construtor utiliza os métodos setNome e setNota para aproveitar as validações. Se o
nome for nulo, vazio ou se a nota estiver fora do intervalo permitido, uma exceção será lançada.
Esse tipo de validação é comum em classes bem projetadas. O objetivo é impedir que o objeto exista com
dados inconsistentes.

15. Exceções e encapsulamento

O tratamento de exceções está diretamente relacionado ao encapsulamento. Em Programação Orientada
a Objetos, os atributos de uma classe geralmente são definidos como private , e o acesso a eles acontece
por métodos públicos.
Esses métodos públicos funcionam como uma camada de proteção. Eles não apenas permitem acessar
ou modificar dados, mas também podem validar as informações antes de alterar o estado do objeto.
Exemplo:

public void setPreco(double preco) {

if (preco < 0) {
throw new IllegalArgumentException("O preço não pode ser negativo.");
}

[Link] = preco;
}

Nesse exemplo, a exceção impede que o atributo preco receba um valor inválido. Assim, a classe protege
seu próprio estado interno.
Portanto, exceções não devem ser vistas apenas como uma forma de lidar com erros inesperados. Elas
também podem ser utilizadas como parte do projeto da classe, ajudando a garantir regras e restrições
importantes do domínio do problema.

16. Exceções em entrada de dados com Scanner

Ao utilizar Scanner , é comum ocorrerem problemas quando o usuário digita um tipo de dado diferente do
esperado. Por exemplo, se o programa espera um número inteiro e o usuário digita uma palavra, pode
ocorrer uma InputMismatchException .
Exemplo:

import [Link];
import [Link];

public class ExemploScannerException {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

try {
[Link]("Digite sua idade: ");
int idade = [Link]();

if (idade < 0) {
throw new IllegalArgumentException("A idade não pode ser negativ
a.");

Exceptions 12
 }

[Link]("Idade informada: " + idade);

} catch (InputMismatchException exception) {
[Link]("Erro: digite apenas números inteiros.");
} catch (IllegalArgumentException exception) {
[Link]("Erro: " + [Link]());
}

[Link]();
}
}

Nesse caso, existem dois tipos de problema. O primeiro ocorre quando o usuário digita algo que não é
inteiro. O segundo ocorre quando o usuário até digita um inteiro, mas esse inteiro não é válido para o
contexto do programa.

17. Try-with-resources
O try-with-resources é uma forma especial de try utilizada para trabalhar com recursos que precisam ser
fechados automaticamente, como arquivos, leitores, conexões e fluxos de dados.
A vantagem dessa estrutura é que o recurso declarado dentro dos parênteses do try será fechado
automaticamente ao final da execução, mesmo que uma exceção aconteça.
Exemplo:

import [Link];
import [Link];
import [Link];

public class ExemploTryWithResources {

public static void main(String[] args) {
try (BufferedReader leitor = new BufferedReader(new FileReader("[Link]
t"))) {
String linha = [Link]();
[Link]("Primeira linha: " + linha);
} catch (IOException exception) {
[Link]("Erro ao ler o arquivo: " + [Link]
());
}
}
}

Nesse exemplo, não foi necessário chamar [Link]() manualmente. O próprio Java fecha o recurso
automaticamente ao final do bloco try .
Essa abordagem é considerada uma boa prática quando se trabalha com recursos que implementam a
interface AutoCloseable .

18. Boas práticas no uso de exceções

Exceptions 13
 O uso de exceções deve ser feito com cuidado. Elas são muito úteis, mas podem deixar o código confuso
se forem usadas sem critério.
Uma boa prática é tratar exceções específicas sempre que possível. Em vez de capturar Exception de
forma genérica, prefira capturar o tipo exato da exceção esperada, como NumberFormatException , IOException
ou SaldoInsuficienteException .
Exemplo menos adequado:

try {
int resultado = 10 / 0;
} catch (Exception exception) {
[Link]("Ocorreu um erro.");
}

Exemplo mais adequado:

try {
int resultado = 10 / 0;
} catch (ArithmeticException exception) {
[Link]("Não é possível dividir por zero.");
}

Também é importante não esconder erros. Um bloco catch vazio dificulta a identificação de problemas e
pode fazer o programa continuar em um estado inconsistente.
Exemplo inadequado:

try {
int resultado = 10 / 0;
} catch (ArithmeticException exception) {

Nesse exemplo, a exceção acontece, mas nada é feito. O erro é ignorado, o que prejudica a manutenção
do sistema.
Outra boa prática é apresentar mensagens claras para o usuário, sem expor detalhes técnicos
desnecessários. A mensagem para o usuário deve explicar o problema de forma simples. Já os detalhes
técnicos podem ser registrados em logs para análise posterior.

19. Quando usar exceções

As exceções devem ser usadas quando ocorre uma situação anormal que impede a continuação normal
de uma operação.
Elas são indicadas, por exemplo, quando:
o usuário fornece dados incompatíveis com a regra do sistema;
uma operação não pode ser realizada por violar uma regra de negócio;
um arquivo necessário não existe;
uma conexão externa falha;
um objeto obrigatório não foi informado;

Exceptions 14
 um valor recebido por parâmetro é inválido;
uma conversão de dados não pode ser realizada.
Porém, exceções não devem ser usadas como substitutas de estruturas condicionais comuns. Se uma
situação é esperada e faz parte do fluxo normal do sistema, muitas vezes um if é mais adequado.
Exemplo adequado com if :

if (idade >= 18) {

[Link]("Usuário maior de idade.");
} else {
[Link]("Usuário menor de idade.");
}

Nesse caso, ser maior ou menor de idade não é uma situação excepcional. É apenas uma regra normal do
sistema.
Já no exemplo abaixo, lançar uma exceção pode fazer sentido, pois uma idade negativa representa um
dado inválido:

if (idade < 0) {
throw new IllegalArgumentException("A idade não pode ser negativa.");
}

20. Exemplo completo: sistema simples de produtos

O exemplo abaixo apresenta uma classe Produto com validações usando exceções. O objetivo é
demonstrar como as exceções podem ser usadas para proteger os dados de um objeto.

public class Produto {

private String nome;
private double preco;
private int quantidade;

public Produto(String nome, double preco, int quantidade) {

setNome(nome);
setPreco(preco);
setQuantidade(quantidade);
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

if (nome == null || [Link]()) {
throw new IllegalArgumentException("O nome do produto é obrigatóri
o.");
}

[Link] = nome;
}

Exceptions 15
 public double getPreco() {
return preco;
}

public void setPreco(double preco) {

if (preco < 0) {
throw new IllegalArgumentException("O preço não pode ser negativ
o.");
}

[Link] = preco;
}

public int getQuantidade() {

return quantidade;
}

public void setQuantidade(int quantidade) {

if (quantidade < 0) {
throw new IllegalArgumentException("A quantidade não pode ser negati
va.");
}

[Link] = quantidade;
}

public double calcularValorTotalEstoque() {

return preco * quantidade;
}
}

Classe principal:

public class ProgramaPrincipal {

public static void main(String[] args) {
try {
Produto produto = new Produto("Notebook", 3500.00, 5);

[Link]("Produto: " + [Link]());

[Link]("Preço: R$ " + [Link]());
[Link]("Quantidade: " + [Link]());
[Link]("Total em estoque: R$ " + [Link]
talEstoque());
} catch (IllegalArgumentException exception) {
[Link]("Erro ao cadastrar produto: " + [Link]
age());
}
}
}

Exceptions 16
 Se os dados forem válidos, o produto será criado normalmente. Se algum dado inválido for informado, a
classe Produto lançará uma exceção e impedirá a criação de um objeto inconsistente.
Esse exemplo reforça um princípio importante da Programação Orientada a Objetos: o objeto deve ser
responsável por manter a validade de seus próprios dados.

21. Resumo dos principais comandos

Comando Função
try Define um bloco de código que pode gerar uma exceção.
catch Captura e trata uma exceção específica.
finally Executa um bloco de código independentemente de ocorrer exceção ou não.
throw Lança uma exceção manualmente.
throws Declara que um método pode lançar uma exceção.
getMessage() Retorna a mensagem associada à exceção.
printStackTrace() Exibe detalhes técnicos da exceção, geralmente usado para depuração.

22. Síntese final

As exceções são um recurso essencial da linguagem Java para lidar com situações anormais durante a
execução de um programa. Elas permitem separar o código principal da lógica de tratamento de erros,
deixando o sistema mais organizado, seguro e fácil de manter.
Em Programação Orientada a Objetos, as exceções também ajudam a proteger o estado interno dos
objetos. Por meio delas, uma classe pode impedir valores inválidos, operações proibidas e violações de
regras de negócio.
Ao estudar exceções, é importante compreender não apenas a sintaxe de try , catch , finally , throw e
throws , mas também o motivo de usar cada recurso. Um bom uso de exceções melhora a robustez do

programa, facilita a manutenção do código e contribui para a criação de sistemas mais confiáveis.

Exceptions 17