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:

 Java | 
 copy code |
?
 
001
002
public class Caixa {
003
	private int notas1; // inicializando variáveis.
004
	private int notas2; // inicializando variáveis.
005
	private int notas5; // inicializando variáveis.
006
	private int notas10;// inicializando variáveis.
007
	private int notas20;// inicializando variáveis.
008
	private int notas50;// inicializando variáveis.
009
	private int notas100;//inicializando variáveis.
010
 
011
	public Caixa(int notas1, int notas2, int notas5, int notas10, int notas20, int notas50, int notas100){ //método constutor, aqui o usuario irá passar
012
		this.notas1 = notas1;  //o número de notas de 1
013
		this.notas2 = notas2;  //o número de notas de 2
014
		this.notas5 = notas5;  //o número de notas de 5
015
		this.notas10 = notas10;//o número de notas de 10
016
		this.notas20 = notas20;//o número de notas de 20
017
		this.notas50 = notas50;//o número de notas de 50
018
		this.notas100 = notas100;//o número de notas de 100
019
 
020
	}
021
 
022
 
023
	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.
024
		this.notas1 += notas1;//adiciona as notas de 1 recebida ao montante das mesmas.
025
		this.notas2 += notas2;//adiciona as notas de 2 recebida ao montante das mesmas.
026
		this.notas5 += notas5;//adiciona as notas de 5 recebida ao montante das mesmas.
027
		this.notas10 += notas10;//adiciona as notas de 10 recebida ao montante das mesmas.
028
		this.notas20 += notas20;//adiciona as notas de 20 recebida ao montante das mesmas.
029
		this.notas50 += notas50;//adiciona as notas de 50 recebida ao montante das mesmas.
030
		this.notas100 += notas100;//adiciona as notas de 100 recebida ao montante das mesmas.
031
		int valorPago = notas1 + notas2*2 + notas5*5 + notas10*10+ notas20*20 + notas50*50 + notas100*100;//calcula o valor Pago. 
032
		return forneceTroco(valorPago, valorProduto); //no retorno, ele irá chamar o método fornece troco, para já retornar o troco para o usuário.
033
	}
034
 
035
	private int forneceTroco(int valorPago, int valorProduto){
036
 
037
		if(valorPago > valorProduto){// se o valor pago for maios que o do produto, então haverá troco.
038
			int troco = valorPago - valorProduto;//o troco é a diferença do valor pago menos o valor do produto.
039
			int trocoTemp = troco;//variável temporaria para controle.
040
 
041
			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.
042
				this.notas100 -= trocoTemp/100;//retira as notas de 100 caixa.
043
				trocoTemp -= trocoTemp/100*100;//subtrai o valor já pago da variável de controle, que é o troco que falta.
044
			}
045
			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.
046
				this.notas50 -= trocoTemp/50;//retira as notas de 50 caixa.
047
				trocoTemp -= trocoTemp/50*50;//subtrai o valor já pago da variável de controle, que é o troco que falta.
048
			}
049
			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.
050
				this.notas20 -= trocoTemp/20;//retira as notas de 20 caixa.
051
				trocoTemp -= trocoTemp/20*20;//subtrai o valor já pago da variável de controle, que é o troco que falta.
052
			}
053
			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.
054
				this.notas10 -= trocoTemp/10;//retira as notas de 10 caixa.
055
				trocoTemp -= trocoTemp/10*10;//subtrai o valor já pago da variável de controle, que é o troco que falta.
056
			}
057
			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.
058
				this.notas5 -= trocoTemp/5;//retira as notas de 5 caixa.
059
				trocoTemp -= trocoTemp/5*5;//subtrai o valor já pago da variável de controle, que é o troco que falta.
060
			}
061
			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.
062
				this.notas2 -= trocoTemp/2;//retira as notas de 2 caixa.
063
				trocoTemp -= trocoTemp/2*2;//subtrai o valor já pago da variável de controle, que é o troco que falta.
064
			}
065
			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.
066
				this.notas1 -= trocoTemp/1;//retira as notas de 1 caixa.
067
				trocoTemp -= trocoTemp/1*1;//subtrai o valor já pago da variável de controle, que é o troco que falta.
068
			}
069
 
070
			if(trocoTemp > 0){ //se faltou pagar algum valor,
071
				return 0;// retorna 0.
072
			}else{
073
				return troco;//retorna o valor do troco.
074
			}
075
		}else if(valorPago == valorProduto){//se o usuario pagou o valor exato do produto, não haverá troco,
076
			return -1; //retorna -1.
077
		}else{// senão, ele pagou menos que o valor do produto,
078
			return -2;//retorna -2
079
		}
080
	}
081
 
082
	/**Getters**/
083
 
084
	public int getNotas1() {
085
		return notas1;
086
	}
087
 
088
	public int getNotas2() {
089
		return notas2;
090
	}
091
 
092
	public int getNotas5() {
093
		return notas5;
094
	}
095
 
096
	public int getNotas10() {
097
		return notas10;
098
	}
099
 
100
	public int getNotas20() {
101
		return notas20;
102
	}
103
 
104
	public int getNotas50() {
105
		return notas50;
106
	}
107
 
108
	public int getNotas100() {
109
		return notas100;
110
	}
111
 
112
}
113

Main:

 Java | 
 copy code |
?
 
01
02
public class Main {
03
	public static void main(String[] args) {
04
 
05
		Caixa caixa = new Caixa(5,5,5,5,5,5,5);//instancia o caixa, com a qtde de notas de cada valor.
06
		int troco = caixa.recebePagamento(377, 0, 0, 0, 0, 0, 0, 5);// faz o pagamento, sendo que o primeiro valor é o valor do produto.
07
 
08
		if(troco == -1){ //se troco é -1, então é pq o usuário pagou o valor exato.
09
			System.out.println("O troco é de R
,00");
10
		}else if(troco == 0){//se troco é 0, então é pq o caixa não possui o troco.
11
			System.out.println("O caixa não possui troco.");
12
		}else if(troco == -2){//se troco é -2, é pq o usuário pagou menos do que deveria.
13
			System.out.println("O cliente pagou menos do que deveria.");
14
		}else{
15
			System.out.println("O troco foi de R$"+troco+",00");// imprime o troco total.
16
		}
17
		System.out.println("Você ainda possui:\n"+caixa.getNotas1()+" notas de R2\n" + //imprime a qtde restante de notas  de 1
18
				caixa.getNotas2()+" notas de R\n" + //imprime a qtde restante de notas  de 2
19
				caixa.getNotas5()+" notas de R\n" + //imprime a qtde restante de notas  de 5
20
				caixa.getNotas10()+" notas de R\n" + //imprime a qtde restante de notas  de 10
21
				caixa.getNotas20()+" notas de R\n" + //imprime a qtde restante de notas  de 20
22
				caixa.getNotas50()+" notas de R\n" + //imprime a qtde restante de notas  de 50
23
				caixa.getNotas100()+" notas de R0"); //imprime a qtde restante de notas  de 100
24
	}
25
}
26

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

}

}