I denne artikkelen vil vi lære om dette nøkkelordet i Java, hvordan og hvor du kan bruke dem ved hjelp av eksempler.
dette nøkkelordet
I Java brukes dette nøkkelordet til å referere til det nåværende objektet i en metode eller en konstruktør. For eksempel,
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); ) )
Utgang :
denne referansen = Main @ 23fc625e objektreferanse = Main @ 23fc625e
I eksemplet ovenfor opprettet vi et objekt som heter obj fra klassen Main. Deretter skriver vi ut referansen til objektets obj og thisnøkkelord i klassen.
Her kan vi se at referansen til begge obj og thiser den samme. Det betyr at dette ikke er annet enn referansen til det nåværende objektet.
Bruk av dette nøkkelordet
Det er forskjellige situasjoner der thisnøkkelord ofte brukes.
Bruker dette for tvetydighetsvariabelle navn
I Java er det ikke lov å erklære to eller flere variabler som har samme navn i et omfang (klasses omfang eller metodes omfang). Imidlertid kan forekomstvariabler og parametere ha samme navn. For eksempel,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
I programmet ovenfor har forekomstvariabelen og parameteren samme navn: alder. Her er Java-kompilatoren forvirret på grunn av tvetydighet i navnet.
I en slik situasjon bruker vi dette nøkkelordet. For eksempel,
La oss først se et eksempel uten å bruke thisnøkkelord:
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); ) )
Utgang :
mc.age = 0
I eksemplet ovenfor har vi gått 8som en verdi til konstruktøren. Imidlertid får vi 0som en produksjon. Dette er fordi Java-kompilatoren blir forvirret på grunn av tvetydigheten i navn mellom instansvariabelen og parameteren.
La oss nå skrive om ovennevnte kode ved hjelp av thisnøkkelord.
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); ) )
Utgang :
obj.age = 8
Nå får vi forventet produksjon. Det er fordi når konstruktøren kalles, thiserstattes konstruktøren av objektet obj som har kalt konstruktøren. Derfor tildeles aldersvariabelen verdi 8.
Hvis navnet på parameteren og forekomstvariabelen er forskjellig, legger kompilatoren automatisk til dette nøkkelordet. For eksempel koden:
class Main ( int age; Main(int i) ( age = i; ) )
tilsvarer:
class Main ( int age; Main(int i) ( this.age = i; ) )
dette med Getters og Setters
En annen vanlig bruk av thisnøkkelord er i setters og getters metoder for en klasse. For eksempel:
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()); ) )
Utgang :
obj.navn: Toshiba
Her har vi brukt thisnøkkelord:
- for å tilordne verdi innenfor settermetoden
- for å få tilgang til verdien i getter-metoden
Bruker dette i Constructor Overloading
Mens vi arbeider med konstruktøroverbelastning, må vi kanskje påkalle en konstruktør fra en annen konstruktør. I et slikt tilfelle kan vi ikke ringe konstruktøren eksplisitt. I stedet må vi bruke thisnøkkelord.
Her bruker vi en annen form for dette nøkkelordet. Det vil si this(). La oss ta et eksempel,
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); ) )
Utgang :
2 + 3i 3 + 3i 0 + 0i
I eksemplet ovenfor har vi brukt thisnøkkelord,
- å ringe konstruktøren
Complex(int i, int j)fra konstruktørenComplex(int i) - å ringe konstruktøren
Complex(int i)fra konstruktørenComplex()
Legg merke til linjen,
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); ) )
Utgang :
Før du sender dette til addTwo () -metoden: x = 1, y = -2 Etter å ha sendt dette til addTwo () -metoden: x = 3, y = 0
I eksemplet ovenfor, inne i konstruktøren ThisExample(), legg merke til linjen,
add(this);
Her kaller vi add()metoden ved å sende denne som et argument. Siden dette nøkkelordet inneholder referansen til objektet obj i klassen, kan vi endre verdien av x og y inne i add()metoden.
