Hi! Ilaan natin ang aralin ngayon sa encapsulation at magsimula kaagad sa mga halimbawa :) Mga prinsipyo ng encapsulation - 1Narito mayroon kang isang ordinaryong soda machine . Mayroon akong isang tanong para sa iyo: paano ito gumagana? Subukang magbigay ng detalyadong sagot: saan nagmula ang tasa, paano pinapanatili ang panloob na temperatura, saan nakaimbak ang yelo, paano malalaman ng makina kung aling syrup ang idaragdag, atbp.? Malamang na wala kang mga sagot sa mga tanong na ito. Sapat na, dahil hindi lahat ay gumagamit ng gayong mga makina. Hindi sila masyadong sikat ngayon. Subukan nating magbigay ng isa pang halimbawa. Isang bagay na tiyak na ginagamit mo ng maraming beses araw-araw. Oh, narito ang isang ideya! Mga prinsipyo ng encapsulation - 2Sabihin sa amin kung paano ang Google search enginegumagana. Paano ito eksaktong naghahanap ng impormasyong nauugnay sa mga salitang iyong ipinasok? Bakit mataas ang ranggo ng ilang partikular na resulta at hindi ang iba? Kahit na araw-araw mong ginagamit ang Google, malamang, hindi mo alam. Ngunit hindi mahalaga. Hindi mo kailangang malaman ito. Maaari kang magpasok ng mga query sa isang search engine nang hindi iniisip kung paano ito gumagana. Maaari kang bumili ng soda mula sa isang makina nang hindi alam kung paano ito gumagana. Maaari kang magmaneho ng kotse nang hindi nauunawaan kung paano gumagana ang isang internal combustion engine, at nang hindi alam ang pisika, kahit na sa antas ng elementarya. Ang lahat ng ito ay posible salamat sa isa sa mga pangunahing prinsipyo ng object-oriented programming: encapsulation. Ang pagbabasa ng iba't ibang mga artikulo sa object-oriented programming (OOP), malamang na nalaman mo na ang programming ay nagsasangkot ng dalawang karaniwang konsepto: encapsulation at pagtatago . At ginagamit ng mga may-akda ang salitang "encapsulation" upang mangahulugan ng isang bagay at pagkatapos ay isa pa. I-explore namin ang parehong termino para magkaroon ka ng kumpletong pang-unawa. Sa programming, ang orihinal na kahulugan ng encapsulation ay ang bundling ng data, kasama ang mga pamamaraan na gumagana sa data na iyon, sa isang unit (ibig sabihin, isang "capsule"). Sa Java, ang klase ay ang yunit ng encapsulation. Ang isang klase ay naglalaman ng parehong data (mga patlang) at mga pamamaraan para sa pagtatrabaho sa data na ito.Mga prinsipyo ng encapsulation - 3Ito ay maaaring mukhang tulad ng malinaw na tamang diskarte sa iyo, ngunit sa iba pang mga paradigm sa programming, ang lahat ay nakaayos nang iba. Halimbawa, sa functional programming, ang data ay mahigpit na pinaghihiwalay mula sa mga operasyon dito. Sa OOP, ang mga programa ay binubuo ng mga kapsula, o mga klase, na binubuo ng parehong data at mga function para sa pagtatrabaho sa data na iyon. Ngayon pag-usapan natin ang pagtatago . Paano natin ginagamit ang lahat ng uri ng kumplikadong mga aparato nang hindi nauunawaan kung paano nakaayos ang mga ito o kung paano gumagana ang mga ito? Ito ay simple: ang kanilang mga tagalikha ay nagbigay sa amin ng isang simple at maginhawang interface. Sa isang soda machine, ang interface ay ang mga pindutan sa panel. Ang pagpindot sa isang pindutan, pipiliin mo ang laki ng tasa. Pagpindot sa isa pa, pipiliin mo ang lasa. Ang ikatlo ay responsable para sa pagdaragdag ng yelo. At iyon lang ang kailangan mong gawin. Ang panloob na organisasyon ng makina ay hindi mahalaga. Ang mahalaga ay ito ay idinisenyo sa paraang nangangailangan ang gumagamit na pindutin ang tatlong mga pindutan upang makakuha ng soda . Ang parehong ay totoo tungkol sa mga kotse. Hindi mahalaga kung ano ang nangyayari sa loob. Ang mahalaga ay kapag pinindot mo ang kanang pedal, umuusad ang kotse, at kapag pinindot mo ang kaliwang pedal, bumagal ito.. Iyon ang halaga ng pagtatago. Ang lahat ng "insides" ng isang programa ay nakatago mula sa user. Para sa gumagamit, ang kalabisan, hindi kinakailangang impormasyon na ito. Kailangan ng user ang huling resulta, hindi ang panloob na proseso. Tingnan natin ang Autoklase bilang isang halimbawa:
Java webinar 
public class Auto {

