1. Panimula
Nais naming italaga ang aralin ngayon sa encapsulation . Alam mo na kung ano ito sa mga pangkalahatang tuntunin.
Ano ang mga pakinabang ng encapsulation? Marami sa kanila, ngunit maaari kong iisa ang apat na, sa palagay ko, ay ang mga pangunahing:
2. Wastong panloob na estado
Sa mga programa, madalas na lumitaw ang mga sitwasyon kapag ang isang bagay ay nakikipag-ugnayan sa ilang iba pang mga klase. Ang mga pakikipag-ugnayang ito sa object ay maaaring masira ang data sa loob ng object, na ginagawang imposible para sa object na patuloy na gumana tulad ng inaasahan.
Bilang resulta, kailangang subaybayan ng object ang anumang mga pagbabago sa panloob na data nito, o mas mabuti pa, gawin ang mga pagbabago mismo.
Kung hindi namin nais na baguhin ng ibang mga klase ang ilang variable, idineklara namin itong pribado. Kapag ginawa namin iyon, tanging ang mga pamamaraan ng sarili nitong klase ang makaka-access dito. Kung gusto nating maging read-only ang mga variable, kailangan nating magdagdag ng isang public getterpara sa mga nauugnay na variable.
Halimbawa, ipagpalagay na gusto naming malaman ng lahat ang bilang ng mga elemento sa aming koleksyon, ngunit hindi namin nais na baguhin nila ang koleksyon nang walang pahintulot namin. Pagkatapos ay ipinapahayag namin ang isang private int countvariable at isang public getCount()pamamaraan.
Tinitiyak ng wastong paggamit ng encapsulation na walang klase ang direktang makaka-access sa panloob na data ng aming klase, na samakatuwid ay pumipigil sa anumang mga pagbabagong hindi namin kontrolado. Ang mga pagbabagong ito ay posible lamang sa pamamagitan ng pagtawag sa mga pamamaraan ng parehong klase bilang mga variable na binago.
Pinakamainam na ipagpalagay na palaging gagamitin ng ibang programmer ang iyong mga klase sa paraang pinakakombenyente para sa kanila, hindi sa paraang pinakaligtas para sa iyo (para sa iyong klase). Ang pag-uugali na ito ay ang pinagmulan ng parehong mga bug pati na rin ang mga pagtatangka na pigilan ang mga ito.
3. Pagpapatunay ng mga argumento ng pamamaraan
Minsan kailangan nating patunayan ang mga argumentong ipinasa sa ating mga pamamaraan. Halimbawa, sabihin nating mayroon kaming klase na kumakatawan sa isang tao at hinahayaan kang magtakda ng petsa ng kapanganakan. Dapat nating suriin ang lahat ng data ng pag-input upang matiyak na may katuturan ito sa lohika ng programa at sa lohika ng ating klase. Halimbawa, hindi payagan ang petsa ng kapanganakan sa ika-13 buwan o noong Pebrero 30, at iba pa.
Bakit sasabihin ng isang tao ang Pebrero 30 para sa kanilang petsa ng kapanganakan? Una, maaaring ito ay isang error ng user kapag naglalagay ng data. Pangalawa, ang isang programa ay maaaring magkaroon ng maraming mga error sa loob nito bago ito magsimulang tumakbo tulad ng orasan. Halimbawa, posible ang sumusunod na sitwasyon.
Ang isang programmer ay nagsusulat ng isang programa na tumutukoy sa mga tao na ang kaarawan ay kinabukasan. Halimbawa, sabihin natin ngayon ay Marso 3. Ang programa ay nagdaragdag ng numero 2 sa kasalukuyang araw ng buwan at hinahanap ang lahat ng ipinanganak noong Marso 5. Mukhang tama ang lahat.
Ngunit pagdating ng Marso 30, ang programa ay hindi makakahanap ng sinuman, dahil ang kalendaryo ay walang Marso 32. Ang isang programa ay may mas kaunting mga error kung susuriin natin ang data na ipinasa sa mga pamamaraan.
Tandaan noong pinag-aralan ArrayListat sinuri natin ang code nito? Nakita namin na sinuri ng getat mga pamamaraan kung mas malaki o katumbas ng zero at mas mababa sa haba ng array. setindex Higit pa rito, ang mga pamamaraang ito ay nagtatapon ng eksepsiyon kung ang index ay nasa labas ng mga hangganan ng array. Ito ay isang klasikong halimbawa ng pagpapatunay ng input.
4. Pag-minimize ng mga error kapag nagpapalit ng code
Ipagpalagay na nagsulat kami ng isang napaka-kapaki-pakinabang na klase kapag kami ay kasangkot sa isang malaking proyekto. Nagustuhan ito ng lahat kaya sinimulan itong gamitin ng ibang mga programmer sa daan-daang lugar sa kanilang code.
Ang klase ay lubhang kapaki-pakinabang na nagpasya kang bigyan ito ng ilang mga pagpapabuti. Ngunit kung aalisin mo ang anumang mga pamamaraan mula sa klase, ang code ng dose-dosenang mga tao ay titigil sa pag-compile. Kailangan nilang muling isulat ang lahat. At kung mas maraming pagbabago ang gagawin mo, mas maraming error ang gagawin mo. Masisira mo ang maraming pagtitipon at kapopootan ka.
Ngunit kapag binago namin ang mga pamamaraan na idineklara bilang pribado, alam namin na walang isa pang klase saanman na maaaring tumatawag sa mga pamamaraang ito. Maaari naming muling isulat ang mga ito, baguhin ang bilang ng mga parameter at kanilang mga uri, at anumang umaasa na panlabas na code ay patuloy na gagana. Well, hindi bababa sa ito ay mag-compile.
5. Nagpapasya kami kung paano nakikipag-ugnayan ang aming bagay sa mga panlabas na bagay
Maaari naming paghigpitan ang ilan sa mga aksyon na maaaring gawin sa aming bagay. Halimbawa, ipagpalagay na gusto namin ang isang bagay na ma-instantiate nang isang beses lamang. Kahit na ito ay malikha sa ilang lugar sa proyekto. At magagawa natin ito salamat sa encapsulation.
Hinahayaan kami ng Encapsulation na magdagdag ng mga karagdagang paghihigpit , na maaaring gawing karagdagang mga pakinabang . Halimbawa, ang Stringklase ay ipinatupad bilang isang hindi nababagong bagay. Ang isang bagay ng Stringklase ay hindi nababago mula sa sandali ng paglikha nito hanggang sa sandali ng kamatayan nito. Ang lahat ng mga pamamaraan ng Stringklase ( remove, substring, ...), ay nagbabalik ng bagong string nang hindi gumagawa ng anumang mga pagbabago sa bagay kung saan sila tinawag.
Ang encapsulation ay isang napaka-kagiliw-giliw na bagay.