This Anzeiger

[pourki]

Hallo, ich verstehen nicht ganz die Bedeutung von "this" innerhalb der Konstrukoteren.

Kann mir jemand vielleicht dabei helfen, was this zu bedeuten hat...

Vielen Dank!

 

[JPKI]

Du meinst das?

public MyClass() {
 this(parameter);
}

Somit kannst du von einem Konsturktor auf einen anderen deiner Klasse verweisen.

Das hat u.A. den Sinn, dass du im Standardkonstruktor einen parametrisierten Konstruktor mit Standard-Parametern aufrufen kannst.

 

[pourki]

Hey JPK,

danke für die Antwort, aber kannst Du es einem "echten JAVA Dummy" erklären... so dass er es versteht...

gruß

 

[JPKI]

Ok.

Also, angenommen du hast in deiner Klasse zwei Konstruktoren, einen Standardkonstruktor (also ohne Parameter) und einen mit Parametern, z.B.

public MyClass() {
 this(0);
}

public MyClass(int value) {
 this.value=value;
}

Wenn es jetzt nötig ist, die Variable value unbedingt zu initialisieren, rufst du im Standardkonstruktor mittels this(0) den erweiterten Konstruktor mit dem Wert 0 auf.

Auch sinnvoll ist es, wenn in mehreren Konstruktoren immer die gleiche Logik ausgeführt wird, die kann man dann in einen einzigen packen und dann mit this() aufrufen.

Ich hoffe, ich hab's einigermaßen verständlich erklärt :wink: ...

 

[Leroy42]

Du hast doch schon Links auf Java-Tutorials bekommen.

Außerdem wird das Buch "Java in 21 Tagen" solche Grundlagen
mit Sicherheit auch erklären.

Was verstehst du denn daran nicht?

 

[pourki]

ich bin absoluter Anfänger und tu mich ein wenig schwer...Aber mit Eurer Hilfe wird das schon...

Es ist nur so furchtbar viel und ich weiss net genau, wo man anfangen sollte...

 

[Leroy42]

Einfach in dem du ein Tutorial Schritt für Schritt durcharbeitest,
die Beispielprogramme nachprogrammierst, sie ein Wenig veränderst
und wenn dir trotzdem irgendetwas Spezielles nicht verstehst,
hier postest.

 

[JPKI]

Kennst du die Javainsel?
Ich halte es für das beste Einsteiger-Buch, ich hab Java auch mit ihm erlernt.

Nachtrag:
Schau mal einer an! Hier steht alles was du über dein Problem wissen musst.

 

[Guest]

Hallo, ich verstehen nicht ganz die Bedeutung von "this" innerhalb der Konstrukoteren.

Neben dem angesprochenen Aufruf von anderen Konstruktoren kannst Du damit auch Exemplarvariablen benutzen, die sonst von formalen Parametern überschattet würden. Hier ist mal ein fehlerhaftes Beispiel:

public class Schatten
{
	private int x;
	
	public Schatten(int x)
	{
		// Hier wird dem formalen Parameter x sein eigener Wert zugewiesen,
		// was ziemlich sinnlos ist.
		x = x;
	}
	
	public int getX()
	{
		return x;
	}
}

Mit this.x sagen wir, dass wir das x meinen, dass im ganzen Objekt bekannt ist, nämlich unsere Exemplarvariable x:

public class Schatten
{
	private int x;
	
	public Schatten(int x)
	{
		// Wir wollen eigentlich an das x rankommen,
		// welches wir oben als Exemplarvariable deklariert hatten.
		this.x = x;
	}
	
	public int getX()
	{
		return x;
	}
}

Ein Bild sagt mehr als tausend Worte:

Fred

 

[JPKI]

Mag sein, aber er meinte glaube ich den Aufruf von einem anderen Konstruktor der selben Klasse.

 

[pourki]

super Fred, danke Dir. So langsam leuchtet es mir ein...hoffe ich.

