Java ang keyword na ito

Sa CodeGym, ang mga mag-aaral ay ipinakilala sa Java ang keyword na ito nang literal mula sa mga unang aralin. Sa paglipas ng panahon, nagiging malinaw ang kahulugan nito. Ngunit sa pagbabalik-tanaw, maraming tao ang malamang na umamin sa kanilang sarili na sa mahabang panahon ay hindi nila maintindihan ang Zen ng keyword na ito. Ibabalik ng artikulong ito ang kurtinang sumasaklaw sa mga lihim ng keyword na ito para sa sinumang hindi pa nakakagawa nito... Mayroon akong sanggunian sa Java ni Schildt , pagkatapos ay sa pahina 171 makikita mo na ang keyword na ito ay kinakailangan para sa isang paraan upang sumangguni sa bagay na tumawag dito. Maaari naming tapusin ang aralin na iyon. Ngunit kailangan namin ng mga detalye. Bilang isang tuntunin, kailangan mong gamitin ito sa dalawang kaso:

1. Kapag ang variable ng instance at variable ng method/constructor ay may parehong pangalan;
2. Kapag kailangan mong tumawag ng isang partikular na uri ng constructor (halimbawa, isang default na constructor o parameterized constructor) mula sa isa pang uri ng constructor. Ito ay tinatawag ding isang tahasang constructor call.

At iyon lang ang tungkol dito — may dalawang kaso lang kung saan ginagamit ang nakakatakot na keyword na ito. Ngayon tingnan natin ang dalawang kaso na ito sa mga halimbawa.

Halimbawa 1: Ang variable ng instance at variable ng method ay may parehong pangalan.

Ipagpalagay na mayroon tayong klase ng Tao na tumutukoy sa field ng pangalan: Gumawa tayo ng setter para sa variable ng pangalan (fully functional ang setter — walang catch dito):

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

Tandaan na ipinapasa namin ang String newName sa setName setter method Nagdeklara kami ng bagong variable at maaaring pinangalanan ito kahit anong gusto namin dahil makikita lang ito sa loob ng curly braces ({}) na nakapaloob sa setName method. Tandaan na ang setter ay may isang linya:

name = newName;

Dito namin ipinakilala ang isang bagong variable na tinatawag na newName at itinalaga ito sa umiiral na variable ng pangalan ng object . Maaaring makita ng maraming programmer na kakaiba ang magpakilala ng variable na may bagong pangalan kapag sa huli ay pareho ang pinag-uusapan natin. Ibig sabihin, pinag-uusapan natin ang field ng pangalan sa klase ng Tao . Iyon ang dahilan kung bakit nag-isip ang mga tagalikha ng Java ng paraan upang maginhawang gamitin ang parehong variable na pangalan. Sa madaling salita, bakit may dalawang pangalan para sa isang variable na nagsasaad ng parehong bagay. Sa madaling salita, gusto naming gawin ang isang bagay tulad nito:

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

Ngunit narito kami ay nakatagpo ng isang problema . Mayroon na tayong dalawang variable na may parehong pangalan. Ang isang pangalan ng String ay kabilang sa klase ng Tao , habang ang isa pang pangalan ng String ay kabilang sa pamamaraang setName nito . Bilang resulta, hindi malalaman ng JVM kung aling variable ang iyong tinutukoy kapag isinulat mo ang sumusunod na linya sa setter:

name = name;

Ipinapalagay ng Java na ang ibig mong sabihin ay ang pinakamalapit na variable ng pangalan , ibig sabihin, ang isa mula sa setName method: Kaya lumalabas na itinatalaga mo lang ang variable ng pangalan ng pamamaraan sa sarili nito. Na siyempre ay walang kahulugan. Samakatuwid, ang wika ay nangangailangan ng ilang paraan upang makilala ang variable ng pangalan ng klase ng Human mula sa variable ng pangalan sa setName method. Nalutas ang problemang ito sa pamamagitan ng pagpapakilala ng keyword na ito , na sa kasong ito ay nagpapahiwatig na nilayon mong i-reference ang variable na nauugnay sa isang halimbawa ng klase ng Tao , hindi ang variable sa pamamaraan: Sa madaling salita, itoay tumutukoy sa bagay na tumatawag, gaya ng binanggit namin sa simula ng artikulo. Bilang resulta, ang setName method ay nagtatakda ng pangalan ng tao sa nilikhang bagay. Nasa ibaba ang code ng programa nang hindi ginagamit ang keyword na ito . Lumilikha ang code ng Human object at nagtatalaga ng pangalan dito: At narito ang code na may ganitong keyword:

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        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, ito ay nagbibigay-daan sa amin na maiwasan ang pagpapakilala ng mga bagong variable upang tukuyin ang parehong bagay, na ginagawang mas malinis ang code at hindi gaanong kalat ng mga karagdagang variable.

Halimbawa 2: Paggamit nito para sa isang tahasang constructor na tawag

Ang pagtawag sa isang constructor mula sa isa pa ay maaaring maging kapaki-pakinabang kapag mayroon kang (kakaibang sapat) na maramihang mga constructor at hindi mo nais na ang bagong constructor ay duplicate ang initialization code na dating nakasulat sa ibang constructor. nalilito? Hindi ito nakakatakot gaya ng tila. Tingnan ang code sa ibaba. Mayroon itong dalawang konstruktor para sa klase ng Tao :

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) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

Dito una kaming nagbigay ng isang constructor na may dalawang parameter: int age at int weight . Ipagpalagay na mayroon itong dalawang linya ng code:

this.age = age;
this.weight = weight;

Sa paglaon, nagpasya kaming magdagdag ng isa pang konstruktor na may tatlong mga parameter, pagdaragdag ng taas sa umiiral na mga parameter ng edad at timbang. Maaari mong isulat ang bagong tagabuo tulad nito:

this.age = age;
this.weight = weight;
this.height = height;

Ngunit sa halip na ulitin ang umiiral na code sa constructor na ito, maaari mong gamitin ang keyword na ito upang tahasang tawagan ang constructor na may dalawang parameter:

this(age, weight);
// and then initialize the missing variable:
this.height = height;

Para bang sinasabi natin sa tatlong-parameter na tagabuo:

• tawagan itong ibang constructor na may dalawang parameter
• at pagkatapos ay magdagdag ng isa pang variable.

Yun lang =). Sa wakas, tandaan namin na sa Java ang keyword na ito ay ginagamit lamang sa mga pamamaraan at constructor. Ngunit ito ay implicitly na ipinapasa sa lahat ng non-static na pamamaraan (kaya naman madalas itong tinatawag na implicit na parameter) at maaaring gamitin upang sumangguni sa object na tinatawag na method. Huwag matakot sa keyword na ito, dahil hindi ito nakakatakot.