Trabalho caixa eletronico

public class RecipenteDeNotas {
    private final int valor;
    private int quantidade = 0;

    public RecipenteDeNotas(int valor) {
        this.valor = valor;
    }
    
    public RecipenteDeNotas(int valor, int quantidade) {
        this.valor = valor;
        this.quantidade = quantidade;
    }

    public int getValor() {
        return valor;
    }
    
    public int getQuantidade() {
        return quantidade;
    }
    
    public boolean hasNotas() {
        return quantidade > 0;
    }
    
    /**
     * retira certa quantidade de notas do recipentes, e 
     * retorna o valor total das notas retiradas
     * @param quantidade Números de notas a serem retiradas.
     * @return o valor total das notas retiradas.
     */
    public int retirarNotas(int quantidade) {
        if (this.quantidade < quantidade)
                throw new RuntimeException("Não há notas suficientes de " + valor +" no recipente");
        this.quantidade = this.quantidade - quantidade;
        return quantidade * valor;
    }
    
     /**
     * deposita certa quantidade de notas no recipentes, e 
     * retorna o valor total das notas depositadas
     * @param quantidade Números de notas a serem retiradas.
     * @return o valor total das notas retiradas.
     */ 
    public int depositarNotas(int quantidade) {
        this.quantidade = this.quantidade + quantidade;
        return quantidade * valor;
    }
}

RecipenteDeNotas notasDe100 = new RecipenteDeNotas(100,2);
RecipenteDeNotas notasDe50 = new RecipenteDeNotas(50,10);
RecipenteDeNotas notasDe20 = new RecipenteDeNotas(20,7);
RecipenteDeNotas notasDe10 = new RecipenteDeNotas(10,6);
RecipenteDeNotas notasDe5 = new RecipenteDeNotas(5,9);
RecipenteDeNotas notasDe2 = new RecipenteDeNotas(2,14);
RecipenteDeNotas notasDe1 = new RecipenteDeNotas(1,33);

public class CaixaDeRecipentes {
    private final RecipenteDeNotas recipienteDe100 = new RecipenteDeNotas(100);
    private final RecipenteDeNotas recipienteDe50 = new RecipenteDeNotas(50);
    private final RecipenteDeNotas recipienteDe20 = new RecipenteDeNotas(20);
    private final RecipenteDeNotas recipienteDe10 = new RecipenteDeNotas(10);
    private final RecipenteDeNotas recipienteDe5 = new RecipenteDeNotas(5);
    private final RecipenteDeNotas recipienteDe2 = new RecipenteDeNotas(2);
    private final RecipenteDeNotas recipienteDe1 = new RecipenteDeNotas(1);

    public RecipenteDeNotas getRecipiente(int valor) {
        switch(valor) {
            case 100:
                return recipienteDe100;
            case 50:
                return recipienteDe50;
            case 20:
                return recipienteDe20;
            case 10:
                return recipienteDe10;
            case 5:
                return recipienteDe5;
            case 2:
                return recipienteDe2;
            case 1:
                return recipienteDe1;
            default:
                throw new RuntimeException("Não existe notas de " + valor);
        }
    }

    /**
     * Quantidade de notas do valor passado.
     * @param valor da nota
     * @return
     */
    public int getQuantidade(int valor) {
        return getRecipiente(valor).getQuantidade();
    }

    /**
     * Se existe notas do valor passado.
     * @param valor da nota
     * @return
     */
    public boolean hasNotas(int valor) {
        return getRecipiente(valor).hasNotas();
    }

    /**
     * retira certa quantidade de notas do recipentes, e
     * retorna o valor total das notas retiradas
     * @param valor Valor da nota a ser retirada
     * @param quantidade Números de notas a serem retiradas.
     * @return o valor total das notas retiradas.
     */
    public int retirarNotas(int valor,int quantidade) {
        return getRecipiente(valor).retirarNotas(quantidade);
    }

     /**
     * deposita certa quantidade de notas no recipentes, e
     * retorna o valor total das notas depositadas
     * @param valor Valor da nota a ser depositada
     * @param quantidade Números de notas a serem depositadas.
     * @return o valor total das notas depositadas.
     */
    public int depositarNotas(int valor,int quantidade) {
        return getRecipiente(valor).depositarNotas(quantidade);
    }

