Sok haszna lehet Java ezt a kulcsszót . Java nyelven ez a referencia változó amely az aktuális objektumra vonatkozik.

A kulcsszó Java használata

Itt van megadva a java 6 használata ennek a kulcsszónak.

1. ez használható az aktuális osztálypéldányváltozóra való hivatkozásra.
2. ez használható az aktuális osztálymetódus meghívására (implicit módon)
3. this() használható az aktuális osztálykonstruktor meghívására.
4. ez argumentumként adható át a metódushívásban.
5. ez argumentumként adható át a konstruktorhívásban.
6. ezzel visszaadható az aktuális osztálypéldány a metódusból.

Javaslat: Ha Ön kezdő java, akkor ennek a kulcsszónak csak három felhasználási módját keresse.

1) ez: az aktuális osztálypéldányváltozóra való hivatkozás

A this kulcsszó az aktuális osztálypéldányváltozóra hivatkozhat. Ha kétértelműség van a példányváltozók és a paraméterek között, ez a kulcsszó megoldja a kétértelműség problémáját.

A probléma megértése e kulcsszó nélkül

Értsük meg a problémát, ha nem használjuk ezt a kulcsszót az alábbi példában:

int duplázni

 class Student{ int rollno; String name; float fee; Student(int rollno,String name,float fee){ rollno=rollno; name=name; fee=fee; } void display(){System.out.println(rollno+' '+name+' '+fee);} } class TestThis1{ public static void main(String args[]){ Student s1=new Student(111,'ankit',5000f); Student s2=new Student(112,'sumit',6000f); s1.display(); s2.display(); }} 

Kimenet:

 0 null 0.0 0 null 0.0 

A fenti példában a paraméterek (formális argumentumok) és a példányváltozók megegyeznek. Tehát ezt a kulcsszót használjuk a helyi változó és a példányváltozó megkülönböztetésére.

A fenti probléma megoldása ezzel a kulcsszóval

 class Student{ int rollno; String name; float fee; Student(int rollno,String name,float fee){ this.rollno=rollno; this.name=name; this.fee=fee; } void display(){System.out.println(rollno+' '+name+' '+fee);} } class TestThis2{ public static void main(String args[]){ Student s1=new Student(111,'ankit',5000f); Student s2=new Student(112,'sumit',6000f); s1.display(); s2.display(); }} 

Kimenet:

 111 ankit 5000.0 112 sumit 6000.0 

Ha a helyi változók (formális argumentumok) és a példányváltozók különböznek, akkor nincs szükség a kulcsszó használatára, mint a következő programban:

Program, ahol ez a kulcsszó nem kötelező

 class Student{ int rollno; String name; float fee; Student(int r,String n,float f){ rollno=r; name=n; fee=f; } void display(){System.out.println(rollno+' '+name+' '+fee);} } class TestThis3{ public static void main(String args[]){ Student s1=new Student(111,'ankit',5000f); Student s2=new Student(112,'sumit',6000f); s1.display(); s2.display(); }} 

Kimenet:

 111 ankit 5000.0 112 sumit 6000.0 

Jobb megközelítés értelmes neveket használni a változókhoz. Tehát valós időben ugyanazt a nevet használjuk például változókhoz és paraméterekhez, és mindig ezt a kulcsszót használjuk.

2) ez: az aktuális osztálymetódus meghívása