Ich das Bild ist definitiv eine Hilfe...Aber meine Frage: Was geschieht hier genau? Ich meine muss man den unten genannten Code hacken, um an X zu kommen. Fragen, Fragen, Fragen.

Ich weiss, dass "public Schatten(int x)" eine Methode ist und x eine Variable von der Klasse Schatten, praktisch ein Attribut. Ich weiss, dass "this" x initialisiert und return x uns einen Wert zurückgibt. Ich kann jedoch noch nicht, den Zusammenhang wirklich erkennen/verstehen. aber vielen dank für eure nette hilfe

public class Schatten
{
private int x;

public Schatten(int x)
{
// Wir wollen eigentlich an das x rankommen,
// welches wir oben als Exemplarvariable deklariert hatten.
this.x = x;
}

public int getX()
{
return x;
}
}

 

[Leroy42]

Ja und was ist jetzt deine Frage? :shock:

Egal: Die Antwort ist sowieso: 42

 

[Guest]

Ich kann jedoch noch nicht, den Zusammenhang wirklich erkennen/verstehen.

Hm, also wenn Du die Begriffe Klasse, Objekt, Konstruktor, Exemplarvariable noch nicht so recht in Einklag bringen kannst, dann solltest Du erstmal ein Buch lesen.

 

[babuschka]

Also ich hab mir mit diesen Dingen als Anfänger auch sehr schwer getan, obwohl ich ein Buch gelesen habe. Wie auch immer. Es ist so:

public class Schatten
{
   private int x;  //diese Variable ist global in der ganzen Klasse gültig
   

   //Das hier ist der Konstruktor, da er aufgerufen wird, wenn die Klasse instanziiert wird,
   //wird er gerne benutzt, um Werte zu initialisieren (also keine einfache Methode!)

   public Schatten(int x)    //bei int x handelt es sich um einen Parameter, den der K. vom Aufrufer übergeben bekommt
   {
      // Wir wollen eigentlich an das x rankommen,
      // welches wir oben als Exemplarvariable deklariert hatten.
      // hier wird dem x links oben also den Wert vom Parameter x zugewiesen
      this.x = x;
   }
   
   public int getX()
   {
      return x;
   }
}

Woanders rufe ich die Klasse jetzt z.B. so auf:

Schatten schattenvariable = new Schatten(9) ;

Der Parameter mit dem Wert 9 wird dem x links oben zugeordnet.

int wert = schattenvariable.getX() ;
System.out.println(wert) ;

gibt also auch 9 aus.

Hoffe das macht es klarer.

 

[JPKI]

Genauso ist es beim Aufruf eines anderen Konstruktors dieser Klasse.
Wenn du z.B. unbedingt einen Standardkonstruktor anbieten möchtest (oder musst), kannst du das so machen:

public class Schatten { //Um an das Beispiel meines Vorposters anzuknüpfen
 private int x;

  public Schatten() { //Standardkonstruktor

   this(1); //Du möchtest jetzt, dass die Variable x auf jeden Fall initialisiert wird. Anstatt das
 //in dieser Methode zu machen, rufst du ganz einfach den parametrisierten Konstruktor mit einem bestimmten Parameter auf.
 }

 public Schatten(int x) {

  this.x = x;
 }
}

Hoffe, ich konnte auch meinen Teil zum Verständnis beitragen.

 

[ARadauer]

Ich meine muss man den unten genannten Code hacken, um an X zu kommen.

natürlich funktionierts auch, wenn du x public machst und einfach darauf zugreifst

Schatten sch = new Schatten();
...

int i = sch.x;

das macht man aber nicht, stichwort Kapselung. Andere Klassen sollen nur über definierte Schnittstellen auf deine Klasse zugreifen können. Also über Methoden.

also genau wie oben gezeigt. das ist sauberer und das macht man so. eclipse bietet eine nette funktion "generate getter/setter", da kannst dir die methoden erstellen lassen.