    public int calcularValorTotal() {
        return
            getRecipiente(100).getQuantidade()*100 +
            getRecipiente(50).getQuantidade()*50 +
            getRecipiente(20).getQuantidade()*20 +
            getRecipiente(10).getQuantidade()*10 +
            getRecipiente(5).getQuantidade()*5 +
            getRecipiente(2).getQuantidade()*2 +
            getRecipiente(1).getQuantidade()*1;
    }

    public String toString() {
        String result = "Valor total de " + calcularValorTotal();
        result += "\n em " + getRecipiente(100).getQuantidade() +" notas de 100 " ;
        result += "e " + getRecipiente(50).getQuantidade() +" nota(s) de 50 " ;
        result += "e " + getRecipiente(20).getQuantidade() +" nota(s) de 20 " ;
        result += "e " + getRecipiente(10).getQuantidade() +" nota(s) de 10 " ;
        result += "e " + getRecipiente(5).getQuantidade() +" nota(s) de 5 " ;
        result += "e " + getRecipiente(2).getQuantidade() +" nota(s) de 2 " ;
        result += "e " + getRecipiente(1).getQuantidade() +" nota(s) de 1 " ;

        return result;
    }
    
    public void zerarRecipientes() {
        retirarNotas(100, getQuantidade(100));
        retirarNotas(50, getQuantidade(50));
        retirarNotas(20, getQuantidade(20));
        retirarNotas(10, getQuantidade(10));
        retirarNotas(5, getQuantidade(5));
        retirarNotas(2, getQuantidade(2));
        retirarNotas(1, getQuantidade(1));
    }
}

public class CaixaEletronicoApp{

    private static final CaixaDeRecipentes CAIXA_ELETRONICO = new CaixaDeRecipentes();
    static {
        CAIXA_ELETRONICO.depositarNotas(100,2); //2 notas de 100 reais
        CAIXA_ELETRONICO.depositarNotas(50,10); //10 notas de 50 reais
        CAIXA_ELETRONICO.depositarNotas(20,7); //7 notas de 20 reais
        CAIXA_ELETRONICO.depositarNotas(10,6); //6 notas de 10 reais
        CAIXA_ELETRONICO.depositarNotas(5,9); //9 notas de 5 reais
        CAIXA_ELETRONICO.depositarNotas(2,14); //14 notas de 2 reais
        CAIXA_ELETRONICO.depositarNotas(1,33); //33 notas de 1 real
    }

    public static void main(String[] args) {
        CaixaDeRecipentes saqueDoJoao = new CaixaDeRecipentes();
        int retirada = 339;
        int valorRestante = redistribuirCedulas(retirada, saqueDoJoao);
        if (valorRestante != 0) {
            extorno(saqueDoJoao);
            System.out.println("Não há notas suficientes para realizar a operação");
        } else
            System.out.println(saqueDoJoao);
    }

    public static int redistribuirCedulas(int retirada, CaixaDeRecipentes caixaCliente) {
        int valorRestante = retirada;
        valorRestante = valorRestante - retirarNotas(100, valorRestante, caixaCliente);
        valorRestante = valorRestante - retirarNotas(50 , valorRestante, caixaCliente);
        valorRestante = valorRestante - retirarNotas(20 , valorRestante, caixaCliente);
        valorRestante = valorRestante - retirarNotas(10 , valorRestante, caixaCliente);
        valorRestante = valorRestante - retirarNotas(5  , valorRestante, caixaCliente);
        valorRestante = valorRestante - retirarNotas(2  , valorRestante, caixaCliente);
        valorRestante = valorRestante - retirarNotas(1  , valorRestante, caixaCliente);
        return valorRestante;
    }

   public static int retirarNotas(int nota, int valorRestante, CaixaDeRecipentes caixaCliente) {
        int notasNecessarias = (int)valorRestante/nota;
        int notasNoCaixaEletronico = CAIXA_ELETRONICO.getRecipiente(nota).getQuantidade();
        int quantidade = (notasNecessarias > notasNoCaixaEletronico) ? notasNoCaixaEletronico : notasNecessarias;

        CAIXA_ELETRONICO.retirarNotas(nota,quantidade);
        return caixaCliente.depositarNotas(nota,quantidade);
    }