Az aktuális osztály metódusát a this kulcsszó használatával hívhatja meg. Ha nem használja ezt a kulcsszót, a fordító automatikusan hozzáadja ezt a kulcsszót a metódus meghívásakor. Lássuk a példát

 class A{ void m(){System.out.println('hello m');} void n(){ System.out.println('hello n'); //m();//same as this.m() this.m(); } } class TestThis4{ public static void main(String args[]){ A a=new A(); a.n(); }} 

Kimenet:

 hello n hello m 

3) this() : az aktuális osztálykonstruktor meghívása

A this() konstruktorhívással meghívható az aktuális osztálykonstruktor. A konstruktor újrafelhasználására szolgál. Más szóval, konstruktor láncolására használják.

Az alapértelmezett konstruktor hívása a paraméterezett konstruktorból:

java összefűzött karakterláncok

 class A{ A(){System.out.println('hello a');} A(int x){ this(); System.out.println(x); } } class TestThis5{ public static void main(String args[]){ A a=new A(10); }} 

Kimenet:

c logikai érték

 hello a 10 

Paraméterezett konstruktor hívása az alapértelmezett konstruktorból:

 class A{ A(){ this(5); System.out.println('hello a'); } A(int x){ System.out.println(x); } } class TestThis6{ public static void main(String args[]){ A a=new A(); }} 

Kimenet:

 5 hello a 

A(z) konstruktorhívás valódi használata

A this() konstruktorhívást a konstruktorból származó konstruktor újrafelhasználásához kell használni. Fenntartja a láncot a konstruktorok között, azaz konstruktor láncolására használják. Lássuk az alábbi példát, amely a kulcsszó tényleges használatát mutatja be.

 class Student{ int rollno; String name,course; float fee; Student(int rollno,String name,String course){ this.rollno=rollno; this.name=name; this.course=course; } Student(int rollno,String name,String course,float fee){ this(rollno,name,course);//reusing constructor this.fee=fee; } void display(){System.out.println(rollno+' '+name+' '+course+' '+fee);} } class TestThis7{ public static void main(String args[]){ Student s1=new Student(111,'ankit','java'); Student s2=new Student(112,'sumit','java',6000f); s1.display(); s2.display(); }} 

Kimenet:

 111 ankit java 0.0 112 sumit java 6000.0 

Szabály: A this() hívásnak az első utasításnak kell lennie a konstruktorban.

 class Student{ int rollno; String name,course; float fee; Student(int rollno,String name,String course){ this.rollno=rollno; this.name=name; this.course=course; } Student(int rollno,String name,String course,float fee){ this.fee=fee; this(rollno,name,course);//C.T.Error } void display(){System.out.println(rollno+' '+name+' '+course+' '+fee);} } class TestThis8{ public static void main(String args[]){ Student s1=new Student(111,'ankit','java'); Student s2=new Student(112,'sumit','java',6000f); s1.display(); s2.display(); }} 

Kimenet:

 Compile Time Error: Call to this must be first statement in constructor 

4) ez: argumentumként átadni a metódusban

A this kulcsszó argumentumként is átadható a metódusban. Főleg eseménykezelésben használják. Lássuk a példát:

 class S2{ void m(S2 obj){ System.out.println('method is invoked'); } void p(){ m(this); } public static void main(String args[]){ S2 s1 = new S2(); s1.p(); } } 

Kimenet:

 method is invoked 

Ennek érvként átadható alkalmazása:

Eseménykezelésben (vagy) olyan helyzetben, amikor egy osztályra hivatkoznunk kell egy másikra. Egy objektum újrafelhasználására szolgál számos módszerben.

5) ez: argumentumként átadni a konstruktorhívásban

A konstruktorban is átadhatjuk ezt a kulcsszót. Hasznos, ha egy objektumot több osztályban kell használnunk. Lássuk a példát:

python konvertálja a bájtokat karakterláncokká

 class B{ A4 obj; B(A4 obj){ this.obj=obj; } void display(){ System.out.println(obj.data);//using data member of A4 class } } class A4{ int data=10; A4(){ B b=new B(this); b.display(); } public static void main(String args[]){ A4 a=new A4(); } } 

 Output:10 

6) ez a kulcsszó az aktuális osztálypéldány visszaadására használható

Ezt a kulcsszót visszaadhatjuk a metódus utasításaként. Ebben az esetben a metódus visszatérési típusának az osztálytípusnak kell lennie (nem primitív). Lássuk a példát:

Ennek utasításként visszaadható szintaxisa

 return_type method_name(){ return this; } 

Példa erre a kulcsszóra, amelyet utasításként ad vissza a metódusból

 class A{ A getA(){ return this; } void msg(){System.out.println('Hello java');} } class Test1{ public static void main(String args[]){ new A().getA().msg(); } } 

Kimenet:

 Hello java 

Ennek a kulcsszónak a bizonyítása

Bizonyítsuk be, hogy ez a kulcsszó az aktuális osztálypéldányváltozóra vonatkozik. Ebben a programban a referenciaváltozót nyomtatjuk ki, és ez mindkét változó kimenete megegyezik.

 class A5{ void m(){ System.out.println(this);//prints same reference ID } public static void main(String args[]){ A5 obj=new A5(); System.out.println(obj);//prints the reference ID obj.m(); } } 

Kimenet:

 A5@22b3ea59 A5@22b3ea59