V tomto článku se dozvíme o tomto klíčovém slovu v Javě, jak a kde je použít pomocí příkladů.
toto klíčové slovo
V jazyce Java se toto klíčové slovo používá k označení aktuálního objektu uvnitř metody nebo konstruktoru. Například,
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); ) )
Výstup :
this reference = Main @ 23fc625e reference objektu = Main @ 23fc625e
Ve výše uvedeném příkladu jsme vytvořili objekt s názvem obj třídy Main. Potom vytiskneme odkaz na objekt obj a thisklíčové slovo třídy.
Zde vidíme, že reference obou obj a thisje stejná. To znamená, že to není nic jiného než odkaz na aktuální objekt.
Použití tohoto klíčového slova
thisKlíčové slovo se běžně používá v různých situacích .
Používá se pro názvy proměnných nejednoznačnosti
V Javě není povoleno deklarovat dvě nebo více proměnných se stejným názvem uvnitř oboru (rozsah třídy nebo rozsah metody). Proměnné instance a parametry však mohou mít stejný název. Například,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Ve výše uvedeném programu mají proměnná instance a parametr stejný název: age. Zde je kompilátor Java zmatený kvůli nejednoznačnosti názvu.
V takové situaci používáme toto klíčové slovo. Například,
Nejprve se podívejme na příklad bez použití thisklíčového slova:
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); ) )
Výstup :
mc.age = 0
Ve výše uvedeném příkladu jsme předali 8jako hodnotu konstruktoru. Dostáváme se však 0jako výstup. Je to proto, že kompilátor Java je zmatený kvůli nejednoznačnosti názvů mezi instancí proměnné a parametru.
Nyní přepíšeme výše uvedený kód pomocí thisklíčového slova.
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); ) )
Výstup :
obj.age = 8
Nyní získáváme očekávaný výstup. Je to proto, že když se volá konstruktor, thisuvnitř konstruktoru se nahradí objekt obj, který zavolal konstruktor. Proto je proměnné věku přiřazena hodnota 8.
Pokud se název parametru a proměnné instance liší, překladač automaticky připojí toto klíčové slovo. Například kód:
class Main ( int age; Main(int i) ( age = i; ) )
odpovídá:
class Main ( int age; Main(int i) ( this.age = i; ) )
to s Gettery a Settery
Další běžné použití thisklíčového slova je v metodách setterů a getrů ve třídě. Například:
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()); ) )
Výstup :
obj. název: Toshiba
Zde jsme použili thisklíčové slovo:
- přiřadit hodnotu uvnitř metody setter
- pro přístup k hodnotě uvnitř metody getru
Pomocí tohoto v Přetížení konstruktoru
Při práci s přetížením konstruktoru možná budeme muset vyvolat jeden konstruktor z jiného konstruktoru. V takovém případě nemůžeme konstruktor explicitně zavolat. Místo toho musíme použít thisklíčové slovo.
Zde používáme jinou formu tohoto klíčového slova. To znamená, že this(). Vezměme si příklad,
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); ) )
Výstup :
2 + 3i 3 + 3i 0 + 0i
Ve výše uvedeném příkladu jsme použili thisklíčové slovo,
- volat konstruktor
Complex(int i, int j)z konstruktoruComplex(int i) - volat konstruktor
Complex(int i)z konstruktoruComplex()
Všimněte si řádku,
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); ) )
Výstup :
Před předáním této metodě addTwo (): x = 1, y = -2 Po předání této metodě addTwo (): x = 3, y = 0
Ve výše uvedeném příkladu si uvnitř konstruktoru ThisExample()všimněte řádku,
add(this);
Zde voláme add()metodu předáním jako argument. Protože toto klíčové slovo obsahuje odkaz na objekt obj třídy, můžeme změnit hodnotu xay uvnitř add()metody.
