I denne artikel lærer vi om dette nøgleord i Java, hvordan og hvor de skal bruges ved hjælp af eksempler.
dette nøgleord
I Java bruges dette nøgleord til at henvise til det aktuelle objekt inde 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); ) )
Output :
denne reference = Main @ 23fc625e objektreference = Main @ 23fc625e
I ovenstående eksempel oprettede vi et objekt med navnet obj fra klassen Main. Vi udskriver derefter henvisningen til objektets obj og thisnøgleord i klassen.
Her kan vi se, at begge objekters henvisning thiser den samme. Det betyder, at dette kun er henvisningen til det aktuelle objekt.
Brug af dette nøgleord
Der er forskellige situationer, hvor thisnøgleord ofte bruges.
Brug af dette til flertydige variabelnavne
I Java er det ikke tilladt at deklarere to eller flere variabler med samme navn inden for et omfang (klasses omfang eller metodes omfang). Imidlertid kan instansvariabler og parametre have samme navn. For eksempel,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
I ovenstående program har instansvariablen og parameteren det samme navn: alder. Her er Java-kompilatoren forvirret på grund af tvetydighed i navnet.
I en sådan situation bruger vi dette nøgleord. For eksempel,
Lad os først se et eksempel uden at bruge thisnøgleord:
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); ) )
Output :
mc.age = 0
I ovenstående eksempel har vi overført 8som en værdi til konstruktøren. Vi får dog 0som output. Dette skyldes, at Java-kompilatoren bliver forvirret på grund af tvetydigheden i navne mellem instansvariablen og parameteren.
Lad os nu omskrive ovenstående kode ved hjælp af thisnøgleord.
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); ) )
Output :
obj.age = 8
Nu får vi det forventede output. Det skyldes, at når konstruktøren kaldes, thiserstattes konstruktøren inde med objektet obj, der har kaldt konstruktøren. Derfor tildeles aldersvariablen værdi 8.
Hvis navnet på parameteren og instansvariablen er forskellig, tilføjer kompilatoren automatisk dette nøgleord. For eksempel koden:
class Main ( int age; Main(int i) ( age = i; ) )
svarer til:
class Main ( int age; Main(int i) ( this.age = i; ) )
dette med Getters og Setters
En anden almindelig brug af thisnøgleord er i settere og getters metoder i 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()); ) )
Output :
obj.name: Toshiba
Her har vi brugt thisnøgleord:
- for at tildele værdi inden for setter-metoden
- for at få adgang til værdi inde i getter-metoden
Brug dette i Constructor Overloading
Mens vi arbejder med overbelastning af konstruktører, er vi muligvis nødt til at påkalde en konstruktør fra en anden konstruktør. I et sådant tilfælde kan vi ikke ringe til konstruktøren eksplicit. I stedet skal vi bruge thisnøgleord.
Her bruger vi en anden form for dette nøgleord. Det vil sige this(). Lad os tage 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); ) )
Output :
2 + 3i 3 + 3i 0 + 0i
I ovenstående eksempel har vi brugt thisnøgleord,
- at kalde konstruktøren
Complex(int i, int j)fra konstruktørenComplex(int i) - at kalde konstruktøren
Complex(int i)fra konstruktørenComplex()
Bemærk 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); ) )
Output :
Før du sender dette til addTwo () metode: x = 1, y = -2 Efter at have sendt dette til addTwo () metode: x = 3, y = 0
I ovenstående eksempel ThisExample()bemærker du linjen inde i konstruktøren ,
add(this);
Her kalder vi add()metoden ved at sende den som et argument. Da dette nøgleord indeholder henvisningen til klassens objekt obj, kan vi ændre værdien af x og y inde i add()metoden.
