Pokazivač this
Postoji više načina upotrebe pokazivača this. U Javi, ovo je referentna promenljiva koja upućuje na tekući objekat.
Upotreba pokazivača this: Ovde je dato 6 upotreba pokazivača this.
U ovom primeru, parametar (formalni argumenti) i instancne promenljive su iste, zbog čega koristimo pokazivač this da razlikujemo lokalnu promenljivu i instancnu promenljivu.
Rešenje problema pomoću pokazivača this:
Ako su lokalne promenljive (formalni argumenti) i instancne promenljive različite, nema potrebe da se koristi pokazivač this, kao u sledećem programu:
Program gdje pokazivač this nije potreban:
Gde se koristi this() poziv konstruktora? this() poziv konstruktora treba koristiti za ponovnu upotrebu (reuse) konstruktora u konstruktoru. On održava vezu između konstruktora tj. koristi se za ulančavanje konstruktora. Pogledajmo primer koji pokazuje stvarnu upotrebu pokazivača this.
Pravilo: Poziv this() mora biti prva naredba u konstruktoru.
Kada this ne može biti prosleđen kao argument? U rukovanju događajima ili u situaciji gde moramo obezbediti referencu klase drugoj klasi.
Primjer pokazivača this koji se vraća kao naredba metode:
- this može biti upotrebljen da uputi na instacnu promenljivu tekuće klase.
- this() može biti upotrebljen da pozove konstruktor tekuće klase.
- this može biti upotrebljen da pozove metod tekuće klase (implicitno).
- this može biti prosleđen kao argument u pozivu metode.
- this može biti prosleđen kao argument u pozivu konstruktora.
- this može takođe biti upotrebljen da vrati instancu tekuće klase.
1) Pokazivač this može se koristiti da uputi na instancnu promenljivu tekuće klase
Ako postoji dvosmislenost između instancne promenljive i parametra, ključna reč this rešava problem dvosmislenosti. Problem koji se javlja bez pokazivača this: Sledeći primer objašnjava koji se problem javlja ako se ne koristi pokazivač this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 |
class Student10{ int id; String name; Student10( int id,String name){ id = id; name = name; } void display(){System.out.println(id+ " " +name);} public static void main(String args[]){ Student10 s1 = new Student10( 111 , "Petar" ); Student10 s2 = new Student10( 321 , "Marko" ); s1.display(); s2.display(); } } Ispis na ekranu: 0 null 0 null |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 |
// primjer za pokazivač this class Student11{ int id; String name; Student11( int id,String name){ this .id = id; this .name = name; } void display(){System.out.println(id+ " " +name);} public static void main(String args[]){ Student11 s1 = new Student11( 111 , "Petar" ); Student11 s2 = new Student11( 222 , "Marko" ); s1.display(); s2.display(); } } Ispis na ekranu: 111 Petar 222 Marko |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 |
class Student12{ int id; String name; Student12( int i,String n){ id = i; name = n; } void display(){System.out.println(id+ " " +name);} public static void main(String args[]){ Student12 e1 = new Student12( 111 , "Petar" ); Student12 e2 = new Student12( 222 , "Marko" ); e1.display(); e2.display(); } } Ispis na ekranu: 111 Petar 222 Marko |
2) this() može biti upotrebljen da pozove konstruktor tekuće klase
this() poziv konstruktora može se koristiti da pozove konstruktor tekuće klase (ulančavanje konstruktora). Ovaj pristup je bolji ako u klasi ima mnogo konstruktora, a želi se ponovna upotreba tog konstruktora.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 |
// Program za this() poziv konstruktora (ulančavanje konstruktora) class Student13{ int id; String name; Student13(){System.out.println( "default konstruktor je pozvan" );} Student13( int id,String name){ this (); // koristi se da pozove konstruktor tekuće klase this .id = id; this .name = name; } void display(){System.out.println(id+ " " +name);} public static void main(String args[]){ Student13 e1 = new Student13( 111 , "Petar" ); // pri dodjeli vrijednosti poziva konstruktor sa 2 parametra, te ispisuje default konstruktor je pozvan Student13 e2 = new Student13( 222 , "Marko" ); // pri dodjeli vrijednosti poziva konstruktor sa 2 parametra, te ispisuje default konstruktor je pozvan e1.display(); e2.display(); } } Ispis na ekranu: default konstruktor je pozvan default konstruktor je pozvan 111 Petar 222 Marko |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 |
class Student14{ int id; String name; String city; Student14( int id,String name){ this .id = id; this .name = name; } Student14( int id,String name,String city){ this (id,name); // sada nema potrebe da se inicijalizuje id i name this .city=city; } void display(){System.out.println(id+ " " +name+ " " +city);} public static void main(String args[]){ Student14 e1 = new Student14( 111 , "Petar" ); Student14 e2 = new Student14( 222 , "Marko" , "Beograd" ); e1.display(); e2.display(); } } Ispis na ekranu: 111 Petar null 222 Marko Beograd |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 |
class Student15{ int id; String name; Student15(){System.out.println( "default konstruktor je pozvan" );} Student15( int id,String name){ id = id; name = name; this (); // mora biti prva naredba } void display(){System.out.println(id+ " " +name);} public static void main(String args[]){ Student15 e1 = new Student15( 111 , "Petar" ); Student15 e2 = new Student15( 222 , "Marko" ); e1.display(); e2.display(); } } Ispis na ekranu: Compile Time Error |
3) this može biti upotrebljen da pozove metod tekuće klase (implicitno)
Moguće je pozvati metod tekuće klase pomoću ključne riječi this. Ako se ne upotrebi pokazivač this, kompajler će automatski dodati pokazivač this dok poziva metod. Pogledajmo primer:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 |
class S{ void m(){ System.out.println( "metod je pozvan" ); } void n(){ this .m(); // nije potrebno zato što kompajler to uradi sam. } void p(){ n(); // kompajler će dodati this da pozove n() metod kao this.n() } public static void main(String args[]){ S s1 = new S(); s1.p(); } } Ispis na ekranu: metod je pozvan |
4) Pokazivač this može se proslediti kao argument u metodi
Pokazivač this može takođe biti prosleđen kao argument u metodi. Ovo se uglavnom koristi u rukovanju događajima. Pogledajmo primer:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 |
class S2{ void m(S2 obj){ System.out.println( "metod je pozvan" ); } void p(){ m( this ); } public static void main(String args[]){ S2 s1 = new S2(); s1.p(); } } Ispis na ekranu: metod je pozvan |
5) this može biti prosleđen kao argument u pozivu konstruktora
Pokazivač this se takođe može proslediti u konstruktoru. Korisno je ako možemo upotrebiti jedan objekt u više klasa. Pogledajmo primer:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 |
class B{ A4 obj; B(A4 obj){ this .obj=obj; } void display(){ System.out.println(obj.data); // upotreba podatka-člana klase A4 } } class A4{ int data= 10 ; A4(){ B b= new B( this ); b.display(); } public static void main(String args[]){ A4 a= new A4(); } } Ispis na ekranu: 10 |
6) Pokazivač this se može upotrebiti da vrati instancu tekuće klase
Pokazivač this možemo vratiti kao naredbu iz metode. U tom slučaju, vraćeni (return) tip metode mora biti tip klase (ne-primitivan). Pogledajmo primjer: Sintaksa za this koji može biti vraćen kao naredba:
1
2
3 |
return_type method_name(){ return this ; } |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 |
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(); } } Ispis na ekranu: Hello java |
Dokazivanje pokazivača this
Dokažimo da pokazivač this upućuje na instancnu promenljivu tekuće klase. U ovom programu, ispisujemo referentnu promenljivu i this, izlaz obe promenljive je isti.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 |
class A5{ void m(){ System.out.println( this ); // ispisuje ID iste reference } public static void main(String args[]){ A5 obj= new A5(); System.out.println(obj); // ispisuje ID reference obj.m(); } } Ispis na ekranu: A5 @22b3ea59 A5 @22b3ea59 |