Ciao a tutti ragazzi.
Avrei bisogno di qualche dritta su come implementare un metodo di un esercizio.

Il metodo che mi interessa si chiama Soldi sub(Soldi s1, Soldi s2) ed è un quesito di un esercizio che vi riporto a seguito prima di postarvi il codice che ho scritto

la traccia è un piccolo papello.....

Esercizio 1. (package poo.soldi)
Una classe Denaro è associata ad una specifica moneta o banconota in euro. Attributi di un oggetto Denaro sono: il suo valore (es. 10.00 per una banconota da dieci euro) e la sua quantità, ossia il numero dei pezzi disponibili di quel valore.
I possibili valori sono quelli correntemente in circolazione ovvero: 0.01, 0.02, 0.05, 0.10, 0.20, 0.50, 1.00, 2.00, 5.00, 10.00, 20.00, 50.00, 100.0, 200.00 e 500.00. Se tenta di creare un oggetto Denaro di un taglio differente occorre sollevare un’opportuna eccezione.
La classe Denaro implementa l’interfaccia Comparable con il criterio che d1 precede d2 se il valore di d1 è maggiore di quello di d2. La classe Denaro offre (almeno) i seguenti metodi: costruttori, getValore(), getQuantita(), setQuantita(...), equals(), toString(), hashCode().
Un’interfaccia Soldi modella una somma di denaro in euro rappresentata da una collezione ordinata di oggetti Denaro. L’interfaccia estende Comparable e Iterable ed esporta i seguenti metodi:
• double totale(), che ritorna il valore complessivo della somma di denaro;
• void add(Denaro d), che aggiunge alla somma di denaro (this) il contenuto dell’oggetto d ricevuto come parametro;
• void add(Soldi s), che aggiunge alla somma di denaro this la somma di denaro s ricevuta come parametro;
• Soldi sub(Soldi s1, Soldi s2), che effettua un “pagamento” s1 con una somma s2. In particolare il metodo aggiunge alla somma di denaro this la somma s2 e restituisce un oggetto Soldi contenente la differenza esatta (resto) “s2-s1” prelevandola dalla somma this. Attenzione che l’oggetto Soldi da restituire deve essere costituito dal minimo numero di oggetti Denaro sulla base di quelli disponibili in this. In più, se non è possibile restituire la differenza esatta, il metodo si deve concludere con una runtime exception lasciando inalterato lo stato dell’oggetto this. Il metodo solleva un’ulteriore eccezione se il totale di s2 è più piccolo del totale di s1.


Ecco quello che ho fatto (Il codice del metodo che non ho capito è alla fine) :

codice:
package poo.soldi;
import java.util.*;


public class Denaro implements Comparable<Denaro> {
	
	private double Valore;
	private int quantità;
	
	public Denaro(double Valore, int quantità){
		
		if(Valore!=0.01 && Valore!=0.02 && Valore!=0.05 && Valore!=0.10 && Valore!=0.20 && Valore!=0.50 && Valore!=1.00 && Valore!=2.00 && Valore!=5.00 && Valore!=10.00 && Valore!=20.00 && Valore!=50.00 && Valore!=100.00 && Valore!=200.00 && Valore!=500.00){
			throw new RuntimeException("Attenzione! Taglio moneta non compatibile con il distributore, inserire taglio differente");
		}
		this.Valore=Valore;
		this.quantità=quantità;
		
	}
	
	public int getQuantità(){
		return quantità;
	}
	
	public double getValore(){
		return Valore;
	}
	
	public void setQuantità(int n){
		this.quantità=n;
	}
	
	public int compareTo(Denaro other){
		
		if(Valore>other.Valore) return -1;
		if(Valore<other.Valore)return 1;
		return 0;
		
	}//COMPARETO
	
	public boolean equals(Object Other){
		if(Other==this) return true;
		if(Other==null) return false;
		if(!(Other instanceof Denaro)) return false;
		Denaro d = (Denaro) Other;
		return d.Valore==Valore && d.quantità==quantità ;
		
	}//EQUALS
	
	public String toString(){
		return ("Banconota da " +Valore+ " ; Pezzi disponibili : " +quantità);
		
	}//TOSTRING
	
	public int hashCode(){
		return  3 * new Double(Valore).hashCode() +  5 * new Integer(quantità).hashCode();
		
	}//HASHCODE
	

}//DENARO

public interface Soldi extends Comparable<Denaro>, Iterable<Denaro>{
	
	double totale();
	void add(Denaro d);
	void add(Soldi s);
	Soldi sub(Soldi s1, Soldi s2);
	
	
	
}//INTERFACCIA SOLDI

public abstract class SoldiAbstract implements Soldi{
	
	TreeSet<Denaro> Soldi = new TreeSet<Denaro>();
	
	@Override
	public double totale(){
		double totale = 0;
		Iterator<Denaro> it = this.iterator();
		while(it.hasNext()){
			Denaro d = it.next();
			totale+= d.getValore() * d.getQuantità();
		}
		return totale;
		
	}//TOTALE
	
	@Override
	public void add(Denaro d){
		this.add(d);
		
	}//ADD_DENARO
	
	@Override
	public void add(Soldi s){
		this.add(s);
		
	}//ADD_SOLDI
	
	@Override
	public Soldi sub(Soldi s1, Soldi s2){
		double resto;
		if(s2.totale()<s1.totale()) throw new RuntimeException ("Soldi insufficienti per il pagamento!");
		double residuo = s1.totale() - s2.totale();;
		Iterator<Denaro> it = this.iterator();
		while(it.hasNext()){
			Denaro d = it.next();
			int pezzi = 0;
			while(d.getValore()<=residuo){
				pezzi++;
			residuo-=d.getValore();
			resto+=d.getValore()*pezzi;
			
			
			}//WHILE INTERNO
			
			
		}

		
	}
}
Beh credo che in parte l'ultimo metodo sia corretto , ma come faccio a restituire un oggetto soldi che contiene il resto?
Mi scrivereste la versione corretta di questo metodo?
Grazie
Ciao