// A classe 'VooFactory' implementa a interface 'ReservaFactory'.

// Isso significa que ela é uma "fábrica" especializada na criação de reservas de

voo,
public class VooFactory implements ReservaFactory {

// Ele é responsável por criar e retornar um objeto do tipo 'ReservaVoo'.

@Override
public Reserva criarReserva(String nomeCliente, Object... parametros) {

// Validação inicial para garantir que todos os parâmetros necessários

foram fornecidos.
// A lógica do negócio para um voo exige 5 parâmetros específicos.
if ([Link] < 5) {
// Se a quantidade de parâmetros for insuficiente, uma exceção é
lançada.
// Isso evita a criação de uma reserva de voo inválida.
throw new IllegalArgumentException("Parâmetros insuficientes para criar
reserva de voo");
}

// Extração dos parâmetros do array 'parametros' e conversão para os tipos

corretos.
// O 'cast' (String) e (Double) é necessário porque o array é do tipo
genérico 'Object'.
String companhiaAerea = (String) parametros[0];
String origem = (String) parametros[1];
String destino = (String) parametros[2];
String classeAssento = (String) parametros[3];
double precoBase = (Double) parametros[4];

// Um novo objeto 'ReservaVoo' é instanciado e retornado.

// O construtor é chamado com todos os dados coletados, encapsulando a
criação do objeto.
return new ReservaVoo(nomeCliente, companhiaAerea, origem, destino,
classeAssento, precoBase);
}
}

import [Link];

public class ReservaPacote extends Reserva {

private List<Reserva> reservasIncluidas;
private double desconto = 0.10; // 10% de desconto

public ReservaPacote(String cliente, List<Reserva> reservasIncluidas) throws

Exception {
super(cliente);
[Link] = reservasIncluidas;
validar();
}

@Override
public double calcularValor() {
double soma = 0.0;
for (Reserva r : reservasIncluidas) {
soma += [Link]();
}
return soma * (1 - desconto);
}
 @Override
public void validar() throws Exception {
if (reservasIncluidas == null || [Link]()) throw new
Exception("Pacote deve ter ao menos uma reserva.");
}

@Override
public String toString() {
return [Link]() + " | Pacote [itens=" + [Link]() +
", valor=" + calcularValor() + "]";
}
}

public class CarroFactory implements ReservaFactory {

// A anotação @Override indica que este metodo está implementando um metodo da

interface ReservaFactory.
// CriarReserva é responsável por criar um objeto do tipo Reserva.
@Override
public Reserva criarReserva(String nomeCliente, Object... parametros) {

// Verifica se a quantidade de parâmetros é menor que 4.

// A a exigencia que 4 parâmetros específicos sejam fornecidos para criar
uma reserva de carro.
if ([Link] < 4) {
// Se a condição for verdadeira, uma exceção é lançada.
// Isso impede que a reserva seja criada com dados incompletos.
throw new IllegalArgumentException("Parâmetros insuficientes para criar
reserva de carro");
}

// Os parâmetros são extraídos do array 'parametros'.

// É importante fazer um 'cast' para o tipo de dado correto (String,
Integer, Double, etc)
String modeloCarro = (String) parametros[0];
int diasAluguel = (Integer) parametros[1];
double precoDia = (Double) parametros[2];
String tipoVeiculo = (String) parametros[3];

// Um novo objeto ReservaCarro é criado e retornado.

// Este objeto representa a reserva de um carro, contendo todas as
informações necessárias.
return new ReservaCarro(nomeCliente, modeloCarro, diasAluguel, precoDia,
tipoVeiculo);

public class HotelFactory implements ReservaFactory {

// O metodo criarReserva é responsável por construir um objeto do tipo
ReservaHotel.
@Override
public Reserva criarReserva(String nomeCliente, Object... parametros) {

// Esta verificação garante que a quantidade de parâmetros passados

(tamanho do array 'parametros')
// é suficiente para criar a reserva. exige 4 parâmetros.
 if ([Link] < 4) {
// Se satisfazer a condição, uma exceção é lançada.
// Isso evita a criação de uma reserva com dados incompletos ou nulos.
throw new IllegalArgumentException("Parâmetros insuficientes para criar
reserva de hotel");
}

// O 'cast' ((String), (Integer), (Double)) é necessário para converter

cada objeto
// para o seu tipo de dado específico.
String nomeHotel = (String) parametros[0];
String cidade = (String) parametros[1];
int diarias = (Integer) parametros[2];
double precoDiaria = (Double) parametros[3];

// Um novo objeto ReservaHotel é instanciado e retornado.

// Ele encapsula todas as informações da reserva de hotel em um único
objeto.
return new ReservaHotel(nomeCliente, nomeHotel, cidade, diarias,
precoDiaria);
}
}
public class PacoteFactory implements ReservaFactory {

// O objetivo e criar um objeto do tipo ReservaPacote.

@Override
public Reserva criarReserva(String nomeCliente, Object... parametros) {

// A primeira verificação garante que a lista de parâmetros não está vazia.

// A segunda verificação confirma que o primeiro parâmetro é de fato um
array de objetos Reserva.
// Isso é crucial, pois um pacote é uma coleção de outras reservas.
if ([Link] < 1 || !(parametros[0] instanceof Reserva[])) {
// Se as validações falharem, uma exceção é lançada.
// Isso evita erros de execução e garante que os dados de entrada estão
corretos.
throw new IllegalArgumentException("Parâmetro inválido para criar
pacote");
}

// O parâmetro é convertido (cast) de um tipo genérico 'Object' para um

array de 'Reserva'.
// Isso permite acessar e usar os serviços contidos no pacote.
Reserva[] servicos = (Reserva[]) parametros[0];

// Um novo objeto ReservaPacote é criado e retornado.

// O construtor recebe o nome do cliente e o array de serviços,
encapsulando tudo.
return new ReservaPacote(nomeCliente, servicos);

}
import [Link];
import [Link];

// A classe 'Reserva' é declarada como abstrata, o que significa que ela não pode
ser instanciada diretamente.
// Ela serve como uma classe base para outros tipos de reservas (como Voo, Hotel,
etc.),
// definindo um contrato e atributos comuns.
public abstract class Reserva {
// Atributos protegidos, acessíveis apenas por esta classe e suas subclasses.
protected String nomeCliente;
protected String codigo;
protected LocalDateTime dataCriacao;
protected String status;

// Primeiro construtor, que permite definir o nome e um código opcional para a

reserva.
public Reserva(String nomeCliente, String codigo) {
// Validação inicial para garantir que o nome do cliente não é nulo ou
vazio.
// Se a validação falhar, uma exceção é lançada.
if (nomeCliente == null || [Link]().isEmpty()) {
throw new IllegalArgumentException("Nome do cliente é obrigatório");
}

// Atribui o nome do cliente, removendo espaços em branco extras.

[Link] = [Link]();
// Atribui o código. Se um código for fornecido, ele é usado; caso
contrário,
// um código único e aleatório é gerado a partir de um UUID.
[Link] = (codigo != null) ? codigo :
[Link]().toString().substring(0, 8);
// Registra a data e hora de criação da reserva.
[Link] = [Link]();
// Define o status inicial da reserva como "Ativa".
[Link] = "Ativa";
}

// Segundo construtor, uma sobrecarga que simplifica a criação da reserva.

// Ele aceita apenas o nome do cliente e delega a chamada ao primeiro
construtor,
// passando 'null' para o código e permitindo a geração automática.
public Reserva(String nomeCliente) {
this(nomeCliente, null);
}

// Metodo abstrato 'calcularValor()'. Não tem implementação aqui.

// Subclasses são OBRIGADAS a implementar este metodo,
// garantindo que cada tipo de reserva terá sua própria lógica de cálculo.
public abstract double calcularValor();

// Metodo para validar a reserva.

public boolean validar() {
// Valida se o nome do cliente foi definido.
// Lança uma exceção se a validação falhar.
if (nomeCliente == null || [Link]().isEmpty()) {
throw new IllegalArgumentException("Reserva sem nome de cliente");
}
// Retorna verdadeiro se a validação for bem-sucedida.
return true;
}

// Metodo para cancelar a reserva.

public String cancelar() {
// Altera o status da reserva para "Cancelada".
 [Link] = "Cancelada";
// Retorna uma mensagem de confirmação para o usuário.
return "Reserva " + codigo + " cancelada com sucesso";
}

// Métodos 'get' (ou 'getters') para acessar os atributos da classe de forma

controlada (encapsulamento).
public String getNomeCliente() { return nomeCliente; }
public String getCodigo() { return codigo; }
public LocalDateTime getDataCriacao() { return dataCriacao; }
public String getStatus() { return status; }

// Sobrescreve o metodo padrão 'toString()' da classe Object.

// Fornece uma representação de string formatada e legível do objeto,
// útil para depuração e exibição em logs ou na interface.
@Override
public String toString() {
return "Código: " + codigo + " | Cliente: " + nomeCliente +
" | Tipo: " + getClass().getSimpleName() + " | Status: " + status;
}
}
public class ReservaCarro extends Reserva {
// Declaração de atributos específicos para uma reserva de carro.
// Esses campos complementam os atributos herdados da classe base 'Reserva'.
private String modeloCarro;
private int diasAluguel;
private double precoDia;
private String tipoVeiculo;

// Construtor para inicializar uma reserva de carro.

// Ele recebe os parâmetros necessários para o cliente e o carro.
public ReservaCarro(String nomeCliente, String modeloCarro, int diasAluguel,
double precoDia, String tipoVeiculo) {
// Chama o construtor da superclasse 'Reserva' para inicializar os
atributos comuns
// (nomeCliente, codigo, dataCriacao, status).
super(nomeCliente);

// Atribuição dos atributos específicos de 'ReservaCarro'.

[Link] = modeloCarro;
[Link] = diasAluguel;
[Link] = precoDia;
[Link] = tipoVeiculo;

// Validações adicionais específicas para uma reserva de carro.

// Se a validação falhar, uma exceção 'IllegalArgumentException' é lançada.
if (diasAluguel <= 0) {
throw new IllegalArgumentException("Número de dias deve ser positivo");
}
if (precoDia <= 0) {
throw new IllegalArgumentException("Preço por dia deve ser positivo");
}
}

// Sobrescreve o metodo abstrato 'calcularValor()' da superclasse 'Reserva'.

// Esta é a implementação específica para uma reserva de carro.
@Override
public double calcularValor() {
// O valor total é calculado multiplicando os dias de aluguel pelo preço
por dia.
return diasAluguel * precoDia;
}

// Sobrescreve o metodo 'validar()' da superclasse para adicionar validações

específicas.
@Override
public boolean validar() {
// Chama o metodo 'validar()' da superclasse para executar as validações
básicas (ex: nome do cliente).
[Link]();

// Adiciona a validação para garantir que o modelo e o tipo de veículo não

são nulos.
if (modeloCarro == null || tipoVeiculo == null) {
throw new IllegalArgumentException("Informações do carro incompletas");
}
// Retorna verdadeiro se todas as validações (da superclasse e desta
classe) forem bem-sucedidas.
return true;
}

// Sobrescreve o metodo 'toString()' da superclasse para fornecer uma

representação de string mais detalhada.
@Override
public String toString() {
// Concatena a representação da superclasse com informações específicas do
carro.
return [Link]() + " | Carro: " + modeloCarro + " | Dias: " +
diasAluguel +
" | Valor: R$" + [Link]("%.2f", calcularValor());
}
}
/ Esta interface define um contrato para a criação de objetos do tipo 'Reserva'.
// Ela faz parte do padrão de projeto Factory Method, que promove a criação de
objetos
// de forma flexível e desacoplada.
public interface ReservaFactory {

/**
* Este é o metodo principal da interface, responsável por criar uma reserva.
* * O nome do cliente para quem a reserva será criada.
* @param parametros: Uma lista de parâmetros de tipo genérico (Object...).
* O 'Object...' (varargs) permite que o metodo aceite
* um número variável de argumentos, o que é ideal aqui,
* pois cada tipo de reserva (voo, hotel, carro)
* precisa de parâmetros diferentes.
*/
Reserva criarReserva(String nomeCliente, Object... parametros);
}
// A classe 'ReservaHotel' herda da classe abstrata 'Reserva', o que significa que
// ela é um tipo específico de reserva e deve implementar os métodos abstratos da
classe pai.
public class ReservaHotel extends Reserva {
// Atributos privados específicos para uma reserva de hotel.
// O 'private' garante que esses atributos só podem ser acessados dentro desta
classe.
private String nomeHotel;
private String cidade;
 private int diarias;
private double precoDiaria;

// Construtor para a ReservaHotel.

// Ele recebe os parâmetros necessários para criar uma reserva de hotel.
public ReservaHotel(String nomeCliente, String nomeHotel, String cidade,
int diarias, double precoDiaria) {
// 'super(nomeCliente)' chama o construtor da classe pai (Reserva).
// Isso é crucial para inicializar os atributos da classe base, como
nomeCliente, código e status.
super(nomeCliente);

// Atribui os valores passados nos parâmetros para os atributos específicos

de hotel.
[Link] = nomeHotel;
[Link] = cidade;
[Link] = diarias;
[Link] = precoDiaria;

// Validações adicionais para garantir que os dados da reserva de hotel são

válidos.
// O número de diárias e o preço da diária devem ser valores positivos.
if (diarias <= 0) {
throw new IllegalArgumentException("Número de diárias deve ser
positivo");
}
if (precoDiaria <= 0) {
throw new IllegalArgumentException("Preço da diária deve ser
positivo");
}
}

// A anotação '@Override' indica que este metodo está sobrescrevendo um metodo

da classe pai.
// A classe 'Reserva' tem um metodo abstrato 'calcularValor()', então esta
classe deve fornecer a implementação.
@Override
public double calcularValor() {
// A lógica de cálculo do valor total para uma reserva de hotel.
// O valor é o resultado da multiplicação das diárias pelo preço da diária.
return diarias * precoDiaria;
}

// Sobrescreve o metodo 'validar()' da classe pai para adicionar validações

específicas de hotel.
@Override
public boolean validar() {
// Chama o metodo 'validar()' da classe pai para garantir que a validação
base seja feita primeiro.
// Isso evita duplicação de código.
[Link]();

// Validação específica: verifica se o nome do hotel e a cidade não são

nulos.
if (nomeHotel == null || cidade == null) {
throw new IllegalArgumentException("Informações do hotel incompletas");
}
// Se todas as validações passarem, retorna 'true'.
return true;
 }

// Sobrescreve o metodo 'toString()' para fornecer uma representação de string

detalhada do objeto.
@Override
public String toString() {
// '[Link]()' chama o metodo 'toString()' da classe pai,
// garantindo que a informação base (código, cliente, tipo) seja incluída.
return [Link]() + " | Hotel: " + nomeHotel + " | Diárias: " +
diarias +
// Adiciona o valor total da reserva, formatado com duas casas
decimais.
" | Valor: R$" + [Link]("%.2f", calcularValor());
}
}

// A classe 'ReservaPacote' herda da classe abstrata 'Reserva'.

// Isso a define como um tipo específico de reserva, que agrupa outros serviços.
public class ReservaPacote extends Reserva {
// Atributo privado para armazenar um array de objetos 'Reserva'.
// Cada elemento do array representa um serviço (como um voo ou um hotel)
// que faz parte deste pacote.
private Reserva[] servicos;

// Construtor para a ReservaPacote.

// Ele recebe o nome do cliente e um array de serviços.
public ReservaPacote(String nomeCliente, Reserva[] servicos) {
// 'super(nomeCliente)' chama o construtor da classe pai (Reserva).
// Isso garante que os atributos básicos (nomeCliente, código, etc.) sejam
inicializados.
super(nomeCliente);

// Atribui o array de serviços passado para o atributo da classe.

[Link] = servicos;

// Validação crucial: um pacote deve ter pelo menos 2 serviços.

// Se a validação falhar, uma exceção é lançada para impedir a criação de
um pacote inválido.
if (servicos == null || [Link] < 2) {
throw new IllegalArgumentException("Pacote deve conter pelo menos 2
serviços");
}
}

// A anotação '@Override' indica que este metodo está sobrescrevendo o metodo

abstrato 'calcularValor()' da classe pai.
@Override
public double calcularValor() {
// Variável local para acumular o valor total dos serviços.
double total = 0;
// Loop 'for-each' que itera sobre cada 'Reserva' no array 'servicos'.
for (Reserva servico : servicos) {
// Chama o metodo 'calcularValor()' de cada serviço individualmente e
soma ao total.
// Isso demonstra o poder do polimorfismo, pois cada serviço (Voo,
Hotel, etc.)
// sabe como calcular seu próprio valor.
 total += [Link]();
}
// Aplica um desconto de 10% sobre o valor total.
return total * 0.9; // 10% de desconto
}

// Sobrescreve o metodo 'validar()' da classe pai.

@Override
public boolean validar() {
// Chama o metodo 'validar()' da classe pai para executar as validações
básicas primeiro.
[Link]();
// Itera sobre cada serviço no pacote para garantir que todos são válidos
individualmente.
for (Reserva servico : servicos) {
// Chama o metodo 'validar()' de cada serviço.
[Link]();
}
// Retorna 'true' se todas as validações, tanto da classe pai quanto dos
serviços, passarem.
return true;
}

// Sobrescreve o metodo 'toString()' para fornecer uma representação de string

detalhada e legível do objeto.
@Override
public String toString() {
// Usa 'StringBuilder' para construir a descrição dos serviços de forma
eficiente.
StringBuilder servicosDesc = new StringBuilder();
// Itera sobre o array 'servicos' para construir a string de descrição.
for (int i = 0; i < [Link]; i++) {
// Adiciona o nome simples da classe de cada serviço (ex:
"ReservaVoo").
[Link](servicos[i].getClass().getSimpleName());
// Adiciona um separador '+' entre os serviços, exceto no último.
if (i < [Link] - 1) {
[Link](" + ");
}
}
// Retorna a string final, combinando a representação da classe pai com os
detalhes do pacote.
// Inclui o valor total do pacote, formatado com duas casas decimais.
return [Link]() + " | Pacote: " + [Link]() +
" | Valor: R$" + [Link]("%.2f", calcularValor());
}
}

// A classe 'ReservaVoo' herda da classe abstrata 'Reserva'.

// Isso a define como um tipo específico de reserva, com atributos e comportamentos
próprios.
public class ReservaVoo extends Reserva {
// Atributos privados específicos para uma reserva de voo.
// O 'private' garante que esses atributos só podem ser acessados dentro desta
classe.
private String companhiaAerea;
private String origem;
private String destino;
private String classeAssento;
 private double precoBase;

// Construtor para a ReservaVoo.

// Ele recebe os parâmetros necessários para criar uma reserva de voo.
public ReservaVoo(String nomeCliente, String companhiaAerea, String origem,
String destino, String classeAssento, double precoBase) {
// 'super(nomeCliente)' chama o construtor da classe pai (Reserva).
// Isso é crucial para inicializar os atributos da classe base, como
nomeCliente, código e status.
super(nomeCliente);

// Atribui os valores passados nos parâmetros para os atributos específicos

de voo.
[Link] = companhiaAerea;
[Link] = origem;
[Link] = destino;
[Link] = classeAssento;
[Link] = precoBase;

// Validação adicional: o preço base do voo deve ser positivo.

// Se a validação falhar, uma exceção é lançada para impedir a criação de
uma reserva inválida.
if (precoBase <= 0) {
throw new IllegalArgumentException("Preço base deve ser positivo");
}
}

// A anotação '@Override' indica que este metodo está sobrescrevendo o metodo

abstrato 'calcularValor()' da classe pai.
@Override
public double calcularValor() {
// Usa uma declaração 'switch' para aplicar um fator de preço com base na
classe do assento.
// Isso demonstra como a lógica de negócio é encapsulada na própria classe.
switch ([Link]()) {
case "executiva":
return precoBase * 1.8; // Fator de 1.8 para a classe executiva.
case "primeira":
return precoBase * 3.0; // Fator de 3.0 para a primeira classe.
default:
return precoBase * 1.0; // Fator padrão de 1.0 para outras classes
(ex: econômica).
}
}

// Sobrescreve o metodo 'validar()' da classe pai para adicionar validações

específicas de voo.
@Override
public boolean validar() {
// Chama o metodo 'validar()' da classe pai para garantir que a validação
base seja feita primeiro.
[Link]();

// Validação específica: verifica se as informações essenciais do voo não

são nulas.
if (companhiaAerea == null || origem == null || destino == null ||
classeAssento == null) {
throw new IllegalArgumentException("Informações do voo incompletas");
}
 // Se todas as validações passarem, retorna 'true'.
return true;
}

// Sobrescreve o metodo 'toString()' para fornecer uma representação de string

detalhada e legível do objeto.
@Override
public String toString() {
// '[Link]()' chama o metodo 'toString()' da classe pai,
// garantindo que a informação base (código, cliente, tipo) seja incluída.
return [Link]() + " | Voo: " + origem + "-" + destino +
" | Classe: " + classeAssento +
// Adiciona o valor total da reserva, formatado com duas casas
decimais.
" | Valor: R$" + [Link]("%.2f", calcularValor());
}
}

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

// A classe 'SistemaReservasFacade' implementa o padrão de projeto Facade.

// Sua função é simplificar a interface do subsistema de reservas para o cliente
(classe Main).
// Ela esconde a complexidade de gerenciar as diferentes fábricas e tipos de
reserva.
public class SistemaReservasFacade {
// Lista para armazenar todas as reservas criadas no sistema.
private List<Reserva> reservas;
// Mapa que associa o tipo de reserva (String) à sua respectiva
'ReservaFactory'.
// Isso permite criar a fábrica correta dinamicamente, de acordo com o tipo
solicitado.
private Map<String, ReservaFactory> factories;

// Construtor da fachada.
public SistemaReservasFacade() {
[Link] = new ArrayList<>();
[Link] = new HashMap<>();

// Inicializa o mapa 'factories' com as fábricas de cada tipo de reserva.

// Isso é a essência do Factory Method: a fachada não cria objetos
diretamente,
// mas delega a criação para a fábrica apropriada.
[Link]("voo", new VooFactory());
[Link]("hotel", new HotelFactory());
[Link]("carro", new CarroFactory());
[Link]("pacote", new PacoteFactory());
}

// Metodo principal para criação de reservas.

// Ele recebe o tipo de reserva, o nome do cliente e os parâmetros específicos.
public String criarReserva(String tipo, String nomeCliente, Object...
parametros) {
try {
// Busca a fábrica correta no mapa com base no tipo de reserva.
ReservaFactory factory = [Link]([Link]());
 if (factory == null) {
return "Tipo de reserva não suportado: " + tipo;
}

// Usa a fábrica encontrada para criar a reserva.

// A fachada não se preocupa com os detalhes da criação (qual
construtor chamar, etc.).
Reserva reserva = [Link](nomeCliente, parametros);
// Valida a reserva recém-criada.
[Link]();
// Adiciona a reserva válida à lista de reservas do sistema.
[Link](reserva);
return "Reserva criada com sucesso! Código: " + [Link]();

} catch (IllegalArgumentException e) {
// Captura e trata erros específicos de validação.
return "Erro ao criar reserva: " + [Link]();
} catch (Exception e) {
// Captura erros inesperados.
return "Erro inesperado: " + [Link]();
}
}

// Metodo que percorre a lista de reservas e gera uma string com todas as
informações.
public String listarTodasReservas() {
if ([Link]()) {
return "Nenhuma reserva encontrada.";
}

StringBuilder resultado = new StringBuilder();

for (Reserva reserva : reservas) {
// Utiliza o metodo 'toString()' polimórfico de cada objeto 'Reserva'
// para obter a descrição detalhada.
[Link]([Link]()).append("\n");
}
return [Link]();
}

// Metodo para filtrar e listar reservas por tipo.

public String listarReservasPorTipo(String tipo) {
List<Reserva> reservasTipo = new ArrayList<>();
String tipoLower = [Link]();

for (Reserva reserva : reservas) {

// Obtém o nome da classe do objeto e verifica se contém o tipo
desejado.
String className = [Link]().getSimpleName().toLowerCase();
if ([Link](tipoLower)) {
[Link](reserva);
}
}

if ([Link]()) {
return "Nenhuma reserva do tipo " + tipo + " encontrada.";
}

StringBuilder resultado = new StringBuilder();

for (Reserva reserva : reservasTipo) {
 [Link]([Link]()).append("\n");
}
return [Link]();
}

// Metodo que encontra uma reserva pelo código e exibe seu valor.
public String exibirValorTotalReserva(String codigo) {
for (Reserva reserva : reservas) {
// Compara o código da reserva com o código fornecido.
if ([Link]().equals(codigo)) {
// Utiliza o metodo 'calcularValor()' polimórfico.
return "Valor da reserva " + codigo + ": R$" +
[Link]("%.2f", [Link]());
}
}
return "Reserva não encontrada.";
}

// Metodo para cancelar uma reserva.

public String cancelarReserva(String codigo) {
for (Reserva reserva : reservas) {
// Encontra a reserva pelo código e chama seu metodo 'cancelar()'.
if ([Link]().equals(codigo)) {
return [Link]();
}
}
return "Reserva não encontrada.";
}

// Metodo auxiliar para obter um objeto 'Reserva' pelo código, útil para outras
operações.
public Reserva getReservaPorCodigo(String codigo) {
for (Reserva reserva : reservas) {
if ([Link]().equals(codigo)) {
return reserva;
}
}
return null;
}
}