    public static void extorno(CaixaDeRecipentes caixaCliente) {
        CAIXA_ELETRONICO.depositarNotas(100, caixaCliente.getQuantidade(100));
        CAIXA_ELETRONICO.depositarNotas(50, caixaCliente.getQuantidade(50));
        CAIXA_ELETRONICO.depositarNotas(20, caixaCliente.getQuantidade(20));
        CAIXA_ELETRONICO.depositarNotas(10, caixaCliente.getQuantidade(10));
        CAIXA_ELETRONICO.depositarNotas(5, caixaCliente.getQuantidade(5));
        CAIXA_ELETRONICO.depositarNotas(2, caixaCliente.getQuantidade(2));
        CAIXA_ELETRONICO.depositarNotas(1, caixaCliente.getQuantidade(1));
        caixaCliente.zerarRecipientes();
    }
}

"Valor total de 339
em 2 notas de 100 e 2 nota(s) de 50 e 1 nota(s) de 20 e 1 nota(s) de 10 e 1 nota(s) de 5 e 2 nota(s) de 2 e 0 nota(s) de 1"

public class CaixaDeRecipentes {  
    private final RecipenteDeNotas recipienteDe100 = new RecipenteDeNotas(100);  
    private final RecipenteDeNotas recipienteDe50 = new RecipenteDeNotas(50);  
    private final RecipenteDeNotas recipienteDe20 = new RecipenteDeNotas(20);  
    private final RecipenteDeNotas recipienteDe10 = new RecipenteDeNotas(10);  
    private final RecipenteDeNotas recipienteDe5 = new RecipenteDeNotas(5);  
    private final RecipenteDeNotas recipienteDe2 = new RecipenteDeNotas(2);  
    private final RecipenteDeNotas recipienteDe1 = new RecipenteDeNotas(1);  
  
    public RecipenteDeNotas getRecipiente(int valor) {  
        switch(valor) {  
            case 100:  
                return recipienteDe100;  
            case 50:  
                return recipienteDe50;  
            case 20:  
                return recipienteDe20;  
            case 10:  
                return recipienteDe10;  
            case 5:  
                return recipienteDe5;  
            case 2:  
                return recipienteDe2;  
            case 1:  
                return recipienteDe1;  
            default:  
                throw new RuntimeException("Não existe notas de " + valor);  
        }  
    }

//... parte que não altera no meio da solução

    public int calcularValorTotal() {  
        return  
            getRecipiente(100).getQuantidade()*100 +  
            getRecipiente(50).getQuantidade()*50 +  
            getRecipiente(20).getQuantidade()*20 +  
            getRecipiente(10).getQuantidade()*10 +  
            getRecipiente(5).getQuantidade()*5 +  
            getRecipiente(2).getQuantidade()*2 +  
            getRecipiente(1).getQuantidade()*1;  
    }  
  
    public String toString() {  
        String result = "Valor total de " + calcularValorTotal();  
        result += "\n em " + getRecipiente(100).getQuantidade() +" notas de 100 " ;  
        result += "e " + getRecipiente(50).getQuantidade() +" nota(s) de 50 " ;  
        result += "e " + getRecipiente(20).getQuantidade() +" nota(s) de 20 " ;  
        result += "e " + getRecipiente(10).getQuantidade() +" nota(s) de 10 " ;  
        result += "e " + getRecipiente(5).getQuantidade() +" nota(s) de 5 " ;  
        result += "e " + getRecipiente(2).getQuantidade() +" nota(s) de 2 " ;  
        result += "e " + getRecipiente(1).getQuantidade() +" nota(s) de 1 " ;  
  
        return result;  
    }  
      
    public void zerarRecipientes() {  
        retirarNotas(100, getQuantidade(100));  
        retirarNotas(50, getQuantidade(50));  
        retirarNotas(20, getQuantidade(20));  
        retirarNotas(10, getQuantidade(10));  
        retirarNotas(5, getQuantidade(5));  
        retirarNotas(2, getQuantidade(2));  
        retirarNotas(1, getQuantidade(1));  
    }

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

public class CaixaDeRecipentes  {
    private final SortedMap<Integer, RecipenteDeNotas> recipientes;

    public CaixaDeRecipentes() {
         recipientes = new TreeMap<Integer, RecipenteDeNotas>();
         recipientes.put(100, new RecipenteDeNotas(100));
         recipientes.put(50 , new RecipenteDeNotas(50 ));
         recipientes.put(20 , new RecipenteDeNotas(20 ));
         recipientes.put(10 , new RecipenteDeNotas(10 ));
         recipientes.put(5  , new RecipenteDeNotas(5  ));
         recipientes.put(2  , new RecipenteDeNotas(2  ));
         recipientes.put(1  , new RecipenteDeNotas(1  ));

    }
    public RecipenteDeNotas getRecipiente(int valor) {
        if (!recipientes.containsKey(valor))
            throw new RuntimeException("Não existe notas de " + valor);
        return recipientes.get(valor);
    }
    
