Deep Clone

[b1zarRe]

Hi,

ich habe grade zwei Klassen erstellt, welches ein Shallow Clone ermöglichen:

package clone;

/** Testen von Clone */
public class Buch implements Cloneable {
    
    /* Variablen */
    private String titel;
    private String autor;
    private double preis;
    
    /* Konstruktor */
    public Buch(String titel, String autor, double preis) {
        this.titel = titel;
        this.autor = autor;
        this.preis = preis;
    }
    
    @Override
    /* Equals */
    public boolean equals(Object o) {
        boolean istGleich = false;
        
        if(o instanceof Buch) {
            Buch b2 = (Buch) o;
            istGleich = this.titel.equals(b2.titel)
                        && this.autor.equals(b2.autor)
                        && this.preis == b2.preis;
        }
        return istGleich;
    }
    
    @Override
    /* HashCode */
    public int hashCode() {
        return this.titel.hashCode() + this.autor.hashCode() + (int)this.preis;
    }
    
    @Override
    /* toString */
    public String toString() {
        return this.titel + ", " + this.autor + ", " + this.preis + " EU.";
    }
    
    @Override
    /* Überschreiben von clone() */
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    /* Tests */
    public static void main(String[] args) throws CloneNotSupportedException {
        
        Buch buch1 = new Buch("Das Erhängnis", "Bernd Spinner", 17.80);
        System.out.println(buch1);
        System.out.println("");
        
        Buch buch2 = (Buch)buch1.clone();
        
        System.out.println("Clone:");
        System.out.println(buch1.equals(buch2));
        System.out.println(buch1 == buch2);
    }
    
}

Das klappt auch soweit alles wunderbar... jedoch verstehe ich es nicht, wie die clone() Methode so umschreibe, dass auch weitere Referenzen gespeichert werden?

Habe ich den Unterschied zwischen Shallow und Deep Clone richtig verstanden???
Hätte jemand vllt. ein Codeschnipsel für mich, was ich zu meinem Code anfügen muss, damit auch Deep Clone möglich ist? Wäre echt nett! Danke euch

 

[njans]

Mal grob gesagt: Momentan machst du, wie du selbst sagst, eine shallow-copy.
Ergo ist die copy praktisch leer. Es ist nur ein Object ohne interne Daten.
Wenn du eine Deep-Copy willst, dann musst du ein neues Object erstellen, dass die Daten aus dem original hat.
Du kannst ja ohne Probleme auf die internen Daten zugreifen, also auch diese in ein neues Object übertragen

 

[b1zarRe]

Hat eine Shallow Copy in dem Beispiel dann nicht auch einen Titel, einen Autor und einen Preis?

Ich dachte bei Shallow wird alles mitkopiert ausser weitere Objekte... Wenn zb. Buch jetzt

private CD eineCD;

hätte, würde das bei Shallow nicht kopiert, sondern nur die anderen Variablen. Und bei Deep halt alles...?!

Demzufolge verstehe ich auch nicht, wie du das mit dem Übertragen der Daten meinst :/

Danke soweit aber schonmal!

 

[njans]

http://www.java-forum.org/java-basics-anfaenger-themen/10312-shallow-copy-deep-copy-objekten.html
Da wird es auch noch mal erklärt

 

[b1zarRe]

"shallow: primitive member kopiert, bei Object Members die referenz kopiert

deep: primitive member kopiert, bei Object Members allen referenzen folgen und alle erreichbaren Objekte selbst kopieren"

Sind meine Strings "titel", "autor" und "preis" nicht primitive Member? Falls nein, was sind primitive Member? oO Und Object Member wären dann, wenn ich noch zb. ein anderes Object speicher zb.: private CD eineCD;
So habe ich es verstanden, ist dies korrekt?

Sprich: wäre das ein deep clone:

public Object clone() throws CloneNotSupportedException {
return new Auto(this.titel, this.autor, this.preis);
}

???

 

[njans]

