Mga Prinsipyo ng Encapsulation sa Java

Kamusta! Ang lecture ngayon ay ilalaan sa encapsulation at sisimulan namin ito kaagad sa mga halimbawa :) Sa harap mo ay isang pamilyar na makina ng soda. Mayroon akong isang tanong para sa iyo: paano ito gumagana? Subukang sagutin nang detalyado: kung saan nagmula ang baso, kung paano pinapanatili ang temperatura sa loob, kung saan nakaimbak ang yelo, kung paano naiintindihan ng makina kung anong syrup ang idaragdag, atbp. Malamang, wala kang mga sagot sa mga tanong na ito. Buweno, marahil hindi lahat ay gumagamit ng gayong mga makina; hindi sila gaanong sikat ngayon. Subukan nating magbigay ng isa pang halimbawa. Isang bagay na alam mong ginagamit mo ng maraming beses araw-araw. Ay, may idea ako! Sabihin sa amin kung paano gumagana ang search engine ng Google . Paano ito eksaktong naghahanap ng impormasyon batay sa mga salitang iyong inilagay? Bakit ang mga resultang ito ang nasa itaas at hindi ang iba? Kahit na araw-araw mong ginagamit ang Google, malamang na hindi mo ito alam. Ngunit hindi ito mahalaga. Pagkatapos ng lahat, hindi mo kailangang malaman ito. Maaari kang magpasok ng mga query sa isang search engine nang hindi iniisip kung paano ito gumagana nang eksakto. Maaari kang bumili ng soda mula sa isang vending machine nang hindi alam kung paano ito gumagana. Maaari kang magmaneho ng kotse nang hindi nakikibahagi sa pagpapatakbo ng internal combustion engine, at nang hindi alam ang pisika, kahit na sa antas ng paaralan. Ang lahat ng ito ay posible salamat sa isa sa mga pangunahing prinsipyo ng object-oriented programming - encapsulation . Habang nagbabasa ng iba't ibang mga artikulo sa paksang ito, malamang na nakita mo ang katotohanan na mayroong dalawang karaniwang konsepto sa programming - encapsulation at pagtatago . At sa pamamagitan ng salitang "encapsulation" ang mga may-akda ay nangangahulugan ng isang bagay o iba pa (tulad ng nangyayari). Hihiwalayin namin ang dalawang termino para magkaroon ka ng kumpletong pang-unawa. Ang orihinal na kahulugan ng salitang " encapsulation " sa programming ay ang kumbinasyon ng data at mga pamamaraan ng pagtatrabaho sa data na ito sa isang pakete ("capsule"). Sa Java, ang klase ay gumaganap bilang isang capsule package . Ang isang klase ay naglalaman ng parehong data (mga field ng klase) at mga pamamaraan para sa pagtatrabaho sa data na ito. Ito ay tila halata sa iyo, ngunit sa iba pang mga konsepto ng programming ang lahat ay gumagana nang iba. Halimbawa, sa functional programming, ang data ay mahigpit na pinaghihiwalay mula sa mga operasyon dito. Sa OOP (object-oriented programming), ang mga programa ay binubuo ng mga klase ng kapsula, na parehong data at mga function para sa pagtatrabaho dito. Ngayon pag-usapan natin ang pagtatago . Paano natin ginagamit ang lahat ng uri ng kumplikadong mekanismo nang hindi nauunawaan kung paano gumagana ang mga ito at kung ano ang batayan ng kanilang trabaho? Ito ay simple: ang kanilang mga tagalikha ay nagbigay ng isang simple at madaling gamitin na interface. Sa isang soda machine, ang interface ay mga pindutan sa isang panel. Sa pamamagitan ng pagpindot sa isang pindutan, pipiliin mo ang volume ng baso. Sa pamamagitan ng pagpindot sa pangalawa, pipiliin mo ang syrup. Ang pangatlo ay may pananagutan sa pagdaragdag ng yelo. At iyon lang ang kailangan mong gawin. Hindi mahalaga kung gaano eksakto ang disenyo ng makina sa loob. Ang pangunahing bagay ay na ito ay dinisenyo sa paraang upang makakuha ng soda, kailangan ng user na pindutin ang tatlong mga pindutan . Ganun din sa kotse. Hindi mahalaga kung ano ang nangyayari sa loob niya. Ang pangunahing bagay ay kapag pinindot mo ang kanang pedal, pasulong ang kotse, at kapag pinindot mo ang kaliwang pedal, bumagal ito . Ito ay tiyak ang kakanyahan ng pagtatago. Ang lahat ng "loob" ng programa ay nakatago mula sa gumagamit. Para sa kanya, ang impormasyong ito ay kalabisan at hindi kailangan. Kailangan ng user ang huling resulta, hindi ang panloob na proseso. Tingnan natin ang klase bilang isang halimbawa Auto:

