Eigene Objekte per Inhalt kopieren!

[by Value]

Hallo,
ich habe eine Klasse, diese einthaelt verschiedene Objekte. So - ich will von dieser Klasse nun eine exakte Copie in eine Variable uebergeben, dh. wenn ich was ander Kopie aendere soll sich der Inhalt des Originals nicht aendern (by value also). Wie mach ich das - ich dachte Java kennt kein by Reference, irgendwie trixt mich das anscheinend dauernd aus?

Ich hab ein Demo geschrieben dazu - wie man sieht, wird alles by value kopiert, bis auf das Objekt der "eigenen Klasse", muss ich dort etwa auch noch so eine klon-methode einbauen?? In der Realitaet habe ich ein Objekt einer Klasse, abgeleitet von ArrayList fuer wiederum eigene Panelklassen - geht das in Java nicht einfacher oder muss ich nun diese saemtlichen Klassen umschreiben, bzw mit dieser Funktion ergaenzen?

package muell;

import java.util.ArrayList;

import javax.swing.JPanel;

public class Klebrig {
	ArrayList<JPanel> pList;
	Schwampf sch;
	private class Schwampf{ // das eigene Objekt
		private String inhalt = "leer";
		public String getString(){return this.inhalt;}
		public void setString(String i){this.inhalt = i;}
	}
	ArrayList<String> list;
	String str;
	int idx;
	
	// main & start des prg's
	public static void main(String[] args) { Klebrig klebrig = new Klebrig(); klebrig.start();}
	public void start(){
		Klebrig nudel = new Klebrig();
		System.out.println("Vor der Kopie: ");
		status(nudel);
		
		Woanders wa = new Woanders(nudel);
		System.out.println("\nWoanders und Zustand der Kopie");
		status(wa.getKlon());
		
		System.out.println("\n..und das Original:");
		status(nudel);
	}
	
	// leerer ctor
	public Klebrig(){
		this.list = new ArrayList<String>();
		this.str = "vanilla";
		this.idx = 0;
		this.sch = new Schwampf();
		this.pList = new ArrayList<JPanel>();
	}
	
	// eine eigene methode zum klonen
	public Klebrig clown() {
		Klebrig k = new Klebrig();
		ArrayList<String> l = new ArrayList<String>();
		for(int cnt=0; cnt<this.getList().size(); ++cnt) l.add(this.getList().get(cnt));
		k.setList(l);
		k.setStr(this.getStr());
		k.setI(this.getI());
		k.setSchwampf(this.getSchwampf());
		ArrayList<JPanel> p = new ArrayList<JPanel>();
		for(int cnt=0; cnt<p.size(); ++cnt) p.add(this.getPList().get(cnt));
		k.setPList(p);
		return k;
	}
	
	// get/set
	public void setList(ArrayList<String> l){this.list = l;}
	public ArrayList<String> getList(){return this.list;}
	public void setStr(String s){this.str = s;}
	public String getStr(){return this.str;}
	public void setI(int i){this.idx = i;}
	public int getI() {return this.idx;}
	public Schwampf getSchwampf(){ return this.sch; }
	public void setSchwampf(Schwampf s){this.sch = s; }
	public ArrayList<JPanel> getPList(){return this.pList; }
	public void setPList(ArrayList<JPanel> pl){ this.pList = pl;}
	
	// output
	public static void status(Klebrig k){ System.out.println( "Laenge der list: " + k.getList().size() 
			+ "\nstr: " + k.getStr() 
			+ "\nint: " + k.getI()
			+ "\neigene Klasse: " + k.getSchwampf().getString()
			+ "\nLaenge der pList: " + k.getPList().size()); }
	
	
	
	/*
	 * 
	 */
	private class Woanders{
		private Klebrig klon = new Klebrig();
		public Woanders(Klebrig k){
//			kopier1(k); // geht nich
			kopier2(k); // geht teilweise
			doMassaker();
		}

		// kopieren aber WIE ???
//		public void kopier1(Klebrig k){ this.klon = k; }
		public void kopier2(Klebrig k){ this.klon = k.clown(); }
		

		// ein paar Veraenderungen
		public void doMassaker(){
			klon.getList().clear();
			klon.getList().add("Sie");
			klon.getList().add("haben");
			klon.getList().add("Gewonnen!");
			klon.setI(9999999);
			klon.setStr("$$$$$$$$$$$$$");
			klon.getSchwampf().setString("############");
			klon.getPList().clear();
			klon.getPList().add(new JPanel());
			klon.getPList().add(new JPanel());
			klon.getPList().add(new JPanel());
		}
		public Klebrig getKlon(){ return this.klon; }
	}
}

 

[Ark]

Objekte werden grundsätzlich by reference behandelt, primitive Werte dagegen grundsätzlich by value.

Wenn Du eine 1:1-Kopie eines Objektes benötigst, bleibt Dir nichts anderes übrig, als ein neues Objekt anzulegen (d. h. irgendwo muss new auftauchen) und es mit den gleichen oder denselben Werten zu füllen, das kommt darauf an:

Wenn Instanzen einer Klasse immutable sind (z. B. Integer, String), dann empfiehlt es sich, dieselben Objekte wiederzuverwenden, da das Speicherplatz spart.

Handelt es sich jedoch um Primitive oder sind Instanzen veränderlich (z. B. StringBuffer, int, double, ArrayList), so musst Du Deine 1:1-Kopie mit Objekten bzw. Primitiven füttern, die nur die gleichen, aber nicht dieselben Werte bzw. Objekte enthalten. D. h, Du musst von diesen veränderlichen Objekten wieder zunächst eine 1:1-Kopie erstellen usw., das funktioniert also rekursiv. Bei Primitiven ist das einfacher, da sie ja nur by value behandelt werden und damit grundsätzlich 1:1-Kopien hin- und hergeschoben werden.

Das alles ist aufwendig, aber unumgänglich.

MfG
Ark

P.S.:

public Klebrig clown()

Ich sag' mal nichts … :roll:

 

[byte]

Wie mach ich das - ich dachte Java kennt kein by Reference, irgendwie trixt mich das anscheinend dauernd aus?

Java kennt kein echtes Call by Reference. Bei der Parameterübergabe wird immer eine Copy der Referenz erzeugt/ übergeben. Das heisst, Du kannst über den Parameter keine Zeiger umbiegen. Du kannst aber sehr wohl das Objekt verändern, auf das die Referenz zeigt.

Deep Copies kannst Du in Java per Cloneable, Serializable, Copy-Constructor oder Reflection machen. Alle Möglichkeiten wurden schon diverse Male im Forum behandelt, also einfach mal suchen.