Avrei da implementare questa interfaccia:

codice:
 interface Cube extends Comparable {
      
      public Integer getEdge (); // ritorna il lato del cubo
      public Integer getVol (); // ritorna il Volume del cubo
      public int compareTo (Cube c); // confronta due cubi
      public Cube copy (); // ritorna una copia identica dell'oggetto
}
Il testo dice:

Si _ realizzi _ l'implementazione _ dell'interfaccia _ Cube
mostrata _ di _ seguito _ (si _ faccia _ in _ modo _ che _ la _ classe
rappresenti_oggetti_immutabili)
Io ho scritto questo:

codice:
 interface Cube extends Comparable<Cube> {
      
      public Integer getEdge (); // ritorna il lato del cubo
      public Integer getVol (); // ritorna il Volume del cubo
      public int compareTo (Cube c); // confronta due cubi
      public Cube copy (); // ritorna una copia identica dell'oggetto
}
    
 
 
 public final class Ciao implements Cube{

    private final Integer edge;
    private final Integer volume;
    
    public class Builder{
        
        private final Integer edge;
        private final Integer volume;
        
        public Builder(Integer edge){
            
            this.edge=edge;
            this.volume=edge*edge*edge;
        }
        
        public Ciao build(){
            return new Ciao(this);
        }
    }
    
    private Ciao(Builder builder){
        edge= builder.edge;
        volume=builder.volume;
    }
    
    public Integer getEdge(){
        return edge;
    }
    
    public Integer getVol(){
        return volume;
    }
    
    public int compareTo(Cube c){
        if(getVol()<((Ciao)(c)).getVol()){
            return -1;
        }
        else if(getVol()==((Ciao)(c)).getVol()){
            return 0;
        }
        else{
            return -1;
        }
    }
    
    public Ciao copy (){
	Ciao copia=this;
	    return copia;
    }
	    
  
    }
Come vi sembra? E' corretto il metodo copy? Restituisce una copia dell' oggetto cosģ oppure č errato?