W tym artykule dowiemy się o tym słowie kluczowym w Javie, jak i gdzie ich używać na przykładach.
to słowo kluczowe
W Javie to słowo kluczowe służy do odwoływania się do bieżącego obiektu wewnątrz metody lub konstruktora. Na przykład,
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); ) )
Wyjście :
this reference = Main @ 23fc625e object reference = Main @ 23fc625e
W powyższym przykładzie utworzyliśmy obiekt o nazwie obj z klasy Main. Następnie drukujemy odniesienie do obiektu obj i thissłowa kluczowego klasy.
Tutaj widzimy, że odniesienie zarówno obj, jak i thisjest takie samo. Oznacza to, że jest to nic innego jak odniesienie do bieżącego obiektu.
Użycie tego słowa kluczowego
Istnieją różne sytuacje, w których thissłowo kluczowe jest często używane.
Używanie tego dla nazw zmiennych niejednoznacznych
W Javie nie można zadeklarować dwóch lub więcej zmiennych o tej samej nazwie wewnątrz zakresu (zakresu klasy lub zakresu metody). Jednak zmienne instancji i parametry mogą mieć tę samą nazwę. Na przykład,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
W powyższym programie zmienna instancji i parametr mają taką samą nazwę: wiek. W tym przypadku kompilator Java jest zdezorientowany z powodu niejednoznaczności nazwy.
W takiej sytuacji używamy tego słowa kluczowego. Na przykład,
Najpierw zobaczmy przykład bez użycia thissłowa kluczowego:
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); ) )
Wyjście :
mc.age = 0
W powyższym przykładzie przekazaliśmy 8jako wartość do konstruktora. Jednak otrzymujemy 0jako wyjście. Dzieje się tak, ponieważ kompilator języka Java jest zdezorientowany z powodu niejednoznaczności nazw między wystąpieniem zmiennej a parametrem.
Teraz przepiszmy powyższy kod za pomocą thissłowa kluczowego.
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); ) )
Wyjście :
obj.age = 8
Teraz otrzymujemy oczekiwany wynik. Dzieje się tak, ponieważ po wywołaniu konstruktora thiswewnątrz konstruktora jest zastępowany obiekt obj, który wywołał konstruktora. Stąd zmiennej wieku przypisuje się wartość 8.
Ponadto, jeśli nazwa parametru i zmiennej wystąpienia jest inna, kompilator automatycznie dołącza to słowo kluczowe. Na przykład kod:
class Main ( int age; Main(int i) ( age = i; ) )
jest równa:
class Main ( int age; Main(int i) ( this.age = i; ) )
to z Getters i Setters
Innym powszechnym zastosowaniem thissłowa kluczowego są metody ustawiające i pobierające klasy. Na przykład:
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()); ) )
Wyjście :
obj.name: Toshiba
Tutaj użyliśmy thissłowa kluczowego:
- przypisać wartość wewnątrz metody ustawiającej
- aby uzyskać dostęp do wartości wewnątrz metody pobierającej
Używanie tego w przeciążaniu konstruktora
Podczas pracy z przeciążeniem konstruktora może być konieczne wywołanie jednego konstruktora z innego konstruktora. W takim przypadku nie możemy jawnie wywołać konstruktora. Zamiast tego musimy użyć thissłowa kluczowego.
Tutaj używamy innej formy tego słowa kluczowego. To znaczy this(). Weźmy przykład,
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); ) )
Wyjście :
2 + 3i 3 + 3i 0 + 0i
W powyższym przykładzie użyliśmy thissłowa kluczowego,
- aby wywołać konstruktora
Complex(int i, int j)z konstruktoraComplex(int i) - aby wywołać konstruktora
Complex(int i)z konstruktoraComplex()
Zwróć uwagę na linię,
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); ) )
Wyjście :
Przed przekazaniem tego do metody addTwo (): x = 1, y = -2 Po przekazaniu tego do metody addTwo (): x = 3, y = 0
W powyższym przykładzie wewnątrz konstruktora ThisExample()zwróć uwagę na linię,
add(this);
Tutaj wywołujemy add()metodę, przekazując ją jako argument. Ponieważ to słowo kluczowe zawiera odniesienie do obiektu obj klasy, możemy zmienić wartość x i y wewnątrz add()metody.
