Esercizio immutabilità oggetti

[Darèios89]

Avrei da implementare questa interfaccia:

 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:

 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?

[VincenzoTheBest]

Originariamente inviato da Darèios89

    public Ciao copy (){
	Ciao copia=this;
	    return copia;
    }

Come vi sembra? E' corretto il metodo copy? Restituisce una copia dell' oggetto così oppure è errato?

Non è corretto, perchè in questo modo se modifichi copia allora, inevitabilmente, modifichi anche this e viceversa.

Poi, perchè il costruttore è privato e hai definito l'inner-class Builder?

[Darèios89]

Ciao e grazie. A quindi in quel modo non è immutabile?
Io mi ricordo che per renderlo immutabile si deve restituire una copia dell' oggetto e mi è venuto istintivo fare in quel modo, cioè dovrei fare una cosa tipo:

return new Copia(this) ? Ma la sintassi è sbagliata, non mi ricordo come fare a restituire un nuovo oggetto copia...
Per il Builder, ho costruito la classe così sulla base di un altro esempio del libro Effective Java:

// Builder Pattern - Pages 14-15

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories      = 0;
        private int fat           = 0;
        private int carbohydrate  = 0;
        private int sodium        = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val)
            { calories = val;      return this; }
        public Builder fat(int val)
            { fat = val;           return this; }
        public Builder carbohydrate(int val)
            { carbohydrate = val;  return this; }
        public Builder sodium(int val)
            { sodium = val;        return this; }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
            calories(100).sodium(35).carbohydrate(27).build();
    }
}

Qui dovrebbe fare come ho fatto io, se non ho sbagliato a realizzarla....

[morpheus4java]

ciao
diciamo che in linea di massima è corretto
se usi final non ti serve il costruttore
se hai un costruttore privato dovresti implementare un metodo factory per la creazione del tuo oggetto
quando ti fai ritornare il clone referenzialo direttamente col this

mmm guarda ti do un link utile
http://www.javapractices.com/topic/TopicAction.do?Id=29

[VincenzoTheBest]

Originariamente inviato da Darèios89
Ciao e grazie. A quindi in quel modo non è immutabile?

Per come hai definito i campi, tutte le istanze della classe Ciao sono immutabili, ma devi sapere che per rendere gli oggetti immutabili non è strettamente necessario porre ogni suo campo come final.

Originariamente inviato da Darèios89
Io mi ricordo che per renderlo immutabile si deve restituire una copia dell' oggetto e mi è venuto istintivo fare in quel modo

Si esatto, ma per come hai definito il metodo restituisci l'istanza stessa e non una copia.

[Darèios89]

Si esatto, ma per come hai definito il metodo restituisci l'istanza stessa e non una copia.

E così andrebbe bene?

public Cube copy(){
         myCube cubo= new myCube.Builder(edge).build();
         return cubo;
      }

[Patrick Jane]

Ma... utilizzare il metodo clone() di Object?

Magari hai scartato questa scelta perchè non puoi utilizzarlo... (Premetto di non aver letto tutto quanto avete scritto).

Comunque per questo tipo di problemi è sufficiente Google; suppongo che VincenzoTheBest volesse farti arrivare da solo alla soluzione.

[VincenzoTheBest]

Originariamente inviato da Darèios89
E così andrebbe bene?

public Cube copy(){
         myCube cubo= new myCube.Builder(edge).build();
         return cubo;
      }

Si, è ok.