Sa JavaRush, literal na ipinakilala ang mga mag-aaral sa keyword mula sa mga unang lektura
at lumalabas na nagtalaga ka lang ng halaga sa isang variable
Iyon ay,
At sa ibaba ay ang program code na may keyword
this
. At sa paglipas ng panahon ay nagiging malinaw kung ano ang ibig sabihin nito. Ngunit marami, sa pagbabalik-tanaw, ay malamang na matapat na sasabihin sa kanilang sarili na sa loob ng mahabang panahon ay hindi nila napagtanto ang zen ng susing salita na ito. Sa artikulong ito itinaas namin ang belo ng mga lihim tungkol sa paggamit ng mga keyword this
para sa mga hindi pa rin maisip ito... Maligayang pagdating! Kung kukunin mo ang Schildt's Java reference book , sa pahina 171 mababasa mo na ang isang keyword this
ay kinakailangan upang ang isang paraan ay maaaring sumangguni sa bagay na tumawag dito. Maaaring ito na talaga ang katapusan nito. Ngunit kailangan namin ng mga detalye. Bilang isang patakaran, this
dapat itong gamitin sa dalawang kaso:
- Kapag ang variable ng instance ng klase at variable ng method/constructor ay may parehong pangalan;
- Kapag kailangan mong tumawag sa isang constructor ng isang uri (halimbawa, isang default o parameterized constructor) mula sa isa pa. Ito ay tinatawag ding isang tahasang constructor call.
Halimbawa ng isa - ang variable ng instance at variable ng pamamaraan ay may parehong pangalan
Sabihin nating mayroon tayong klaseHuman
kung saan tinukoy ang field na "pangalan": Gumawa tayo name
ng setter para sa variable (ang setter ay medyo gumagana at walang trick dito): Mangyaring tandaan na ipinapasa namin ang variable sa pamamaraan (setter ) . Nagpakilala kami ng bagong variable at (sa pangkalahatan) ay maaaring tawagin ito kahit anong gusto namin dahil makikita lang ito sa loob ng {curly braces} ng method . Pansinin na mayroong isang linya sa setter: setName
String newName
setName
name = newName;
Ibig sabihin, sa katunayan, nagpakilala kami ng bagong variable newName
at itinalaga ito sa isang variable na mayroon na sa klase name
. Maraming mga programmer ang nag-isip na kakaiba na magpakilala ng isang variable na may bagong pangalan kung sa huli ay pareho ang pinag-uusapan natin. Tungkol sa pangalan sa klase Human
. Samakatuwid, naisip ng mga developer ng wika na gawing maginhawa ang paggamit ng isang variable na pangalan. Sa madaling salita, bakit may dalawang pangalan para sa isang variable na pareho ang ibig sabihin. Iyon ay, gusto kong gawin ang isang bagay na tulad nito: Ngunit sa kasong ito ay lumitaw ang isang problema . Mayroon na tayong dalawang variable na pareho ang pangalan. Ang isa String name
ay kabilang sa klase Human
, at ang isa String name
ay sa pamamaraan nito setName
. Samakatuwid, hindi alam ng Java machine kung aling variable ang ibig mong sabihin kapag sumulat ka ng string sa isang setter:
name = name;
Kinukuha ng Java ang pinakamalapit - name
mula sa pamamaraan setName
:
name
mula sa pamamaraang ito, dito. Na siyempre ay walang kahulugan. Samakatuwid, kailangan ang ilang paraan upang makilala ang isang variable name
mula sa isang klase Human
mula sa isang variable name
mula sa isang pamamaraan setName
. Upang malutas ang problemang ito, ang keyword ay ipinakilala this
, na sa kasong ito ay magsasaad na ito ay kinakailangan upang tumawag ng isang variable hindi ng isang paraan, ngunit ng isang klase Human
:
this
ito ay tumutukoy sa bagay sa pagtawag, tulad ng sinabi sa simula ng artikulo. Bilang resulta, ang pangalan ng tao setName
ay itatakda sa pamamagitan ng setter sa nilikhang bagay. Nasa ibaba ang code nang hindi gumagamit ng keyword this
. Lumilikha ang code ng object ng klase Human
at binibigyan ito ng pangalan:
this
:
public class Solution{
public static void main(String[] args) {
Human human1 = new Human();
human1.setName("Volodya");
human1.print();
}
}
class Human{
String name;
public String getName() {
return name;
}
public void setName(String name){
this.name = name;
}
void print(){
System.out.println(name);
}
}
Kaya, this
iniiwasan nito ang pagpapakilala ng mga bagong variable upang tukuyin ang parehong bagay, na ginagawang mas "sobrang karga" ang code sa mga karagdagang variable.
Ikalawang Halimbawa - Gamit ito para tahasang tumawag sa isang constructor
Ang pagtawag sa isang constructor mula sa isa pa ay maaaring maging kapaki-pakinabang kapag ikaw (kakaiba) ay may ilang mga constructor at hindi mo nais na muling isulat ang initialization code na ibinigay nang mas maaga sa constructor sa isang bagong constructor. nalilito? Ang lahat ay hindi nakakatakot gaya ng tila. Tingnan ang code sa ibaba, mayroon itong dalawang konstruktor ng klaseHuman
:
class Human{
int age;
int weight;
int height;
Human(int age, int weight){
this.age = age;
this.weight = weight;
}
Human(int age, int weight, int height){
//you call the constructor with two parameters
this(age, weight);
//and add the missing variable
this.height = height;
}
}
Dito, mayroon muna tayong dalawang parameter na tagabuo na tumatanggap int age
at int weight
. Sabihin nating sumulat kami ng dalawang linya ng code dito:
this.age = age;
this.weight = weight;
at pagkatapos ay nagpasya silang magdagdag ng isa pang konstruktor, na may tatlong mga parameter, na, bilang karagdagan sa edad at timbang, ay tumatagal din ng taas. Sa bagong constructor maaari mong isulat ito:
this.age = age;
this.weight = weight;
this.height = height;
Ngunit sa halip na ulitin ang code na naisulat mo na sa constructor na ito, maaari kang gumamit ng keyword para this
tahasang tawagan ang constructor na may dalawang parameter:
this(age, weight);
// and add the missing variable:
this.height = height;
Kaya't sinasabi mo ang tagabuo na may tatlong mga parameter:
- tawagan ang constructor na ito, na mayroong dalawang parameter.
- at idagdag ang nawawalang variable.
this
ay ipinapasa sa lahat ng mga pamamaraan maliban sa mga static (kaya't this
madalas itong tinatawag na isang implicit na parameter) at maaaring gamitin upang sumangguni sa bagay na tinatawag na pamamaraan. Hindi kailangang matakot sa keyword na ito, dahil This
hindi ito nakakatakot.
GO TO FULL VERSION