Primitive Members sind primitive Typen: int, double, long, etc.
Objekte sind nicht primitiv. Und Strings sind Objekte (erkennt man schon daran, dass String groß geschrieben wird, wie alle Klassen in Java).
Ergo wäre deines keine Deep, sonder shallow copy, denn du kopierst die Referenzen.

 

[Gelöschtes Mitglied 5909]

Bei Strings ist das ein Sonderfall, denn sie sind immutable. Eine shallow copy reicht deshalb aus,
da du bei einer kopie (deines objekts) zwar zwei referenzen hast die auf den gleichen String verweisen,
aber keines der beiden objekte kann den String des anderen manipulieren.
Denn es kann nur die eigene Referenz umgebogen werden, der inhalt bleibt gleich (immutable) und die referenz des anderen objekts sowieso.

 

[b1zarRe]

mhhh bin irgendwie leider nun noch verwirrter... :/
Hat einer vielleicht ein Stück Code, an dem das Deep Clone gezeigt wird?

 

[Andi_CH]

Es ist zwar nett dass du das da hinschreibst

    @Override
    /* Überschreiben von clone() */
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

aber so wie es jetzt da steht, ist es total überflüssig.

Deep copy?

Gibt ein neues Objekt zurück das vom Typ Buch ist. (Zaunpfahl:

new

)
Das neue Objekt muss Kopien von allen, ich erfinde mal die Bezeichnung Unterobjekte, beinhalten, welche im aktuellen Objekt sind.
Diese Unterobjekte müssen auch wieder Kopien von ihren eigenen Unterobjekten beinhalten und diese ....... the never ending story, die erst da endet wo eben keine Unterobjekte mehr beinhaltet werden.

Also jede Klasse hatt sinnvollerweise einen Copykonstruktor oder dann halt eine clone Methode

Ach jetzt kommt dann sicher die Frage was eine Copy-Konstruktor ist -> siehe da ;-)

 

[Gelöschtes Mitglied 5909]

wenn du einen copy konstruktor verwendest, musst du auch die primitiven typen "per hand" kopieren.
Das musst du mit dem aufruf von clone nicht. Clone ist quasi auch ein konstruktor, der per default die referenzen kopiert und bei primitiven typen eben den inhalt.

Lies am besten aus Effective Java:

http://java.sun.com/developer/Books/effectivejava/Chapter3.pdf

 

[Andi_CH]

Hm fachchinesisch - na ja, dafür nehme ich mir die Zeit jetzt nicht - ich habe längst ein mittelgrosses Beispiel bereit das clone und copyconstructoren drin hat, aber damit warte ich natürlich noch ne Weile - der TO hat sich ja noch nicht wieder gemeldet.

Ob ich nun für ein Unterobject

x.clone()

oder

x = new X(o.x)

aufrufe ist kein sehr grosser Unterschied - im Fall von clone spare ich mir ausserhalb das "new" das in der clone Methode drin allerdings auch vorhanden sein muss.

 

[Gelöschtes Mitglied 5909]

ausserhalb das "new" das in der clone Methode drin allerdings auch vorhanden sein muss.

Eben nicht. Darum gehts ja gerade. Du musst in deinem Copy Konstructor alles selber machen, wo dir clone einen Teil abnimmt.

Das mit dem Copy Konstrukor ist übrigens eine legitime Lösung, die aber nur außerhalb von clone verwendet werden kann. Wenn du den copy ctor innerhalb von clone aufrust, bekommst du mit Klassenhierarchien Probleme.

 

[fastjack]

Wenn du den copy ctor innerhalb von clone

den von Referenzklassen kannst Du in clone benutzen. Allerdings würde ich, wenn ich clone nutze, immer die clone-Methoden der anderen Objekte benutzen. Ich finde den Kopierkonstruktor aber besser, da er besser klarmacht, das wirklich das Objekt kopiert wird (naja, eine hohe Wahrscheinlichkeit eben ). Bei clone weist man ja nie, wie das jetzt programmiert wurde.