# Referenz einer Variable übergeben



## TKausL (11. Jan 2011)

Hallo.

Ich google und google aber finde nicht wirklich was brauchbares <.<

Problem ist folgendes:

```
main(){
  int i = 0;
  methode1(i);
  //i ausgeben
}
methode1(int zahl){
  zahl++;
}
```

beim ausgeben sollte nun 1!!! rauskommen.
Ich habe irgendwo mal gelesen dass/wie das geht. ich komme aber nicht mehr drauf...
habs schon mit methode(int &zahl) versucht, aber Eclipse nimmt das nicht an...


----------



## Noctarius (11. Jan 2011)

Du musst eine Klasse als Wrapper für den Wert nutzen, da gäbe es z.B. den AtomicInteger, welche gleich noch andere Möglichkeiten bietet (AtomicInteger (Java Platform SE 6)).

Ansonsten einfach ein Bean welches den Wert vorhält.


----------



## ARadauer (11. Jan 2011)

Im Grunde ist Java CallByValue. Das heißt bei primitiven Datentypen wird der Wert übergeben, also kopiert.
Eigentlich ist es bei Objekten genauso, es wird aber die Referenz kopiert. Also adresse wohin gezweigt wird. Änderst du dann das Objekt. Ändert es sich auch beim Aufrufer, da es ja das selbe ist:


```
public class Test
{

	public int wert;

	public static void main(String[] args)
	{
		Test test = new Test();
		test.wert = 2;
		methode(test);
		System.out.println(test.wert);
		methode(test.wert);
		System.out.println(test.wert);
	}

	public static void methode(Test test)
	{
		test.wert++;
	}
	
	public static void methode(int wert)
	{
		wert++;
	}
}
```

Wie gesagt, Objektereferenzen werden auch kopiert... das geht somit nicht


```
public static void change(Test test)
	{
		test = new Test(); 
		test.wert=99;
	}
```
hier ändert sich der Wert beim Aufrufer nicht, da das test in Main noch immer auf das alte Objekt zeigt.

Ist vielleicht etwas verwirrend, aber das ist soch sehr wichtig, spiel ein bisschen damit rum, dann wirds klarer...


----------



## Andi_CH (11. Jan 2011)

Ich hab da vor Kurzem eine Demo geschrieben die zeigt was geht und was nicht


```
public class CallValueCallRefDemo {

	public static class MyInt {
		private int value = 0;
		public void set(int i) { value = i; }
		public int get() {return value; }
		public String toString(){ return ""+value; }
	}

	private static void setValue(int pValue) {
		System.out.println("setValue(int): Parameter vor dem Setzen = " + pValue);
		// Bewirkt ausserhalb ncihts, da pValue eine Kopie ist
		pValue = 999;
		System.out.println("setValue(int): Parameter nach dem Setzen = " + pValue);
	}

	private static void setValue(Integer pValue) {
		System.out.println("setValue(Integer): Parameter vor dem Setzen = " + pValue);
		// Hier wird implizit ein neuer Integer angelegt
		// Da aber pValue nur eine Kopie der eigentlichen Referenz ist, bewirkt das nichts
		// Integer hat aus mir unbekannten Gründen keine set Methode
		pValue = 999;
		System.out.println("setValue(Integer): Parameter nach dem Setzen = " + pValue);
	}

	private static void setValue(MyInt pValue) {
		System.out.println("setValue(MyInt): Parameter vor dem Setzen = " + pValue.get());
		pValue.set(999);
		System.out.println("setValue(MyInt): Parameter nach dem Setzen = " + pValue.get());
	}

	public static void main(String[] args) {
		int i = 1;
		System.out.println("int im Main vor dem Aufruf " + i);
		setValue(i);
		System.out.println("int im Main nach dem Aufruf " + i);
		System.out.println();
		Integer j = 2;
		System.out.println("Integer im Main vor dem Aufruf " + j);
		setValue(j);
		System.out.println("Integer im Main nach dem Aufruf " + j);
		System.out.println();
		MyInt k = new MyInt();
		k.set(2);
		System.out.println("MyInt.value im Main vor dem Aufruf " + k);
		setValue(k);
		System.out.println("MyInt.value im Main nach dem Aufruf " + k);
	}
}
```


----------

