Tässä artikkelissa opit tästä Java-avainsanasta, miten ja missä niitä käytetään esimerkkien avulla.
tämä avainsana
Java-ohjelmassa tätä avainsanaa käytetään viittaamaan menetelmän tai konstruktorin nykyiseen objektiin. Esimerkiksi,
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); ) )
Tuotos :
tämä viite = Main @ 23fc625e-objektiviite = Main @ 23fc625e
Yllä olevassa esimerkissä loimme objektin nimeltä objektin luokka Main. Tulostamme sitten viitteen thisluokan objektiin ja avainsanaan.
Täällä voimme nähdä, että molempien obj ja viite ovat thissamat. Se tarkoittaa, että tämä ei ole muuta kuin viittaus nykyiseen kohteeseen.
Tämän avainsanan käyttö
On olemassa useita tilanteita, joissa thisavainsanaa käytetään yleisesti.
Tämän käyttö epäselvyyden muuttujien nimissä
Java-ohjelmassa ei ole sallittua ilmoittaa kahta tai useampaa samannimistä muuttujaa toimialueen sisällä (luokan tai menetelmän laajuus). Esimerkki muuttujilla ja parametreillä voi kuitenkin olla sama nimi. Esimerkiksi,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Yllä olevassa ohjelmassa esiintymämuuttujalla ja parametrilla on sama nimi: ikä. Tässä Java-kääntäjä on hämmentynyt nimen epäselvyyden vuoksi.
Tällaisessa tilanteessa käytämme tätä avainsanaa. Esimerkiksi,
Katsotaanpa ensin esimerkki ilman thisavainsanaa:
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); ) )
Tuotos :
mcage = 0
Yllä olevassa esimerkissä olemme välittäneet 8arvon rakentajalle. Saamme 0kuitenkin tuotoksen. Tämä johtuu siitä, että Java-kääntäjä sekoittuu nimien epäselvyyden vuoksi muuttujan ja parametrin välillä.
Kirjoita nyt uudestaan yllä oleva koodi thisavainsanalla.
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); ) )
Tuotos :
obj.age = 8
Nyt saamme odotetun tuotoksen. Se johtuu siitä, että kun konstruktoria kutsutaan, thiskonstruktorin sisällä korvataan objektilla obj, joka on kutsunut konstruktorin. Siksi ikämuuttujalle annetaan arvo 8.
Jos parametrin ja esiintymämuuttujan nimi on erilainen, kääntäjä liittää tämän avainsanan automaattisesti. Esimerkiksi koodi:
class Main ( int age; Main(int i) ( age = i; ) )
vastaa:
class Main ( int age; Main(int i) ( this.age = i; ) )
tämä Getters and Settersin kanssa
Toinen yleinen thisavainsanan käyttö on luokan setereissä ja gettereissä. Esimerkiksi:
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()); ) )
Tuotos :
obj.nimi: Toshiba
Tässä olemme käyttäneet thisavainsanaa:
- määrittää arvon setterimenetelmän sisällä
- päästäksesi arvoon getter-menetelmän sisällä
Tämän käyttö rakentajan ylikuormituksessa
Työskennellessäsi konstruktorin ylikuormituksen kanssa, meidän on ehkä kutsuttava yksi konstruktori toisesta konstruktorista. Tällöin emme voi kutsua rakentajaa nimenomaisesti. Sen sijaan meidän on käytettävä thisavainsanaa.
Tässä käytämme eri muotoista avainsanaa. Eli this(). Otetaan esimerkki,
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); ) )
Tuotos :
2 + 3i 3 + 3i 0 + 0i
Yllä olevassa esimerkissä olemme käyttäneet thisavainsanaa,
- kutsua rakentaja
Complex(int i, int j)rakentajaltaComplex(int i) - kutsua rakentaja
Complex(int i)rakentajaltaComplex()
Huomaa rivi,
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); ) )
Tuotos :
Ennen tämän välittämistä addTwo () -menetelmälle: x = 1, y = -2 Tämän jälkeen addTwo () -menetelmälle: x = 3, y = 0
Yllä olevassa esimerkissä ThisExample(), huomaa rakentajan sisällä viiva,
add(this);
Tässä kutsutaan add()menetelmää välittämällä tämä argumenttina. Koska tämä avainsana sisältää viittauksen luokan objektiobjektiin, voimme muuttaa x: n ja y: n arvoa add()menetelmän sisällä .
