Respondendo dúvida do Mateus
Bom, o Mateus me fez a seguinte pergunta: “De qualquer forma, tenho um exercício programa em Java, e também tô meio perdidinho… preciso montar uma classe caixa com o método recebePagamento (foi fácil de fazer), e com mais outro, que tá complicando, que é o forneceTroco… esse método tem que receber o número de notas e devolver o troco preferencialmente com as notas mais altas. Aqui explica melhor:
“Classe Caixa:
Esta classe modela o fluxo de caixa do teatro. Tem como tarefa gerenciar a quantidade
de notas de 1, 5, 10, 20, 50 e 100 reais. Para isso, deve receber pagamentos e fornecer
trocos.
A classe Caixa deve implementar pelo menos os seguintes métodos:
*recebePagamento (notas1, notas5, notas10, notas20, notas50, notas100):
onde notasX é quantidade de notas X recebidas (X sendo 1, 5, 10, 20, 50 ou
100).
*forneceTroco(valor): se há o valor do troco pedido no caixa, retira do caixa as
notas necessárias para o troco (decrementa os contadores das notas) e retorna
o valor 1, que significará que o troco foi feito com sucesso. O cálculo do troco
deve sempre dar preferência para as notas de valores mais altos. Se não houver
o valor do troco no caixa, então exibe mensagem informando o fato e retorna o
valor zero, que significará que houve falha no troco.
Você tem alguma idéia de como fazê-lo, cara?
Se possível, não use conceitos muito avançados, porque eu tive uns 3 meses de Java até agora… de qualquer forma, qualquer coisa que você possa me dar um apoio, já fico extremamente grato!!!
Obrigado! “
Tá certo Mateus, fiz uma classe Caixa como você falou. Seguindo o padrão das minhas respostas, fiz a classe Main simulando as transações e comentei ao lado de cada linha. Espero que você entenda minha lógica, qualquer dúvida pode postar um comentário que esclareço. Abaixo temos as duas Classes:
Caixa:
public class Caixa {
private int notas1; // inicializando variáveis.
private int notas2; // inicializando variáveis.
private int notas5; // inicializando variáveis.
private int notas10;// inicializando variáveis.
private int notas20;// inicializando variáveis.
private int notas50;// inicializando variáveis.
private int notas100;//inicializando variáveis.
public Caixa(int notas1, int notas2, int notas5, int notas10, int notas20, int notas50, int notas100){ //método constutor, aqui o usuario irá passar
this.notas1 = notas1; //o número de notas de 1
this.notas2 = notas2; //o número de notas de 2
this.notas5 = notas5; //o número de notas de 5
this.notas10 = notas10;//o número de notas de 10
this.notas20 = notas20;//o número de notas de 20
this.notas50 = notas50;//o número de notas de 50
this.notas100 = notas100;//o número de notas de 100
}
public int recebePagamento(int valorProduto, int notas1, int notas2, int notas5, int notas10, int notas20, int notas50, int notas100){ //adicionei o valor do produto, pois para o troco é preciso o produto ter um valor.
this.notas1 += notas1;//adiciona as notas de 1 recebida ao montante das mesmas.
this.notas2 += notas2;//adiciona as notas de 2 recebida ao montante das mesmas.
this.notas5 += notas5;//adiciona as notas de 5 recebida ao montante das mesmas.
this.notas10 += notas10;//adiciona as notas de 10 recebida ao montante das mesmas.
this.notas20 += notas20;//adiciona as notas de 20 recebida ao montante das mesmas.
this.notas50 += notas50;//adiciona as notas de 50 recebida ao montante das mesmas.
this.notas100 += notas100;//adiciona as notas de 100 recebida ao montante das mesmas.
int valorPago = notas1 + notas2*2 + notas5*5 + notas10*10+ notas20*20 + notas50*50 + notas100*100;//calcula o valor Pago.
return forneceTroco(valorPago, valorProduto); //no retorno, ele irá chamar o método fornece troco, para já retornar o troco para o usuário.
}
private int forneceTroco(int valorPago, int valorProduto){
if(valorPago > valorProduto){// se o valor pago for maios que o do produto, então haverá troco.
int troco = valorPago - valorProduto;//o troco é a diferença do valor pago menos o valor do produto.
int trocoTemp = troco;//variável temporaria para controle.
if(trocoTemp/100 > 0 && this.notas100 > 0){//verifica se o troco precisa de notas de 100, e se existem notas de 100 disponiveis no caixa.
this.notas100 -= trocoTemp/100;//retira as notas de 100 caixa.
trocoTemp -= trocoTemp/100*100;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp/50 > 0 && this.notas50 >0){//verifica se o troco precisa de notas de 50, e se existem notas de 50 disponiveis no caixa.
this.notas50 -= trocoTemp/50;//retira as notas de 50 caixa.
trocoTemp -= trocoTemp/50*50;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp/20 > 0 && this.notas20 >0){//verifica se o troco precisa de notas de 20, e se existem notas de 20 disponiveis no caixa.
this.notas20 -= trocoTemp/20;//retira as notas de 20 caixa.
trocoTemp -= trocoTemp/20*20;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp/10 > 0 && this.notas10 >0){//verifica se o troco precisa de notas de 10, e se existem notas de 10 disponiveis no caixa.
this.notas10 -= trocoTemp/10;//retira as notas de 10 caixa.
trocoTemp -= trocoTemp/10*10;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp/5 > 0 && this.notas5 >0){//verifica se o troco precisa de notas de 5, e se existem notas de 5 disponiveis no caixa.
this.notas5 -= trocoTemp/5;//retira as notas de 5 caixa.
trocoTemp -= trocoTemp/5*5;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp/2 > 0 && this.notas2 >0){//verifica se o troco precisa de notas de 2, e se existem notas de 2 disponiveis no caixa.
this.notas2 -= trocoTemp/2;//retira as notas de 2 caixa.
trocoTemp -= trocoTemp/2*2;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp/1 > 0 && this.notas1 >0){//verifica se o troco precisa de notas de 1, e se existem notas de 1 disponiveis no caixa.
this.notas1 -= trocoTemp/1;//retira as notas de 1 caixa.
trocoTemp -= trocoTemp/1*1;//subtrai o valor já pago da variável de controle, que é o troco que falta.
}
if(trocoTemp > 0){ //se faltou pagar algum valor,
return 0;// retorna 0.
}else{
return troco;//retorna o valor do troco.
}
}else if(valorPago == valorProduto){//se o usuario pagou o valor exato do produto, não haverá troco,
return -1; //retorna -1.
}else{// senão, ele pagou menos que o valor do produto,
return -2;//retorna -2
}
}
/**Getters**/
public int getNotas1() {
return notas1;
}
public int getNotas2() {
return notas2;
}
public int getNotas5() {
return notas5;
}
public int getNotas10() {
return notas10;
}
public int getNotas20() {
return notas20;
}
public int getNotas50() {
return notas50;
}
public int getNotas100() {
return notas100;
}
}
Main:
public class Main {
public static void main(String[] args) {
Caixa caixa = new Caixa(5,5,5,5,5,5,5);//instancia o caixa, com a qtde de notas de cada valor.
int troco = caixa.recebePagamento(377, 0, 0, 0, 0, 0, 0, 5);// faz o pagamento, sendo que o primeiro valor é o valor do produto.
if(troco == -1){ //se troco é -1, então é pq o usuário pagou o valor exato.
System.out.println("O troco é de R$0,00");
}else if(troco == 0){//se troco é 0, então é pq o caixa não possui o troco.
System.out.println("O caixa não possui troco.");
}else if(troco == -2){//se troco é -2, é pq o usuário pagou menos do que deveria.
System.out.println("O cliente pagou menos do que deveria.");
}else{
System.out.println("O troco foi de R$"+troco+",00");// imprime o troco total.
}
System.out.println("Você ainda possui:\n"+caixa.getNotas1()+" notas de R$1\n" + //imprime a qtde restante de notas de 1
caixa.getNotas2()+" notas de R$2\n" + //imprime a qtde restante de notas de 2
caixa.getNotas5()+" notas de R$5\n" + //imprime a qtde restante de notas de 5
caixa.getNotas10()+" notas de R$10\n" + //imprime a qtde restante de notas de 10
caixa.getNotas20()+" notas de R$20\n" + //imprime a qtde restante de notas de 20
caixa.getNotas50()+" notas de R$50\n" + //imprime a qtde restante de notas de 50
caixa.getNotas100()+" notas de R$100"); //imprime a qtde restante de notas de 100
}
}
Atualizando, como continua com dúvida:
Então Mateus, a classe Caixa te ajudei com os algoritmos. Acredito que você já tenha entendido mais ou menos o conceito. Então dessa vez irei dar o empurrão inicial e ver se você consegue caminhar com as próprias pernas. Eu teria projetado diferente as classes e os métodos, mas vou fazer como está pedido. Vou fazer a classe Setor, e vamos ver se você consegue implementar a classe vendedor, que não parece muito difícil.
public class Setor {
private int codigo = 0;
private int capacidade = 0;
private int preco = 0;
private int disponibilidade;
public void abreSetor(int codigo,int capacidade,int preco){
this.codigo = codigo; //estamos setando o código passado para o código global da classe.
this.capacidade = capacidade;//estamos setando a capacidade passado para a capacidade global da classe.
this.preco = preco;//estamos setando o preço passado para o preço global da classe.
this.disponibilidade = capacidade;//quando inicializado, a capacidade é igual à disponibilidade.
}
public void reservaLugar(int quantidade){
this.disponibilidade -= quantidade;//decrementa quantidade da disponibilidade.
}
public int capacidadeSetor(){
return this.capacidade;//retorna a capacidade.
}
public int disponibilidade(){
return this.disponibilidade;//retorna a disponibilidade.
}
}
A dúvida persiste, então vamos lá!
A classe Vendendor seria sua classe main, aqui acho que só faltaria você imprimir o relatório:
Desculpe a formatação, mas meu plugin que fazia isso deu problema, estou trabalhando em consertá-lo.
public class Vendedor {
static Setor camarote = new Setor();//instancia o camarote
static Setor frente = new Setor();//instancia a frente
static Setor meio = new Setor();//instancia o meio
static Setor fundo = new Setor();//instancia o fundo
public static void main(String[] args) {
Caixa caixa = abreCaixa(5, 5, 5, 5, 5, 5, 5);
abreTeatro(1, 50, 300, 2, 100, 200, 3, 150, 100, 4, 100, 75);
vendeIngresso(caixa, 5, 1, 4, 1, 5, 4, 1, 3, 2);
}
public static Caixa abreCaixa(int notas1, int notas2, int notas5, int notas10, int notas20, int notas50, int notas100){
Caixa caixa = new Caixa(notas1,notas2,notas5,notas10,notas20,notas50,notas100);
return caixa;
}
public static void abreTeatro(int codigoCamarote,int capacidadeCamarote,int precoCamarote,
int codigoFrente,int capacidadeFrente,int precoFrente,
int codigoMeio,int capacidadeMeio,int precoMeio,
int codigoFundo,int capacidadeFundo,int precoFundo){
camarote.abreSetor(codigoCamarote, capacidadeCamarote, precoCamarote);//e seta seus atributos
frente.abreSetor(codigoFrente, capacidadeFrente, precoFrente);//e seta seus atributos
meio.abreSetor(codigoMeio, capacidadeMeio, precoMeio);//e seta seus atributos
fundo.abreSetor(codigoFundo, capacidadeFundo, precoFundo);//e seta seus atributos
}
public static void vendeIngresso(Caixa caixa, int quantidade,int codigoSetor,int notas1, int notas2, int notas5,int notas10,int notas20,int
notas50,int notas100){
int troco = 0;
switch(codigoSetor){
case 1:
troco = caixa.recebePagamento(camarote.getPreco(), notas1, notas2, notas5, notas10, notas20, notas50, notas100);
break;
case 2:
troco = caixa.recebePagamento(camarote.getPreco(), notas1, notas2, notas5, notas10, notas20, notas50, notas100);
break;
case 3:
troco = caixa.recebePagamento(camarote.getPreco(), notas1, notas2, notas5, notas10, notas20, notas50, notas100);
break;
case 4:
troco = caixa.recebePagamento(camarote.getPreco(), notas1, notas2, notas5, notas10, notas20, notas50, notas100);
break;
}
System.out.println(“Troco de “+troco);//aqui você faz aquelas validações do Main
}
}
Nossa cara, muito bom mesmo! Gostei muito da sua lógica, algo na linha que eu estava pensando… ainda assim, seus métodos ficaram muito bem explicados! A minha grande dúvida estava pa parte de fornecer o troco… não conseguia bolar um algoritmo pra tal, mas você solucionou minhas dúvidas!
De qualquer forma, cara, você pode me dizer o que são exatamente ‘Getters’?
Agradeço de antemão!
Então, se você observar, os membros da minha classe(notas1,notas2, etc.) estão como private. Logo eles não podem ser acessados pela classe Main. Então o que se faz são os métodos get e set, para pegar o valor ou setar, respectivamente. Como eu não tenho interesse de setar esses valores, pois uma vez iniciados não podem ser alterados, fiz apenas os gets. Se você entrar em http://www.tiexpert.net/ver.php?page=132 você poderá encontrar uma pequena explicação deles.
Ah, e mais uma coisa: nesse mesmo exercício, eu também devo criar uma classe Vendedor que instancia objetos da classe Caixa e chamar métodos para os seus atributos. Em outras palavras, essa classe é literalmente o vendedor, pois ela quem lida com o caixa… sendo assim, que método(s) da classe Caixa eu devo utilizar a fim de fazer os cálculos necessários na classe Vendedor? Creio que ‘Main’ seria um exemplo disso, né?
Desculpe-me a ignorância, mas meu Java ainda não é dos melhores…
De qualquer forma, agradeço mesmo, colega!
Exatamente, Main seria quem manipularia as transações.
Muito bem então! E por que outro ‘comando’ eu poderia substituir os getters? Eu poderia colocá-los num método void?
Então, os métodos getters precisam retornar o mesmo tipo que o objeto. E não é usual substituí-los por nenhum outro métodos. Pois foi convencionado que eles seriam get e set.
Cara, eu entendi perfeitamente os algoritmos e a lógica utilizada por você… minha principal dúvida, é em como instanciar os objetos de Setor e Caixa em Vendedor… eu até tentei, mas fico meio perdido no momento de criar os objetos… se você puder me dar uma dica ou um exemplozinho de um método qualquer dentro de Vendedor, eu creio que possa realizar o resto…
Mais uma dúvida:
Por que você igualou três dos quatro atributos a zero?
Na verdade eram os 4, apenas para zera-los, para não correr o risco da memória setar outro número para eles.
Nossa, então tal risco existe? E por que a memória faria isto?
Desculpa cara, troquei as bolas. O que vai acontecer se você não inicializar a variável é que o programa não vai compilar. Esse lance da memória é no C.