Estou desenvolvendo um programa de reserva de hotel e um dos requisitos é calcular a capacidade de pessoas para um determinado quarto, pessoas com menos de 2 anos não contam na hora da reserva.
Tenho minha classe principal, classe de hospede e da reserva. Eu criei o arraylist na minha classe main e atribui os valores e eu preciso recuperar esse valores na classe reserva para desenvolver o método, segue o código para vocês avaliarem.
Classe Main
public class Principal {
public static void main(String[] args) {
Hospede h1 = new Hospede();
h1.setNome("Pessoa1");
h1.setIdade(23);
h1.setEndereco("Brasil");
Hospede h2 = new Hospede();
h2.setNome("Pessoa2");
h2.setIdade(22);
h2.setEndereco("Brasil");
Hospede h3 = new Hospede();
h3.setNome("Pessoa3");
h3.setIdade(1);
h3.setEndereco("Brasil");
List <Hospede> hospedes = new ArrayList<Hospede>();
hospedes.add(h1);
hospedes.add(h2);
hospedes.add(h3);
}
Vou precisar utilizar a idade de cada um para calcular a capacidade de quarto em um método na minha classe Reserva.
Então uma reserva é criada a partir de N hóspedes, certo? Pensando na orientação objetos, vc precisa dos hóspedes para construir uma reserva, então vc pode ter um construtor na classe Reserva que irá receber a lista de hóspedes, ou vc pode ter um método, por exemplo, iniciar (de iniciar reserva) na classe Reserva que receba a lista de hóspedes e faça a validação:
public class Reserva {
// propriedades da reserva
public Reserva(List<Hospede> hospedes) {
validar(hospedes);
}
private boolean validar(List<Hospede> hospedes) throws ValidacaoReservaException {
// faça as validações e vc pode lançar uma exceção caso não passe em alguma validação
}
}
No exemplo, a classe ValidacaoReservaException é uma exceção customizada que herda de Exception apenas para deixar claro a validação.
E para usar:
public class Principal {
public static void main(String[] args) {
List <Hospede> hospedes = // cria a lista de hospedes
// Tenta criar a reseva
try {
Reserva reserva = new Reserva(hospedes);
salvar(reserva);
} catch (ValidacaoReservaException e) {
System.out.println("Não foi possível criar a reserva: " + e.getMessage());
}
}
}
Utilizando dessa forma como eu poderia utilizar os dados da idade? Por exemplo eu preciso criar um método para gerenciar a capacidade do quarto, na reserva o número de pessoas não pode ultrapassar a capacidade do quarto, criança de dois anos ou menos não conta na capacidade, pensei em usar um if, mas não sei como pegar os valores (no caso a idade) do ArrayList da classe Principal e trabalhar com ele na classe Reserva.
Estou começando ainda na programação Java , desde já agradeço você pela ajuda
Lucas confesso que fiquei meio perdido na sua explicação, ainda estou começando na programação Java, dentro do método que você explicou eu conseguiria fazer a tratativa da capacidade? Porque assim eu preciso gerenciar a capacidade do quarto e tem a questão da idade, crianças de 2 anos ou menos não conta má capacidade do quarto, pensei em usar um if no meu método, mas não sei como fazer isso kkkk, pode ser que nem seja a forma de tratar também
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String args[]) {
Quarto quartoSimples = new Quarto("Simples", 1);
List<Hospede> hospedes = new ArrayList<>();
hospedes.add(new Hospede("Fulano", 17));
try {
Reserva reserva = new Reserva(quartoSimples, hospedes);
salvar(reserva);
} catch (ValidacaoReservaException e) {
System.err.println("Não foi possível criar a reserva: " + e.getMessage());
}
}
private static void salvar(Reserva reserva) {
System.out.println("Reserva criada com sucesso: " + reserva);
}
}
public class Hospede {
private final String nome;
private final int idade;
public Hospede(String nome, int idade) {
this.nome = nome;
this.idade = idade;
}
public String getNome() {
return nome;
}
public int getIdade() {
return idade;
}
@Override
public String toString() {
return "nome=" + nome + ", idade=" + idade;
}
}
public class Quarto {
private final String descricao;
private final Integer capacidade;
public Quarto(String descricao, Integer capacidade) {
this.descricao = descricao;
this.capacidade = capacidade;
}
public String getDescricao() {
return descricao;
}
public Integer getCapacidade() {
return capacidade;
}
@Override
public String toString() {
return "Quarto \"" + descricao + "\" (capacidade=" + capacidade + ")";
}
}
public class Reserva {
private final Quarto quarto;
private final List<Hospede> hospedes;
public Reserva(Quarto quarto, List<Hospede> hospedes) throws ValidacaoReservaException {
this.quarto = quarto;
this.hospedes = hospedes;
validar();
}
private void validar() throws ValidacaoReservaException {
// inventei essas regras para exemplificar:
// > Para quartos com capacidade igual à 1:
// - deve ser apenas 1 hóspede para a reserva e
// - o hóspede deve ser maior idade (maior que 18 anos)
if (quarto.getCapacidade() == 1) {
if (hospedes.size() > 1) {
throw new ValidacaoReservaException("Para quartos com capacidade igual à 1, a reserva deve ter apenas 1 hóspede.");
}
for (Hospede hospede : hospedes) {
if (hospede.getIdade() < 18) {
throw new ValidacaoReservaException("Para quartos com capacidade igual à 1, o hóspede deve ser maior de idade.");
}
}
}
}
@Override
public String toString() {
return "Reserva [" + quarto + ", hospedes=" + hospedes + "]";
}
}
public class ValidacaoReservaException extends Exception {
private static final long serialVersionUID = 1L;
public ValidacaoReservaException(String message) {
super(message);
}
}
A ideia é deixar a responsabilidade de validar a reserva na própria classe Reserva. Isso deixa a classe mais inteligente e as validações centralizadas onde mais interessa. E, lembrando, que essa é apenas uma forma de fazer.
Muito obrigado Lucas você é 10. Outra coisa se não for incomodo, porque nessa parte você escreveu diferente das outras classes?
E eu tenho que calcular a capacidade, se a pessoa tiver 2 anos ou menos não soma na capacidade, vi seu exemplo e pensei em fazer assim, mas não deu muito certo kkk tenho que estudar essa estrutura
for (Hospede hospede :hospedes){
if(hospede.getIdade()<=2){
quarto.getCapacidade() = quarto.getCapacidade()+1;
}
}
Apenas coloquei toString nas classes para aparecer alguma informação útil no console no método salvar (apenas para o exemplo mesmo).
Esse cálculo seria para verificar se a capacidade do quarto atende a quantidade de hóspedes considerando a idade certo?
Nesse caso, vc poderia filtrar a lista de hóspedes antes e, só então, verificar com a capacidade do quarto. Veja:
Alteração na classe Hospede:
public class Hospede {
private final String nome;
private final int idade;
public Hospede(String nome, int idade) {
this.nome = nome;
this.idade = idade;
}
/*
* Verifica se hóspede afeta a capacidade do quarto pela idade
*/
public boolean isAfetaCapacidadeQuarto() {
return idade >= 2;
}
public String getNome() {
return nome;
}
public int getIdade() {
return idade;
}
@Override
public String toString() {
return "nome=" + nome + ", idade=" + idade;
}
}
e para verificar a capacidade:
List<Hospede> hospedesCalculoCapacidade = hospedes.stream()
.filter(h -> h.isAfetaCapacidadeQuarto())
.collect(Collectors.toList());
if (hospedesCalculoCapacidade.size() > quarto.getCapacidade()) {
throw new ValidacaoReservaException("Há mais hóspedes do que a capacidade permitida para o quarto \"" + quarto.getDescricao() + "\"");
}
Obrigado pelo apoio Lucas, eu tentei aqui mas ele não está atendendo essa validação, tá passando direto pra de capacidade, e eu coloquei primeiro essa condição de menor de 2 anos
(Não sei se isso interfere kkk)
import java.util.List;
import java.util.stream.Collectors;
public class Reserva {
private final Quarto quarto;
private final List<Hospede> hospedes;
public Reserva(Quarto quarto, List<Hospede> hospedes) throws ValidacaoReservaException {
this.quarto = quarto;
this.hospedes = hospedes;
validar();
}
private void validar() throws ValidacaoReservaException {
List<Hospede> hospedesCalculoCapacidade = hospedes.stream()
.filter(h -> h.isAfetaCapacidadeQuarto())
.collect(Collectors.toList());
if (hospedesCalculoCapacidade.size() > quarto.getCapacidade()) {
throw new ValidacaoReservaException("Há mais hóspedes do que a capacidade permitida para o quarto \"" + quarto.getDescricao() + "\"");
}
if (quarto.getCapacidade() == 1) {
if (hospedes.size() > 1) {
throw new ValidacaoReservaException("Para quartos com capacidade igual à 1, a reserva deve ter apenas 1 hóspede.");
}
for (Hospede hospede : hospedes) {
if (hospede.getIdadeResp() < 18) {
throw new ValidacaoReservaException("Para fazer a reserva, precisa de um hospede responsável maior de 18 anos.");
}
}
}
}
@Override
public String toString() {
return "Reserva [" + quarto + ", hospedes=" + hospedes + "]";
}
}
É nesse caso que eu queria ver, esse filtro de lista é novo e estou tentando entender, basicamente ele percorre toda a lista verificando a idade, ai ele chama o isAfetarCapacidade que está na classe Hospede, esse método retorna que idade >2 afeta na contagem da capacidade, seria isso?
public boolean isAfetaCapacidadeQuarto(){
return idade > 2;
}