Encapsulation sa Java

Hi! Ilalaan namin ang aralin ngayon sa Encapsulation sa Java at magsisimula sa mga halimbawa sa labas mismo ng gate:) Narito mayroon kang ordinaryong soda dispensing machine . Mayroon akong isang tanong para sa iyo: paano ito gumagana? Subukang magbigay ng detalyadong sagot: Saan nagmula ang soda? Paano pinapanatili ang panloob na temperatura? Saan nakaimbak ang yelo? Paano malalaman ng makina kung aling syrup ang idaragdag? Malamang na wala kang mga sagot sa mga tanong na ito. Okay, marahil hindi lahat ay gumagamit ng mga makinang ito. Hindi sila gaanong sikat sa kasalukuyan. Subukan natin ang isa pang halimbawa. Isang bagay na tiyak na ginagamit mo ng maraming beses araw-araw. Ay, may idea ako! Sabihin sa akin kung paano ang Google search enginegumagana. Paano ito eksaktong naghahanap ng impormasyon sa mga salitang iyong ipinasok? Bakit ang mga resultang ito ang nasa itaas at hindi ang iba? Kahit na ginagamit mo ang Google araw-araw, malamang na hindi mo alam. Ngunit hindi iyon mahalaga. Pagkatapos ng lahat, hindi ito isang bagay na kailangan mong malaman. Maaari kang gumamit ng search engine nang hindi iniisip ang eksaktong paraan kung paano ito gumagana. Maaari kang bumili ng soda mula sa isang makina nang hindi alam kung paano ito binuo. Maaari kang magmaneho ng kotse nang hindi sinisiyasat kung paano gumagana ang internal combustion engine at hindi man lang alam ang high-school physics. Lahat ito ay posible salamat sa isa sa mga pangunahing prinsipyo ng object-oriented programming: encapsulation. Sa pagbabasa ng iba't ibang mga artikulo sa paksa, malamang na nakatagpo ka ng dalawang malawak na konsepto ng programming: encapsulation at pagtatago ng impormasyon. Habang nangyayari ito, naiintindihan ng iba't ibang tao ang salitang ' encapsulation' upang mangahulugan ng iba't ibang bagay. Ide-decipher namin ang parehong termino para magkaroon ka ng kumpletong pang-unawa. Sa programming, ang orihinal na kahulugan ngAng encapsulation ay pinagsasama ang data at mga pamamaraan para sa pagtatrabaho sa data na iyon sa isang pakete ("capsule"). Sa Java, ang encapsulating package ay ang class . Ang klase ay naglalaman ng parehong data (mga patlang) at mga pamamaraan para sa pagtatrabaho sa data na iyon. Ito ay maaaring mukhang halata sa iyo, ngunit ang lahat ay nakaayos nang iba sa iba pang mga paradigm sa programming. Halimbawa, sa functional programming, ang data ay mahigpit na pinaghihiwalay mula sa data operations. Sa object-oriented programming (OOP), ang mga programa ay binubuo ng mga kapsula (mga klase) na binubuo ng parehong data at mga function para sa pagtatrabaho sa data.

Ngayon pag-usapan natin ang pagtatago ng impormasyon

Paano natin ginagamit ang lahat ng uri ng kumplikadong mekanismo nang hindi nauunawaan kung paano ito binuo o kung paano gumagana ang mga ito? Ito ay simple: ang kanilang mga tagalikha ay nagbigay ng simple at maginhawang mga interface. Sa isang soda machine, ang interface ay ang mga button sa front panel. Hinahayaan ka ng isang pindutan na piliin ang laki ng tasa. Pumili ka ng syrup na may pangalawang pindutan. Ang ikatlo ay responsable para sa pagdaragdag ng yelo. At iyon lang ang kailangan mong gawin. Hindi mahalaga kung ano ang hitsura ng makina sa loob. Ang mahalagang bagay ay na ito ay dinisenyo upang ang gumagamit ay makakuha ng soda sa pamamagitan ng pagtulak ng tatlong mga pindutan. Ang parehong bagay ay naaangkop sa isang kotse. Hindi mahalaga kung ano ang nangyayari sa loob. Ang mahalaga ay kapag pinindot mo ang kanang pedal ay umuusad ang sasakyan, at kapag pinindot mo ang kaliwang pedal ay bumagal ang takbo ng sasakyan. Ito ang kakanyahan ng pagtatago ng impormasyon. Lahat ng isang programa' s 'innards' ay nakatago mula sa gumagamit. Ang nasabing impormasyon ay labis o hindi kailangan para sa gumagamit. Ang gumagamit ay nangangailangan ng isang resulta, hindi isang panloob na proseso. Para sa isang halimbawa, tingnan natin angKlase ng sasakyan :

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

Ito ay kung paano nakatago ang pagpapatupad sa isang Java program. Tulad ng sa totoong buhay: ang gumagamit ay binibigyan ng isang interface (mga pamamaraan). Sa isang programa, kung kailangan mo ng kotse para magsagawa ng aksyon, tatawagan mo lang ang gustong paraan. Ang nangyayari sa loob ng mga pamamaraang ito ay kalabisan. Ang mahalaga ay gumagana ang lahat ayon sa nararapat. Dito natin pinag-uusapan ang pagtatago ng pagpapatupad. Ang Java ay mayroon ding pagtatago ng data. Isinulat namin ito sa aralin tungkol sa mga getter at setter, ngunit hindi makakasakit ang isang paalala. Halimbawa, mayroon kaming klase ng 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!");
   }


}

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

public static void main(String[] args) {

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

}

Sa sitwasyong ito, maaari mong maingat na subaybayan kung ang isa sa iyong mga kasamahan ay gumagawa ng mga bagay na may di-wastong estado, ngunit ito ay magiging mas mahusay na alisin kahit na ang posibilidad ng paglikha ng mga hindi wastong bagay na ito. Nakamit namin ang pagtatago ng data sa tulong ng:

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

Ginagamit namin ang mga ito upang suriin kung may isang taong sumusubok na bigyan ang pusa ng negatibong edad. Tulad ng sinabi namin kanina, ang mga may-akda ng iba't ibang mga artikulo sa encapsulation ay talagang tumutukoy sa encapsulation (pagsasama-sama ng data at mga pamamaraan) o pagtatago ng impormasyon, o pareho. Ang Java ay may parehong mekanismo (hindi naman ito ang kaso sa ibang mga wika ng OOP), kaya ang huling opsyon ay pinakatama.

Ang encapsulation ay nagbibigay sa amin ng ilang mahahalagang pakinabang:

1. Pagsubaybay sa tamang estado ng bagay. Nagbigay kami ng mga halimbawa nito sa itaas: salamat sa setter at pribadong modifier, na-secure namin ang aming programa laban sa mga pusa na may timbang na 0.


2. User-friendly na interface. Iniiwan lang namin ang mga pamamaraan na nakalantad sa gumagamit. Kailangan lang ng user na tawagan sila para makakuha ng resulta. At hindi na kailangan pang pag-aralan ang mga detalye kung paano gumagana ang mga ito.


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 nakakaapekto sa mga user: isinulat nila ang vehicle.gas() para ilapat ang gas, at iyon ang patuloy nilang gagawin. Ang katotohanang may binago kami sa loob ng gas() na pamamaraan ay nananatiling hindi nakikita: tulad ng dati, nakukuha lang nila ang kinakailangang resulta.