Ebben a cikkben megismerhetjük ezt a kulcsszót a Java-ban, hogyan és hol használhatjuk őket példák segítségével.
ez a kulcsszó
A Java-ban ez a kulcsszó arra szolgál, hogy a metódus vagy a konstruktor aktuális objektumára utaljon. Például,
class Main ( int instVar; Main(int instVar)( this.instVar = instVar; System.out.println("this reference = " + this); ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("object reference = " + obj); ) )
Kimenet :
ez a referencia = Main @ 23fc625e objektum hivatkozás = Main @ 23fc625e
A fenti példában létrehoztuk a Main osztály obj nevű objektumát. Ezután kinyomtatjuk thisaz osztály objektumára és kulcsszavára való hivatkozást .
Itt láthatjuk, hogy mind az obj, mind a hivatkozás thismegegyezik. Ez azt jelenti, hogy ez nem más, mint az aktuális objektumra való hivatkozás.
A kulcsszó használata
Különféle helyzetekben thisszokás kulcsszót használni.
Ennek használata a kétértelműség változó neveknél
A Java-ban nem engedélyezhető két vagy több azonos névvel rendelkező változó deklarálása egy hatókörön belül (osztálykör vagy módszer hatóköre). A példányváltozóknak és a paramétereknek azonban ugyanaz a neve lehet. Például,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
A fenti programban a példányváltozónak és a paraméternek ugyanaz a neve: age. Itt a Java fordító zavaros a név kétértelműsége miatt.
Ilyen helyzetben ezt a kulcsszót használjuk. Például,
Először nézzünk meg egy példát thiskulcsszó használata nélkül :
class Main ( int age; Main(int age)( age = age; ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("obj.age = " + obj.age); ) )
Kimenet :
mc.age = 0
A fenti példában 8értékként átadtuk a konstruktort. Kimenetként azonban megkapjuk 0. Ennek oka, hogy a Java fordító összezavarodik a változó és a paraméter közötti nevek kétértelműsége miatt.
Most írjuk át a fenti kódot thiskulcsszóval.
class Main ( int age; Main(int age)( this.age = age; ) public static void main(String() args) ( Main obj = new Main(8); System.out.println("obj.age = " + obj.age); ) )
Kimenet :
obj.age = 8
Most megkapjuk a várt teljesítményt. Ez azért van, mert amikor a konstruktort meghívják, thisa konstruktort belül helyettesíti az objektum objektum, amely felhívta a konstruktort. Ezért az életkori változóhoz a 8. értéket rendeljük.
Továbbá, ha a paraméter és a példányváltozó neve eltér, a fordító automatikusan hozzáfűzi ezt a kulcsszót. Például a kód:
class Main ( int age; Main(int i) ( age = i; ) )
egyenértékű:
class Main ( int age; Main(int i) ( this.age = i; ) )
ezt a Getters and Setters-rel
A thiskulcsszó másik gyakori használata egy osztály beállítói és getterei módszereiben. Például:
class Main ( String name; // setter method void setName( String name ) ( this.name = name; ) // getter method String getName()( return this.name; ) public static void main( String() args ) ( Main obj = new Main(); // calling the setter and the getter method obj.setName("Toshiba"); System.out.println("obj.name: "+obj.getName()); ) )
Kimenet :
objekt.név: Toshiba
Itt a következő thiskulcsszót használtuk :
- értéket rendelni a szetter módszeren belül
- az érték eléréséhez a getter módszer belsejében
Ennek használata a konstruktor túlterhelésében
Míg a konstruktor túlterhelésével dolgozunk, előfordulhat, hogy egyik konstruktort egy másik konstruktortól kell meghívnunk. Ilyen esetben nem hívhatjuk meg kifejezetten a konstruktort. Ehelyett thiskulcsszót kell használnunk .
Itt ennek a kulcsszónak egy másik formáját használjuk. Azaz, this(). Vegyünk egy példát,
class Complex ( private int a, b; // constructor with 2 parameters private Complex( int i, int j )( this.a = i; this.b = j; ) // constructor with single parameter private Complex(int i)( // invokes the constructor with 2 parameters this(i, i); ) // constructor with no parameter private Complex()( // invokes the constructor with single parameter this(0); ) @Override public String toString()( return this.a + " + " + this.b + "i"; ) public static void main( String() args ) ( // creating object of Complex class // calls the constructor with 2 parameters Complex c1 = new Complex(2, 3); // calls the constructor with a single parameter Complex c2 = new Complex(3); // calls the constructor with no parameters Complex c3 = new Complex(); // print objects System.out.println(c1); System.out.println(c2); System.out.println(c3); ) )
Kimenet :
2 + 3i 3 + 3i 0 + 0i
A fenti példában thiskulcsszót használtunk ,
- hogy felhívja a konstruktort
Complex(int i, int j)a konstruktorrólComplex(int i) - hogy felhívja a konstruktort
Complex(int i)a konstruktorrólComplex()
Figyelje meg a sort,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
class ThisExample ( // declare variables int x; int y; ThisExample(int x, int y) ( // assign values of variables inside constructor this.x = x; this.y = y; // value of x and y before calling add() System.out.println("Before passing this to addTwo() method:"); System.out.println("x = " + this.x + ", y = " + this.y); // call the add() method passing this as argument add(this); // value of x and y after calling add() System.out.println("After passing this to addTwo() method:"); System.out.println("x = " + this.x + ", y = " + this.y); ) void add(ThisExample o)( o.x += 2; o.y += 2; ) ) class Main ( public static void main( String() args ) ( ThisExample obj = new ThisExample(1, -2); ) )
Kimenet :
Mielőtt ezt átadná az addTwo () metódusnak: x = 1, y = -2 Miután ezt átadta az addTwo () metódusnak: x = 3, y = 0
A fenti példában a konstruktor belsejében ThisExample()vegye észre a vonalat,
add(this);
Itt a add()metódust úgy hívjuk meg, hogy ezt argumentumként adjuk át. Mivel ez a kulcsszó tartalmazza az osztály objektum objektumára való hivatkozást, megváltoztathatjuk az x és y értékét a add()módszeren belül .
