Pokazivač this

by
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.
  1. this može biti upotrebljen da uputi na instacnu promenljivu tekuće klase.
  2. this() može biti upotrebljen da pozove konstruktor tekuće klase.
  3. this može biti upotrebljen da pozove metod tekuće klase (implicitno).
  4. this može biti prosleđen kao argument u pozivu metode.
  5. this može biti prosleđen kao argument u pozivu konstruktora.
  6. this može takođe biti upotrebljen da vrati instancu tekuće klase.
Napomena: Početnici u Javi ne bi trebalo da koriste više od dve od ovih upotreba pokazivača this.

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
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:
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
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:
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
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.
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
Pravilo: Poziv this() mora biti prva naredba u konstruktoru.
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
Kada this ne može biti prosleđen kao argument? U rukovanju događajima ili u situaciji gde moramo obezbediti referencu klase drugoj klasi.

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; 
}
Primjer pokazivača this koji se vraća kao naredba metode:
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

Comments

comments

Leave a Comment