public class Auto {

   public void gas() {

       /*some complicated things are happening inside the car
       as a result of which it goes forward*/
   }

   public void brake() {

       /*some complicated things are happening inside the car
       as a result of which it slows down*/
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // How everything looks to the user

       //pressed one pedal - went
       auto.gas();

       //pressed another pedal - braked
       auto.brake();
   }
}

Ito ang hitsura ng pagtatago ng pagpapatupad sa isang Java program. Ang lahat ay tulad sa totoong buhay: ang gumagamit ay binibigyan ng isang interface (mga pamamaraan). Kung kailangan niya ang kotse sa programa upang magsagawa ng isang aksyon, kailangan lang niyang tawagan ang nais na paraan. At kung ano ang nangyayari sa loob ng mga pamamaraang ito ay hindi kinakailangang impormasyon, ang pangunahing bagay ay gumagana ang lahat ayon sa nararapat. Dito namin napag-usapan ang pagtatago ng pagpapatupad . Bukod dito, ang Java ay mayroon ding data hiding . Isinulat namin ang tungkol dito sa lecture tungkol sa mga getter at setter , ngunit hindi masakit na ipaalala sa iyo. Halimbawa, mayroon kaming klase Cat:

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Marahil naaalala mo mula sa huling panayam kung ano ang problema ng klase na ito? Kung hindi, tandaan natin. Ang problema ay ang kanyang data (mga patlang) ay bukas sa lahat, at ang isa pang programmer ay madaling lumikha ng isang walang pangalan na pusa sa programa na may timbang na 0 at isang edad na -1000 taon:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

Sa ganoong sitwasyon, masusubaybayan mong mabuti kung ang isa sa iyong mga kasamahan ay gumagawa ng mga bagay na may maling estado, ngunit mas mahusay na ibukod ang mismong posibilidad na lumikha ng gayong "mga maling bagay". Tinutulungan nila kami sa pagtatago ng data:

1. access modifiers ( pribado , protektado , package default );
2. getters at setter.

Doon natin, halimbawa, suriin kung may sumusubok na magtalaga ng negatibong numero sa pusa bilang edad nito. Gaya ng sinabi namin kanina, ang mga may-akda ng iba't ibang artikulo sa encapsulation ay nangangahulugang alinman sa encapsulation (pagsasama-sama ng data at mga pamamaraan), o pagtatago, o pareho. Ang Java ay may parehong mekanismo (hindi naman ito ang kaso sa ibang mga wika ng OOP), kaya ang huling opsyon ang pinakatama. Ang paggamit ng encapsulation ay nagbibigay sa amin ng ilang mahahalagang pakinabang:

1. Pagsubaybay sa tamang estado ng bagay. May mga halimbawa nito sa itaas: salamat sa setter at sa pribadong modifier, pinrotektahan namin ang aming programa mula sa mga pusang may timbang na 0.


2. User-friendly dahil sa interface. Nag-iiwan lamang kami ng mga pamamaraan sa "labas" para sa pag-access ng user. Ang kailangan lang niyang gawin ay tawagan sila para makuha ang resulta, at hindi na niya kailangang pag-aralan ang mga detalye ng kanilang trabaho.


3. Ang mga pagbabago sa code ay hindi nakakaapekto sa mga user. Ginagawa namin ang lahat ng pagbabago sa loob ng mga pamamaraan. Hindi ito makakaapekto sa user: sumulat siya ng auto.gas() para sa gas ng sasakyan, kaya isusulat niya ito. At ang katotohanan na may binago kami sa pagpapatakbo ng pamamaraan ng gas() ay mananatiling hindi nakikita sa kanya: siya, tulad ng dati, ay tatanggap lamang ng nais na resulta.