Boa noite, estou com dificuldades em fazer um trabalho da faculdade, se alguém puder ajudar com algumas ideias de como melhorar o código e fazer o que falta. agradeço, vou colocar as etapas do trabalho e o que já fiz.
Existe uma necessidade de gerenciar controles, medidas e atividades em uma aplicação
destinada ao trabalho com eventos. Os eventos ocorridos são de tipos diferentes, com exigências
diferentes e geram resultados diferentes. Essas diferenças são difíceis de serem controladas
sem o devido auxílio de uma aplicação. Nesse sentido, os requisitos listados abaixo cobrem essa
necessidade aqui descrita
R1) É necessário ter uma classe Evento para representar as principais características do evento.
Crie atributos para tratar o nome do evento, data e a quantidade de pessoas que estarão
presentes. Esses atributos são os básicos e requisitados, você pode adicionar quaisquer outros
para enriquecer o projeto (o mesmo serve para outras classes a serem criadas). Além disso, crie
o método iniciarEvento() que imprime na tela o resumo das informações do evento e também
uma mensagem dizendo que o evento foi iniciado.
R2) Crie a classe GerenciaEventos para controlar e armazenar todos os eventos a serem
criados. Para tal, use ArrayList ou uma estrutura similar. Métodos de manipulação desse
ArrayList devem ser criados. Somente um objeto desse classe vai ser instanciado, e será na
classe Principal dentro do método main.
R3) Crie a classe Financas para lidar com os lucros e gastos de cada evento. Entende-se que, a
cada novo evento criado, um objeto da classe Financas será instaciado para representar o
controle desse evento. Nesta classe estima-se ter, no mínimo, os atributos relacionados às
entradas financeiras obtidas (que podem ser por diversas instâncias – patrocínio, venda de
ingressos, venda de bebidas, venda de comidas, …), despesas e, com base nesses dois itens, o
controle de lucros. Além disso, é necessário ter um método que imprime o resumo das finanças
de cada evento.
R4) Existe um ponto muito importante na realização dos eventos que é a operação de venda de
ingressos. Crie a classe OpVendaIngressos responsável por controlar, para cada evento criado,
os pontos de venda existentes, pessoas que estão trabalhando na operação, quantidades e
valores de ingresso e seus devidos lotes (promocionais, segundo, terceiro e quarto lotes). Cada
evento terá um número limite de ingressos a serem vendidos. Deve existir o método
verificarQuantidadeDisponivel(), que como parâmetro deve receber qual o lote se quer
verificar a quantidade de ingressos disponíveis para aquele evento. Além dele, deve existir
também o método vendeIngresso() que vai instanciar um objeto da classe Ingresso – a ser
criada. É necessário controlar todos os ingressos vendidos para cada evento – de preferência em
uma estrutura como ArrayList.
R5) Considerando o R4, crie uma classe chamada Ingresso. Cada ingresso vendido vai possuir
os atributos nome (nome do show ou da festa), data, tipoEntrada (para se referir se é meiaentrada ou inteira), setor (para se referir ao espaço para assistir o show – vip, pista, …), valor e
forma de pagamento (dinheiro ou cartão).
R6) Crie as classes Show e Festa, filhas da classe Evento. Elas devem possuir atributos próprios
que as diferenciam. Nesse sentido, entende-se que shows são um tipo de evento que contém a
apresentação de algum artista/banda e que festas são eventos temáticos que ocupam maior
espaço de tempo de duração que shows. Aliado a isso, crie uma classe Data para associar como
atributo em Evento.
R7) Utilize os modificadores de acesso para tratar o encapsulamento nas classes criadas até o
momento.
R8) Aplique poliformismo nos construtores de todas as classes e também sobrescreva nas
classes Show e Festa o método iniciarEvento(), considerando diferenças entre essas
classes.
R9) Pequise sobre o que são classes abstratas. Baseado na sua pesquisa, defina quais classes
são candidatas a serem abstratas.
R10) Crie uma interface chamada Conformidade para tratar as regulamentações e normas que
qualquer tipo de evento deve cumprir, seja Show ou seja Festa. Dentro dessa interface teremos
os métodos verificaAlvará(), realizarVistoria(), estabeleceAreasRestritas() e
controlaNormasGerais(). Crie o corpo desses métodos nas classes que implementam essa
interface. Deve existir uma diferença para shows e para festas:
Shows:
• verificaAlvara(): ao chamar esse método, deve ser impressa a capacidade
máxima do local que irá receber o show. Para tal, crie uma classe Local que
possua esses atributos.
• realizarVistoria(): imprimir as informações de dimensão do local que irá
receber o show (dimensões devem ser atributos da classe Local) e também as
taxas de vistoria (atributo taxas pertecente a classe Evento), que para shows
será representada pelo multiplicação da quantidade de pessoas que irão no
evento por R$1,25.
• estabeleceAreasRestritas(): criar as classes AreaFumante e
AreaAlimentacao que devem ser classes filhas de Local e utilizar composição
para criar essas areas dentro do método.
• controlaNormasGerais(): o método deve comparar a quantidade de pessoas
setada no evento com a capacidade máxima do local. Se estiver ok, imprimir
“Evento com a capacidade controlada”, do contrário, imprimir “Vai dar problema
com a galera”.
Festas:
• verificaAlvara(): idem a de Shows, porém imprimindo “Festa com capacidade
para X pessoas”.
• realizarVistoria(): imprimir as informações de dimensão do local que irá
receber o show (dimensões devem ser atributos da classe Local) ) e também as
taxas de vistoria (atributo taxas pertecente a classe Evento), que para Festas
será representada pelo multiplicação da quantidade de pessoas que irão no
evento por R$0,85.
• estabeleceAreasRestritas(): utilizar apenas a classe AreaFumante.
• controlaNormasGerais(): o método deve comparar a quantidade de pessoas
setada no evento com a capacidade máxima do local. Se estiver ok, imprimir
“Evento com a capacidade controlada”, do contrário, imprimir “Vai dar problema
com a galera”.
R11) Quem vai poder comprar ingresso é a Pessoa (caso não tenha a classe, crie – assim como o
método comprarIngresso()). Aplique polimorfismo ao permitir que a pessoa possa comprar
mais de um ingresso – assim se ela quiser comprar só um chamará o método
comprarIngresso(), e se quiser comprar mais de um irá chamar o método
comprarIngresso(int quantidade). Para realizar uma operação de compra de ingresso, a
pessoa precisa utilizar algum dos pontos de venda – assim, é necessário associar com a classe
OpVendaIngresso para saber.
R12) Vamos criar também uma classe chamada Banda. A banda vai possuir nome, número de
integrantes, gênero musical, número de shows feitos e o cachê que cobra. Na classe Show, faça
uma composição de Banda. Existem custos nessa contratação que precisam estar relacionados a
classe Financas.
R13) Durante a execução de cada evento, precisamos saber quais as comidas e bebidas que
serão vendidas para poder estimar os valores que vão impactar diretamente na classe Financas.
Nesse sentido, crie uma classe chamada Produto e suas respectivas classes filhas Alimento,
Bebida e Diversos. Entende-se que Diversos vai englobar itens de venda que não comidas e
bebidas (ex.: camisetas). Será necessária uma classe ProdutosEvento que gerenciar todos os
produtos que estarão sendo comercializados em cada evento.
R14) Faça uso de arquivos para inserir informações que possam ser consumidas pelos arraylists
criados ao longo dos requisitos.
import java.util.Calendar;
public abstract class Evento {
private String nomeEvento;
private String dataEvento;
private int qtdPessoas;
private Financa minhasFinancas;
public Evento () {
minhasFinancas = new Financa();
}
public void iniciarEvento () {
}
public void financas (Double gastos) {
minhasFinancas.setGastos(gastos);
}
public void financasLucros (Double lucros) {
minhasFinancas.setLucros(lucros);
}
public String getNomeEvento() {
return nomeEvento;
}
public void setNomeEvento(String nomeEvento) {
this.nomeEvento = nomeEvento;
}
public int getQtdPessoas() {
return qtdPessoas;
}
public void setQtdPessoas(int qtdPessoas) {
this.qtdPessoas = qtdPessoas;
}
public Financa getMinhasFinancas() {
return minhasFinancas;
}
public void setMinhasFinancas(Financa minhasFinancas) {
this.minhasFinancas = minhasFinancas;
}
public String getDataEvento() {
return dataEvento;
}
public void setDataEvento(String dataEvento) {
this.dataEvento = dataEvento;
}
}
import java.util.ArrayList;
import java.util.List;
public class GerenciaEventos {
List <Evento> evento = new ArrayList <>();
private int numEventos;
private Evento nomeEvento;
public GerenciaEventos() {
}
public void eventosRealizados () {
this.numEventos ++;
}
public void addEvento (Evento e) {
this.nomeEvento = e;
evento.add(this.nomeEvento);
}
public void listarEventosRealizados () {
if(evento.size() == 0) {
System.out.println("Nenhum evento realizado!");
} else {
for (int i = 0; i<evento.size();i++) {
System.out.println("=====================");
System.out.println("Evento " + evento.get(i).getNomeEvento());
System.out.println("Com capacidade para "+ evento.get(i).getQtdPessoas()+ " pessoas.");
System.out.println(evento.get(i).getMinhasFinancas());
}
}
}
public int getNumEventos() {
System.out.println("=====================");
return numEventos;
}
public void setNumEventos(int numEventos) {
this.numEventos = numEventos;
}
}
public class Financa {
private double lucros;
private double gastos;
public void imprimeResumaFinanca () {
System.out.println("Lucros ");
}
public double getLucros() {
return lucros;
}
public void setLucros(double lucros) {
this.lucros = lucros;
}
public double getGastos() {
return gastos;
}
public void setGastos(double gastos) {
this.gastos = gastos;
}
@Override
public String toString() {
return "Financa [lucros = " + lucros + ", gastos = " + gastos + "]";
}
}
import java.util.ArrayList;
import java.util.List;
public class OpVendaIngressos {
private List <Evento> evento = new ArrayList <>();
ArrayList<Ingresso> ingressos = new ArrayList<>();
ArrayList<ControleIngresso> controle = new ArrayList<>();
private Ingresso ingresso;
private Evento nomeEvento;
private ControleIngresso cIngresso;
private int qtdIngresso;
private int ingsVendidos;
public OpVendaIngressos() {
}
public void cadastrarIngresso (Ingresso ingresso, Evento nomeEvento,ControleIngresso cIngresso) {
this.ingresso = ingresso;
this.nomeEvento = nomeEvento;
this.cIngresso = cIngresso;
evento.add(this.nomeEvento);
ingressos.add(this.ingresso);
controle.add(this.cIngresso);
}
public void listarIngressosCadastrados () {
if(ingressos.size() == 0) {
System.out.println("Nenhum ingresso disponivel!");
} else {
for (int i = 0; i<ingressos.size() ;i++) {
System.out.println("=====================");
System.out.println("Eventos Disponiveis: "+evento.get(i).getNomeEvento());
System.out.println("Banda: " + ingressos.get(i).getNome());
System.out.println("Data : "+ingressos.get(i).getData());
System.out.println("Valores de ingressos --> Camarote: "+ingressos.get(i).getVlrCamarote()+",Pista: "+ingressos.get(i).getVlrPista()+",Vip: "+ingressos.get(i).getVlrVip());
System.out.println("Ingressos disponiveis do lote 1: "+ingressos.get(i).getQtd1()+ " ,Lote 2: "+ingressos.get(i).getQtd2());
}
}
}
public void totalIngresso (Integer totalIngresso) {
this.qtdIngresso = totalIngresso;
}
public void verificaQuantidadeDisponivel (String lote, String noBanda) {
if (lote.contentEquals("1")) {
if (controle.size()==0) {
System.out.println("Nenhum ingresso Disponivel!");
}else {
for (int i = 0;i<controle.size();i++) {
if(noBanda.equals(ingressos.get(i).getNome())) {
System.out.println("=====================");
controle.get(i).atualizarVendaLote1();
}
}
}
}
if(lote.contentEquals("2")) {
if (controle.size()==0) {
System.out.println("Nenhum ingresso Disponivel!");
}else {
for (int i = 0;i<controle.size();i++) {
if(noBanda.equals(ingressos.get(i).getNome())) {
System.out.println("=====================");
controle.get(i).atualizarVendaLote2();
}
}
}
}
}
public void vendeIngresso (String lote, String nomeBanda, Integer qtdIngresso, Double vendaIngressos) {
if (lote.contentEquals("1")) {
if (controle.size()==0) {
System.out.println("Nenhum ingresso Disponivel!");
}else {
for (int i = 0;i<controle.size();i++) {
if(nomeBanda.equals(ingressos.get(i).getNome())) {
System.out.println("=====================");
controle.get(i).compraingressoLt1(qtdIngresso);
evento.get(i).financasLucros(vendaIngressos);
}
}
}
}
if(lote.contentEquals("2")) {
if (controle.size()==0) {
System.out.println("Nenhum ingresso Disponivel!");
}else {
for (int i = 0;i<controle.size();i++) {
if(nomeBanda.equals(ingressos.get(i).getNome())) {
System.out.println("=====================");
controle.get(i).compraingressoLt1(qtdIngresso);
evento.get(i).financasLucros(vendaIngressos);
}
}
}
}
}
public void ingressosVendidos () {
this.ingsVendidos += this.ingsVendidos;
}
public List<Evento> getEvento() {
return evento;
}
public void setEvento(List<Evento> evento) {
this.evento = evento;
}
public ArrayList<Ingresso> getIngressos() {
return ingressos;
}
public void setIngressos(ArrayList<Ingresso> ingressos) {
this.ingressos = ingressos;
}
public Ingresso getIngresso() {
return ingresso;
}
public void setIngresso(Ingresso ingresso) {
this.ingresso = ingresso;
}
public Evento getNomeEvento() {
return nomeEvento;
}
public void setNomeEvento(Evento nomeEvento) {
this.nomeEvento = nomeEvento;
}
public int getQtdIngresso() {
return qtdIngresso;
}
public void setQtdIngresso(int qtdIngresso) {
this.qtdIngresso = qtdIngresso;
}
public int getIngsVendidos() {
return ingsVendidos;
}
public void setIngsVendidos(int ingsVendidos) {
this.ingsVendidos = ingsVendidos;
}
public ArrayList<ControleIngresso> getControle() {
return controle;
}
public void setControle(ArrayList<ControleIngresso> controle) {
this.controle = controle;
}
public ControleIngresso getcIngresso() {
return cIngresso;
}
public void setcIngresso(ControleIngresso cIngresso) {
this.cIngresso = cIngresso;
}
}
import java.sql.Date;
public class Ingresso {
private String nome;
private String data;
private String tipoEntrada; // Meia ou inteira
private String setor; // vip, pista, camarote
private double vlrVip;
private double vlrCamarote;
private double vlrPista;
private String tipoPagamento; //cartão ou dinheiro.
private int qtdIngresso;
private int qtd1;
private int qtd2;
public Ingresso() {
}
public void ingressosDisponiveis () {
}
public void lote1 (Integer qtdl1) {
this.qtd1 = qtdl1;
}
public void lote2 (Integer qtdl2) {
this.qtd2 = qtdl2;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public String getTipoEntrada() {
return tipoEntrada;
}
public void setTipoEntrada(String tipoEntrada) {
this.tipoEntrada = tipoEntrada;
}
public String getSetor() {
return setor;
}
public void setSetor(String setor) {
this.setor = setor;
}
public double getVlrVip() {
return vlrVip;
}
public void setVlrVip(double vlrVip) {
this.vlrVip = vlrVip;
}
public double getVlrCamarote() {
return vlrCamarote;
}
public void setVlrCamarote(double vlrCamarote) {
this.vlrCamarote = vlrCamarote;
}
public double getVlrPista() {
return vlrPista;
}
public void setVlrPista(double vlrPista) {
this.vlrPista = vlrPista;
}
public String getTipoPagamento() {
return tipoPagamento;
}
public void setTipoPagamento(String tipoPagamento) {
this.tipoPagamento = tipoPagamento;
}
public int getQtdIngresso() {
return qtdIngresso;
}
public void setQtdIngresso(int qtdIngresso) {
this.qtdIngresso = qtdIngresso;
}
public int getQtd1() {
return qtd1;
}
public void setQtd1(int qtd1) {
this.qtd1 = qtd1;
}
public int getQtd2() {
return qtd2;
}
public void setQtd2(int qtd2) {
this.qtd2 = qtd2;
}
@Override
public String toString() {
return "Ingresso [nome = " + nome + ", data = " + data + ", tipoEntrada=" + tipoEntrada + ", setor = " + setor
+ ", vlrVipv = " + vlrVip + ", vlrCamarote = " + vlrCamarote + ", vlrPista = " + vlrPista + ", tipoPagamento="
+ tipoPagamento + "]";
}
}
public class Show extends Evento {
private Banda apresenta;
public Show (Banda ob) {
this.apresenta = ob;
}
@Override
public void iniciarEvento() {
System.out.println("=====================");
System.out.println("Evento iniciado!");
System.out.println(apresenta.toString());
financas(apresenta.getCache());
}
}
public class ControleIngresso {
private int lote1;
private int lote2;
private int compraLt1;
private int compraLt2;
public void ingressosLote1 (Integer in1) {
this.lote1 = in1;
}
public void ingressosLote2 (Integer in2) {
this.lote2 = in2;
}
public void atualizarVendaLote1() {
this.lote1 -= this.compraLt1;
System.out.println("Ingressos disponiveis lote 1: " + this.lote1);
}
public void atualizarVendaLote2() {
this.lote2 -= this.compraLt2;
System.out.println("Ingressos disponiveis lote 2: " + this.lote2);
}
public void compraingressoLt1 (Integer qtd1) {
this.compraLt1 = qtd1;
}
public void compraingressoLt2 (Integer qtd2) {
this.compraLt2 = qtd2;
}
public int getLote1() {
return lote1;
}
public void setLote1(int lote1) {
this.lote1 = lote1;
}
public int getLote2() {
return lote2;
}
public void setLote2(int lote2) {
this.lote2 = lote2;
}
}
public class Banda {
private String nomeBanda;
private int numIntegrantes;
private String generoMusical;
private int numShows;
private double cache;
public Banda () {
}
public String getNomeBanda() {
return nomeBanda;
}
public void setNomeBanda(String nomeBanda) {
this.nomeBanda = nomeBanda;
}
public int getNumIntegrantes() {
return numIntegrantes;
}
public void setNumIntegrantes(int numIntegrantes) {
this.numIntegrantes = numIntegrantes;
}
public String getGeneroMusical() {
return generoMusical;
}
public void setGeneroMusical(String generoMusical) {
this.generoMusical = generoMusical;
}
public int getNumShows() {
return numShows;
}
public void setNumShows(int numShows) {
this.numShows = numShows;
}
public double getCache() {
return cache;
}
public void setCache(double cache) {
this.cache = cache;
}
@Override
public String toString() {
return "Banda = " + nomeBanda + ", Numero de Integrantes = " + numIntegrantes + ", Genero Musical = "
+ generoMusical + "\n"+ "Numero de shows = " + numShows + ", Cache = R$ " + cache;
}
}
public class Principal {
public static void main(String[] args) {
Banda b = new Banda();
Ingresso i = new Ingresso();
ControleIngresso ci = new ControleIngresso();
ControleIngresso ci1 = new ControleIngresso();
OpVendaIngressos op = new OpVendaIngressos();
b.setNomeBanda("Metalica");
b.setGeneroMusical("Rock");
b.setNumIntegrantes(4);
b.setCache(300.000);
b.setNumShows(500);
i.setNome("Metalica");
i.setData("25/11/2020");
i.setVlrPista(50);
i.setVlrVip(200);
i.setVlrCamarote(150);
ci.setLote1(150);
ci.setLote2(250);
Show s = new Show(b);
s.setNomeEvento("Rock SUL");
s.setQtdPessoas(2000);
s.setDataEvento("25/11/2020");
s.iniciarEvento();
op.cadastrarIngresso(i,s,ci);
GerenciaEventos g = new GerenciaEventos();
g.eventosRealizados();
g.addEvento(s);
Banda b1 = new Banda();
Ingresso i1 = new Ingresso();
b1.setNomeBanda("Exalta Samba");
b1.setGeneroMusical("Samba");
b1.setNumIntegrantes(4);
b1.setCache(3000);
b1.setNumShows(480);
i1.setNome("Exalta Samba");
i1.setData("10/11/2020");
i1.setVlrPista(80);
i1.setVlrVip(180);
i1.setVlrCamarote(200);
i1.setQtdIngresso(1000);
ci1.setLote1(600);
ci1.setLote2(300);
Show s1 = new Show(b1);
s1.setNomeEvento("Samba SUL");
s1.setQtdPessoas(1000);
s1.iniciarEvento();
op.cadastrarIngresso(i1,s1,ci1);
op.listarIngressosCadastrados();
g.addEvento(s1);
op.verificaQuantidadeDisponivel("1","Metalica");
op.verificaQuantidadeDisponivel("2", "Exalta Samba");
op.vendeIngresso("1", "Metalica", 3,450.0);
op.verificaQuantidadeDisponivel("1","Metalica");
g.listarEventosRealizados();
}
}