neues Objekt speichern, nicht Referenz

[Miriam90]

Hallo,

ich habe ein Objekt Snake und dieses wiederum einthält neben anderen Eigenschaften eine Liste aus Segmenten. In der Klasse Segment gibt es x und y als Koordinaten.

Ich dachte jetzt, es wäre ganz einfach, mir einen Zustand meiner Snake zu merken. Ich wollte also sowas wie

Snake oldSnake = snake

machen. Aber anscheinend speichere ich mir damit nur die Referenz, sodass ich oldSnake immer das gleiche drinsteht wie in snake. Hat das irgendwas mit mutable und immutable zutun? Wie bekommt man es hin, dass man wirklich die Daten speichert und nicht nur eine Referenz?

Mit dem Thema hatte ich schonmal ein riesiges Problem und bin es dann irgendwie kompliziert umgangen. Da ich nun schon wieder darauf stoße, frage ich die Experten und hoffe, dass ich etwas dazu lernen kann.

Grüße,

Miriam

 

[faetzminator]

Du musst deine Klasse von Cloneable (Java Platform SE 6) ableiten und noch die Methode Object (Java Platform SE 6) implementieren. Danach funktioniert folgendes Snippet:

Snake oldSnake = snake.clone();

Natürlich müssen je nach dem die inneren Objekte ebenfalls mit [c]clone()[/c], Copy-Konstruktor o.ä. kopiert werden.

 

[nillehammer]

Aber anscheinend speichere ich mir damit nur die Referenz, sodass ich oldSnake immer das gleiche drinsteht wie in snake.

Ja, in Java arbeitest Du grundsätzlich mit Referenzen. Wenn du eine neue Instanz von irgendwas erzeugen willst, musst Du das explizit programmieren.

Hat das irgendwas mit mutable und immutable zutun?

Nein, mutable/immutable ist eine Eigenschaft von Instanzen, die der Programmierer gewählt hat. Es sagt aus, ob Werte, die in einer Instanz gespeichert sind, geändert werden können oder nicht. Dazu folgende Codebeispiele:

// Gutes immutable, alle Inszanzvariablen sind final und es gibt keinen Code, der sie ändert.
public class GoodImmutable {

  private final String name;

  public GoodImmutable(final String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }
}
// Nicht so gutes immutable. Die Instanzvariable ist nicht final.
// Aber, weil es keinen Code gibt, der sie ändert und man wg. private
// auch von draußen nicht rankommt, ist es trotzdem immutable
public class NotSoGoodImmutable {

  private String name;

  public NotSoGoodImmutable(final String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }
}

// Mutable, die Instanzvariable kann verändert werden.
public class Mutable {

  private String name;

  public Mutable(final String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }

  public void setName(final String name) {
    this.name = name;
  }
}

Wie bekommt man es hin, dass man wirklich die Daten speichert und nicht nur eine Referenz?

Wie gesagt, Du musst explizit eine neue Instanz als Kopie erzeugen. Nur dann sind die Inszanzen wirklich unabhängig und es kommt nicht zu unerwünschtem Sharing. Dazu gibt es verschiedene Möglichkeiten:
- Implementiere Cloneable
- Schreibe einen Copy-Construktor
- Erzeuge eine neue Inszanz und ruf danach alle setter auf, um die Daten in der neuen Instanz zu haben

 

[Miriam90]

Wow, danke für die schnellen Antworten! Das hört sich sehr einleuchtend an =) An der praktischen Umsetzung haperts noch ein wenig..

public class Snake implements Cloneable{
	private List <Segment> segments = new ArrayList <Segment>();	
	private Character direction;								
	private int newx;	
	// ...

	protected Object clone() throws CloneNotSupportedException {
		Snake clone=(Snake)super.clone(); 
		clone.segments = segments;
		clone.direction = direction;
		clone.newx = newx;
		//...
		return clone;
	}
}

public class Segment implements Cloneable {
	private String typ;					
	private Color colour;					
	private int x;							
	private int y;
	
	 protected Object clone() throws CloneNotSupportedException {
		    Segment clone=(Segment)super.clone(); 	
		    clone.typ = typ;
		    clone.colour = colour;
		    clone.x = x;
		    clone.y = y;	    
		    return clone;
	 }
}

Damit scheine ich noch nicht fertig zu sein. Was fehlt noch?

 

[Gast2]

clone.segments = segments;

Damit teilen sich beide Schlangen wieder die selbe Liste. Du musst jedes Objekt (dass nicht immutable ist) klonen dass du in deiner Snake Klasse hast.

 

[Miriam90]

Wie und wo mache ich das? Kannst du dazu ein Codebeispiel zeigen?

 

[nillehammer]

Wie und wo mache ich das? Kannst du dazu ein Codebeispiel zeigen?

Du erzeugst ja schon beim Construieren jeweils eine neue ArrayList. Dieser kannst Du einfach alle Elemente hinzufügen

    public Object clone() throws CloneNotSupportedException {
        Snake clone=(Snake)super.clone();
        clone.segments.addAll(this.segments);
        //...
        clone.direction = direction;
        clone.newx = newx;
        //...
        return clone;
    }

Wenn Du jedes Segment selbst noch clonen willst, iterier händisch über die Liste von Segments und füge sie einzeln in die neue Liste ein.

 

[Miriam90]

	        final List<Segment> clonedSegments = new ArrayList<Segment>(this.segments.size());
	        for (Segment s : segments){
	        	clonedSegments.add(s);
	        }
	        clone.segments = clonedSegments;

Also so?
Sorry, dass ich so schwer von Begriff bin - aber müsste ich dann nicht durch diese Änderung fertig sein? Oder gibts noch andere Stellen?

 

[nillehammer]

Also so?

Leider nein. Die Erzeugung der ArrayList ist unnötig. Aufgrund folgender Zeile im Snake-Code hast Du bei einer frisch erzeugten Snake bereits eine frische Liste:

    private List <Segment> segments = new ArrayList <Segment>();

Eine der beiden Listenerzeugungen kannst Du Dir also sparen.

Wenn du "nur" alle Segments der Liste hinzufügen wolltest (das machst Du in der Schleife), würde auch das reichen:

clone.segments.addAll(this.segments);

Jetzt hast Du das Listensharing beseitigt. Die einzelnen Elemente in der Liste (die Segmente) werden aber immer noch geshared. Ist das schlimm? Nein, wenn Segment immutable ist. Dann bist Du fertig. Wenn Segment mutable ist (dazu siehe mein vorletzter Post), musst Du auch hier für unabhängige Instanzen sorgen . Bau dafür den clone-Befehl noch in Deine Schleife ein:

Segment clonedSegment = (Segment) s.clone();

 

[tuttle64]

Zu diesem Problem findet man in Google unter "deep copy and shallow copy" viele Ergebnisse: https://www.google.com/search?hl=en&btnI=I%27m+Feeling+Lucky&pws=0&q=What+is+shallow+copy+and+deep+copy+in+Java%3F

 

[Miriam90]

Jaaaa =)))
Ganz ganz großen Dank an euch alle!! Wenn ich jetzt nicht was fürs Leben gelernt hab =D Da macht das Studium doch endlich mal richtig Sinn^^
Danke auch für alle Begriffserläuterungen - werden nicht ignoriert, falls ihr das befürchtet habt Hatte ja zum Großteil auch ein Problem bei der Lösung, weil ich nicht genau wusste, nach was ich suche bzw. wie ich das betiteln soll.

Miriam