    /**
     * Retorna a lista de recipientes em ordem decrescente
     * @return
     */
    public List<RecipenteDeNotas> getRecipientes() {
        List<RecipenteDeNotas> list = new ArrayList<RecipenteDeNotas>(recipientes.values());
        Collections.reverse(list);
        return list;
    }
    /**
     * Retorna a lista de notas em ordem descrecente
     * @return
     */
    public List<Integer> getNotas() {
        List<Integer> list = new ArrayList<Integer>(recipientes.keySet());
        Collections.reverse(list);
        return list;
    }

//... parte que não altera no meio da solução

    public int calcularValorTotal() {
        int valorTotal = 0;
        for (RecipenteDeNotas recipiente : getRecipientes())
            valorTotal = valorTotal + recipiente.getValor() * recipiente.getQuantidade();
        return  valorTotal;
    }  
  
    public String toString() {  
        String result = "Valor total de R$ " + calcularValorTotal();
        for (RecipenteDeNotas recipiente : getRecipientes())
             result += "\n" + recipiente.getQuantidade() +" nota(s) de " + recipiente.getValor();
        return result;
    }
      
    public void zerarRecipientes() {  
        for (Integer nota : getNotas())
             retirarNotas(nota, getQuantidade(nota));
    }
}

public static void extorno(CaixaDeRecipentes caixaCliente) {
        for(RecipenteDeNotas recipiente : caixaCliente.getRecipientes()) 
              CAIXA_ELETRONICO.depositarNotas(recipiente.getValor(), recipiente.getQuantidade());
        caixaCliente.zerarRecipientes();  
    }

public static int redistribuirCedulas(int retirada, CaixaDeRecipentes caixaCliente) {  
        int valorRestante = retirada;  
        for(Integer valorDaNota : caixaCliente.getNotas())
              valorRestante = valorRestante - retirarNotas(valorDaNota, valorRestante, caixaCliente);
        return valorRestante;
    }

public class CaixaEletronico {
    private static final CaixaDeRecipentes CAIXA_ELETRONICO = new CaixaDeRecipentes();
    static {
        CAIXA_ELETRONICO.depositarNotas(100,2); //2 notas de R$ 100,00
        CAIXA_ELETRONICO.depositarNotas(50,10); //10 notas de R$ 50,00
        CAIXA_ELETRONICO.depositarNotas(20,7); //7 notas de R$ 20,00
        CAIXA_ELETRONICO.depositarNotas(10,6); //6 notas de R$ 10,00
        CAIXA_ELETRONICO.depositarNotas(5,9); //9 notas de R$ 5,00
        CAIXA_ELETRONICO.depositarNotas(2,14); //14 notas de R$ 2,00
        CAIXA_ELETRONICO.depositarNotas(1,33); //33 notas de R$ 1,00
    }

    public static void main(String[] args) {
        CaixaDeRecipentes saqueDoJoao = new CaixaDeRecipentes(); //recipiente para receber as cedulas
        int valorDoSaque = 338; //R$ 338,00
        int valorPendente = CAIXA_ELETRONICO.transfereCedulas(valorDoSaque, saqueDoJoao);
        if (valorPendente != 0) { //se não houve cedulas suficientes para o saque
            CAIXA_ELETRONICO.extornar(saqueDoJoao);
            System.out.println("Não há notas suficientes para realizar a operação");
        } else
            System.out.println("Saque realizado com sucesso");

        System.out.println("Notas entregues ao cliente");
        System.out.println(saqueDoJoao);
        System.out.println();
        System.out.println("Notas restantes no caixa eletronico");
        System.out.println(CAIXA_ELETRONICO);
    }
}

Saque realizado com sucesso
Notas entregues ao cliente
Valor total de R$ 338
2 nota(s) de R$ 100,00
2 nota(s) de R$ 50,00
1 nota(s) de R$ 20,00
1 nota(s) de R$ 10,00
1 nota(s) de R$ 5,00
1 nota(s) de R$ 2,00
1 nota(s) de R$ 1,00

Notas restantes no caixa eletronico
Valor total de R$ 668
0 nota(s) de R$ 100,00
8 nota(s) de R$ 50,00
6 nota(s) de R$ 20,00
5 nota(s) de R$ 10,00
8 nota(s) de R$ 5,00
13 nota(s) de R$ 2,00
32 nota(s) de R$ 1,00