# this - wann verwende ich das?



## CoronaLemon (20. Jun 2009)

Hallo,

ich arbeite gerade ein Java Buch durch und bin dabei auf folgendes Beispiel gestoßen:


```
public class Fraction {

	int n=0;
	int d=0;
	
	void add (Fraction f)
	{
		this.n = this.n * f.d + f.n * this.d;
		this.d = this.d * f.d;
		System.out.println(this.n + " " + this.d);
	}
	
	public static void main (String arg[])
	{
		Fraction bruch = new Fraction();
		bruch.n = 3;
		bruch.d = 4;
		bruch.add(bruch);
	}
}
```

Ist nicht gerade ein komplexes Programm, aber im Moment fehlt mir dafür ein bisschen der Durchblick.

Im Hauptprogramm erzeuge ich einen bruch vom Typ "Fraction". bruch zeigt also auf ein Fraction-Objekt n, in dem noch kein Wert steht - richtig?

Nun wird bruch.n der Wert 3 und bruch.d der Wert 4 hinzugefügt.
Wie ich der Ausgabe entnehmen kann, werden zuerst Zähler und Nenner multipliziert bzw. anschließend addiert. Also in diesem Beispiel wäre der neue Zähler 3*3+4*4 ... aber warum? Zeigen this.n und f.n auf das gleiche Fraction-Objekt n?

Mir ist noch nicht ganz klar, wann ich dieses this verwenden kann / muss.

Danke im Voraus und schönes WE,

Philipp


----------



## Developer_X (20. Jun 2009)

hi, also ich versuchs dir mal zu erklären, this, heißt ja dies/das
this wird verwendet um auf die eigene Klasse innerhalb der Klasse zu zeigen.

Zum beispiel in deinem code

this.n 

es gibt ja einen Wert, namens "n" in deiner klasse,
und das this, soll heißen:
seht mal alle her, das n aus dieser klasse, dieses n meine ich!

this kann für vieles verwendet werden, auch wenn man erbt, ich weiß nicht ob du schon so weit bist, noch mal kurz zusammengefasst:
Wenn man in Klasse A ist, und auf Klasse A verweisen will, dann schreibt man this
um auf die Klasse selbst innerhalb der klasse zu zeigen

oder um werte aus der klasse zu meinen, 

die werden mit this und einem punkt und dann dem wert angegeben wie hier:

this.n 

OK?
Ichhoffe du hast das einigermaßen verstanden wie ich das erklärt habe


----------



## Developer_X (20. Jun 2009)

du kannst es;:
immer verwenden

du musst es verwenden:
wenn du z.B. im Constructor der Klasse, einen Wert m hast, und ganz oben auch den wert m, wenn du jetzt m schreibst, weiß java nicht ob du das obere m meinst, oder das im Constructor, das im constructor heißt ganz einfach m, aber das ganz oben würde im constructor dann this.m heißen


```
public class Test
{
//wert der klasse
int m;
//construcotr
public Test()
{
//wert im constructor
int m;
//java denkt jetzt, wenn ich m schreibe, welches m? ich habe in der klasse 2 ms
//dann wenn man m schreibt
m = 1;
//wird der wert im construcor zu eins,
//wenn man this.m schreibt
this.m = 1;
//wird der wert ganz oben zu eins
//das wars

}
}
```


----------



## Developer_X (20. Jun 2009)

in der main kann man ganz schön sehen, wie man werte von anderen klassen meinen kann, nämlich in dem man 
ganz einfach den klassennamen, dann denk punkt und dann den wert schreibt


----------



## CoronaLemon (20. Jun 2009)

Das ging ja schnell ... 

Aaah, das macht die Sache schon verständlicher.

Also wenn ich die Methode (in diesem Fall add) von dem Objekt bruch aufrufen, dann wird bei this.n, immer der Wert von bruch verwendet. Mit dem "normalen" Parameter Fraction f kann ich dann festlegen, mit was addiert wird?!

z.B.

Fraction alpha = new Fraction();
Fraction beta = new Fraction();
alpha.n = 1;
alpha.d = 2;
beta.n = 1;
beta.d = 2;
alpha.add(beta);

Dann würde in der Methode das this.n den Wert 1 und this.d den Wert 2 haben, richtig?

EDIT// Das Konstruktor Beispiel ist prima, danke!


----------



## Developer_X (20. Jun 2009)

genau, du hast es erfasst,
wenn du weitere fragen hast, zöger nie zu fragen

obwohl welche methode meinst du, das verstehe ich nicht ganz,

PS: dein Code ist ziemlich komplex, kennst du die Java Rechenoperationen schon? das sieht nicht einfach aus für einen anfänger, 

+ = plus ja klar
- = minus auch klar
/ = geteilt
*= mal

ich weiß net ob du die schon kennst


----------



## CoronaLemon (20. Jun 2009)

Developer_X hat gesagt.:


> genau, du hast es erfasst,
> wenn du weitere fragen hast, zöger nie zu fragen


Werd ich machen! 
Danke für die schnelle Hilfe.


----------



## Schandro (20. Jun 2009)

this ist nicht nur dazu da um zwischen Membervariablen und lokalen Variablen zu unterscheiden wenn sie den selben Namen haben. Der wichtigere Aspekt ist, dass man mit "this" tatsächlich eine Referenz auf sich selber weitergeben kann:

```
public class A{
	
	public static void main(String[] args) {
		new A().doSomething();
	}
	
	public A(){
	}
	
	public void doSomething(){
		B myB = new B(this); // Der Konstruktor von B erwartet eine Referenz auf ein A-Object als Parameter. this ist eine Referenz auf sich selber, ALSO auf ein A-Object da wir uns gerade in der Klasse A und nicht in einen statichen Kontext befinden.
		myB.doSomethingToo();			
	}
	
	public void print(){
		System.out.println("A says: Hello");
	}
}

class B{
	private A myA;
	
	public B(A myA){
		this.myA = myA; // hier nochmal die Verwendung von this um zwischen Lokaler und Membervariable syntaktisch zu unterscheiden
	}
	
	public void doSomethingToo(){
		myA.print(); // myA zeigt auf ein A-Object. (Zuffäligerweise genau das Object was DIESES B-Object hier erst erschaffen hat, aber das ist egal)
		System.out.println("B says: Hello");
	}
}
```
A gibt beim erschaffen des B-Objectes eine Referenz AUF SICH SELBER mit. B benutzt diese Referenz auf das A-Object um eine Methode des A-Objectes aufzurufen.


----------



## CoronaLemon (20. Jun 2009)

Oha, jetzt wird's interessant.

Also in diesem Fall wird durch 
	
	
	
	





```
B myB = new B(this);
```
 einfach ein leeres (nennt man das so?) A Objekt mitgegeben, damit B auf A verweisen kann?

Interessantes Beispiel, danke!


----------



## Der Müde Joe (20. Jun 2009)

>einfach ein leeres (nennt man das so?) A Objekt mitgegeben

Nein, kein leeres. Dieses Objekt. Das aktuelle auf dem gerade gearbeitet wird.

EDIT:

```
A a = new A(); //das A Objekt
a.doSomething() // ruft nun die Methode auf im Objekt a, 
//welche wiederum new B(this) aufruft, wobei this dann das a ist. 
//Das Objekt auf dem doSomethong aufgerufen wird
```


----------



## CoronaLemon (20. Jun 2009)

Aah, langsam aber doch macht das alles einen Sinn.


----------