   public void go() {

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

   public void brake() {

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

   public static void main(String[] args) {

       Auto auto = new Auto();

       // From the user's perspective,

       // one pedal is pressed and the car accelerates.
       auto.gas();

       // The other is pressed, and the car slows down.
       auto.brake();
   }
}
Narito kung ano ang hitsura ng pagtatago ng pagpapatupad sa isang Java program. Ito ay tulad ng sa totoong buhay: ang gumagamit ay binibigyan ng isang interface (mga pamamaraan). Kung ang gumagamit ay nangangailangan ng isang kotse sa isang programa upang magsagawa ng isang aksyon, siya ay tumawag lamang sa nais na paraan. Ang nangyayari sa loob ng mga pamamaraang ito ay kalabisan. Ang mahalaga ay gumagana ang lahat ayon sa nararapat. Dito pinag-uusapan natin ang pagtatago ng pagpapatupad . Bukod doon, ang Java ay mayroon ding data hiding . Isinulat namin iyon sa aralin tungkol sa mga getter at setter , ngunit hindi masasaktan ang pagsusuri sa konsepto. Halimbawa, mayroon kaming Catklase: 
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 ang problema sa klase na ito mula sa huling aralin? Kung hindi, tandaan natin ito ngayon. Ang problema ay ang data nito (mga patlang) ay bukas sa lahat — ang isa pang programmer ay madaling makagawa ng isang walang pangalan na pusa 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;

}
Marahil ay maaari mong bantayang mabuti kung ang isa sa iyong mga katrabaho ay gumawa ng mga bagay na may di-wastong estado, ngunit ito ay mas mahusay na ibukod ang kahit na ang posibilidad ng paglikha ng gayong "mga di-wastong bagay." Mga prinsipyo ng encapsulation - 4Ang mga sumusunod na mekanismo ay tumutulong sa amin na makamit ang pagtatago ng data:
  1. access modifiers ( pribado , protektado , package default )
  2. getters at setter
Halimbawa, maaari tayong maglagay ng tsek doon upang makita kung may sumusubok na magtalaga ng negatibong numero sa edad ng pusa. Tulad ng sinabi namin kanina, ang mga may-akda ng iba't ibang mga artikulo tungkol sa encapsulation ay minsan ay nangangahulugan ng pagsasama-sama ng data at mga pamamaraan, o pagtatago sa kanila, o pareho (pagsasama-sama at pagtatago sa kanila). Ang Java ay may parehong mga mekanismo (ito ay hindi kinakailangang totoo para sa iba pang mga wika ng OOP), kaya ang huling kahulugan ay pinakatama. Ang encapsulation ay nagbibigay sa amin ng ilang mahahalagang pakinabang:
  1. Kontrol sa tamang estado ng isang bagay. May mga halimbawa nito sa itaas. Tinitiyak ng isang setter at ng pribadong modifier na ang aming programa ay hindi magkakaroon ng mga pusa na ang timbang ay 0.

  2. User-friendly sa pamamagitan ng isang interface. Ang mga pamamaraan lamang ang naiwan na "nakalantad" sa labas ng mundo. Sapat na ang mga paraan ng pagtawag para makakuha ng resulta — talagang hindi na kailangang suriin ang mga detalye kung paano gumagana ang mga ito.

  3. Ang mga pagbabago sa code ay hindi nakakaapekto sa mga user. Gumagawa kami ng anuman at lahat ng pagbabago sa loob ng mga pamamaraan. Hindi ito nakakaapekto sa gumagamit ng pamamaraan: kung ang tamang code ay dating "auto.gas()" para ilapat ang pedal ng gas, magpapatuloy ito. Ang katotohanang may binago kami sa loob ng gas() na pamamaraan ay nananatiling hindi nakikita ng gumagamit: tulad ng dati, natatanggap lang ng tumatawag ang nais na resulta.