Mga Prinsipyo ng OOP

Hi! Sa aralin ngayon, pag-uusapan natin ang Mga Prinsipyo ng object-oriented programming. Naisip mo na ba kung bakit ang Java ay idinisenyo nang eksakto kung ano ito? Ibig kong sabihin, nagdedeklara ka ng mga klase at lumikha ng mga bagay batay sa mga klase, ang mga klase ay may mga pamamaraan, atbp. Ngunit bakit nakabalangkas ang wika upang ang mga programa ay binubuo ng mga klase at bagay, at hindi iba pa? Bakit naimbento at inilagay sa unahan ang konsepto ng isang "bagay"? Lahat ba ng wika ay dinisenyo sa ganitong paraan? Kung hindi, anong mga pakinabang ang ibinibigay nito sa Java? Sa nakikita mo, maraming tanong :) Subukan nating sagutin ang bawat isa sa mga ito sa aralin ngayon.

Ano ang object-oriented programming (OOP)?

Siyempre, ang Java ay hindi binubuo ng mga bagay at klase para lang sa kasiyahan. Hindi sila kapritso ng mga tagalikha ng Java, at kahit na ang kanilang imbensyon. Mayroong maraming iba pang mga wika batay sa mga bagay. Ang unang naturang wika ay tinawag na "Simula". Naimbento ito noong 1960s sa Norway. Higit pa rito, ang mga konsepto ng isang "klase" at "paraan" ay lumitaw sa Simula. Ayon sa mga pamantayan ng pagbuo ng software, ang "Simula" ay tila isang sinaunang wika, ngunit makikita ng sinuman ang "pagkahawig ng pamilya" nito sa Java. Malamang na madali mong mabasa ang code na nakasulat sa wikang ito at ipaliwanag sa malawak na mga stroke kung ano ang ginagawa nito :)

Begin
	Class Rectangle (Width, Height); Real Width, Height;
			           
	 Begin
	    Real Area, Perimeter;  
	 
	    Procedure Update;      
	    Begin
	      Area := Width * Height;
              OutText("Rectangle is updating, Area = "); OutFix(Area,2,8); OutImage;
	      Perimeter := 2*(Width + Height);
              OutText("Rectangle is updating, Perimeter = "); OutFix(Perimeter,2,8); OutImage;
	    End of Update;
	 
	    Update;               
	    OutText("Rectangle created: "); OutFix(Width,2,6);
	    OutFix(Height,2,6); OutImage;
	 End of Rectangle;

       Rectangle Class ColouredRectangle (Color); Text Color;
			           
	Begin   	  
	    OutText("ColouredRectangle created, color = "); OutText(Color);
	    OutImage;
        End of ColouredRectangle;

 
      	 Ref(Rectangle) Cr;            
	 Cr :- New ColouredRectangle(10, 20, "Green"); 
End;

Ang sample code ng code na ito ay kinuha mula sa "Simula - 50 taon ng OOP" ng Weekly-geekly. Tulad ng nakikita mo, ang Java ay hindi masyadong naiiba sa lolo nito :) Ito ay dahil sa katotohanan na ang hitsura ng Simula ay minarkahan ang pagsilang ng isang bagong konsepto: object-oriented programming. Tinukoy ng Wikipedia ang OOP tulad nito: "Ang Object-Oriented Programming (OOP) ay isang programming paradigm batay sa konsepto ng "mga bagay", na maaaring maglaman ng data, sa anyo ng mga patlang (kadalasang kilala bilang mga katangian), at code, sa anyo ng mga pamamaraan (madalas na kilala bilang mga pamamaraan)." Sa aking opinyon, ito ay isang talagang magandang kahulugan. Ito ay hindi pa matagal na ang nakalipas na nagsimula kang matuto ng Java, ngunit ang kahulugan na ito ay malamang na hindi naglalaman ng anumang mga salita na hindi mo alam :) Ngayon ang OOP ay ang pinakakaraniwang pamamaraan ng programming. Bilang karagdagan sa Java, Ginagamit ang mga prinsipyo ng OOP sa maraming sikat na wika na maaaring narinig mo na. Halimbawa, C++ (aktibong ginagamit sa pagbuo ng laro), Objective-C at Swift (ginagamit para magsulat ng mga programa para sa mga Apple device), Python (pinakatanyag sa machine learning), PHP (isa sa pinakasikat na wika sa web development), JavaScript ( mas madaling sabihin kung ano ang hindi ginagamit) at marami pang iba. Kaya, ano pa rin ang mga prinsipyo ng OOP? Sasabihin namin sa iyo nang detalyado. ano ang mga prinsipyo ng OOP pa rin? Sasabihin namin sa iyo nang detalyado. ano ang mga prinsipyo ng OOP pa rin? Sasabihin namin sa iyo nang detalyado.

Mga Prinsipyo ng OOP

Ito ang pundasyon ng pundasyon. Ang 4 na pangunahing tampok na magkasama ay bumubuo ng object-oriented programming paradigm. Ang pag-unawa sa mga ito ay mahalaga sa pagiging isang matagumpay na programmer.

Prinsipyo 1. Pamana

Magandang balita: alam mo na ang ilan sa mga prinsipyo ng OOP! :) Ilang beses na kaming nakatagpo ng mana sa mga aralin, at nagamit namin ito. Ang inheritance ay isang mekanismo na nagbibigay-daan sa iyong ilarawan ang isang bagong klase batay sa isang umiiral na (magulang) na klase. Sa paggawa nito, hinihiram ng bagong klase ang mga katangian at functionality ng parent class. Para saan ang mana at anong mga pakinabang ang ibinibigay nito? Higit sa lahat, muling paggamit ng code. Ang mga field at pamamaraan na idineklara sa mga parent class ay maaaring gamitin sa mga descendant na klase. Kung ang lahat ng uri ng kotse ay may 10 karaniwang field at 5 magkatulad na pamamaraan, kailangan mo lang ilipat ang mga ito sa Autoklase ng magulang. Magagamit mo ang mga ito sa mga descendant na klase nang walang anumang problema. Solid na bentahe: parehong quantitative (mas kaunting code) at, bilang resulta, qualitative (magiging mas simple ang mga klase). Bukod dito, napaka-flexible ng pamana — maaari kang magdagdag ng write hiwalay na functionality na nawawala ang mga descendant (ilang field o pag-uugali na partikular sa isang partikular na klase). Sa pangkalahatan, tulad ng sa totoong buhay, lahat tayo ay medyo katulad ng ating mga magulang, ngunit iba rin sa kanila :)

Prinsipyo 2. Abstraction

Ito ay isang napakasimpleng prinsipyo. Ang ibig sabihin ng abstraction ay tukuyin ang mga pangunahing, pinaka makabuluhang katangian ng isang bagay, habang sabay na itinatapon ang anumang bagay na maliit at hindi gaanong mahalaga. Hindi na kailangang muling likhain ang gulong. Alalahanin natin ang isang halimbawa mula sa isang lumang aralin tungkol sa mga klase. Ipagpalagay na gumagawa kami ng isang sistema ng pag-file para sa mga empleyado ng kumpanya. Upang lumikha ng mga bagay na "empleyado", nagsulat kami ng klase ng Empleyado . Anong mga katangian ang mahalaga upang ilarawan ang mga ito sa sistema ng pag-file ng kumpanya? Pangalan, petsa ng kapanganakan, SSN, at ID ng empleyado. Ngunit malamang na hindi natin kakailanganin ang taas, kulay ng mata, o kulay ng buhok ng empleyado para sa ganitong uri ng record. Ang kumpanya ay hindi nangangailangan ng ganoong impormasyon tungkol sa isang empleyado. Kaya, sa klase ng Empleyado , ipinapahayag namin ang mga sumusunod na variable:, int age , int socialSecurityNumber , at int employeeId . At inaalis namin ang mga hindi kinakailangang impormasyon tulad ng kulay ng mata. Gayunpaman, kung gagawa kami ng isang sistema ng pag-file para sa isang ahensya ng pagmomolde, ang sitwasyon ay kapansin-pansing nagbabago. Ang taas, kulay ng mata, at kulay ng buhok ng isang modelo ay mahalagang katangian, ngunit ang kanyang SSN ay ganap na walang kaugnayan sa amin. Kaya, sa klase ng Modelo , ginagawa namin ang mga sumusunod na variable: String height , String hair , String eyes .

Prinsipyo 3. Encapsulation

Naabutan na natin ito. Sa Java, ang encapsulation ay nangangahulugan ng paghihigpit sa kakayahang magbasa at magbago ng data. Tulad ng nakikita mo, ang termino ay batay sa salitang "capsule". Gagamit kami ng "capsule" para itago ang ilang mahalagang data na hindi namin gustong baguhin ng iba. Narito ang isang simpleng halimbawa mula sa totoong buhay. Mayroon kang unang pangalan at apelyido. Kilala sila ng lahat ng kaibigan mo. Ngunit wala silang kakayahang baguhin ang iyong pangalan o apelyido. Maaari naming sabihin na ang proseso para gawin iyon ay "naka-encapsulated" ng sistema ng hukuman: maaari mong baguhin ang iyong apelyido sa pamamagitan lamang ng klerk ng hukuman, at ikaw lang ang makakagawa nito. Ang ibang "mga user" ay may "read-only" na access sa iyong pangalan at apelyido :) Isa pang halimbawa ng paglalarawan ay ang pera na iniingatan sa bahay. Ang pag-iwan nito nang malinaw sa gitna ng iyong silid ay hindi magandang ideya. Ang sinumang "gumagamit" (taong pumupunta sa iyong bahay) ay magagawang baguhin ang halaga ng iyong pera, ibig sabihin, maaari nilang kunin ang iyong pera. Mas mainam na i-encapsulate ito sa isang safe. Kung gayon ang pag-access ay magiging available lamang sa iyo at sa pamamagitan lamang ng paggamit ng isang espesyal na code. Ang mga halatang halimbawa ng encapsulation na nakatrabaho mo na ay ang mga access modifier (pribado, pampubliko, atbp.), pati na rin ang mga setter at getter. Kung hindi mo i-encapsulate angAng field ng edad ng klase ng pusa , pagkatapos ay maaaring isulat ng sinuman ang:

Cat.age = -1000;

Ang mekanismo ng encapsulation ay nagbibigay-daan sa amin na protektahan ang field ng edad gamit ang isang setter method, kung saan masisiguro naming hindi maitakda ang edad sa isang negatibong numero.

Prinsipyo 4. Polymorphism

Ang polymorphism ay ang kakayahang magtrabaho kasama ang ilang uri na parang pareho silang uri. Bukod dito, ang pag-uugali ng mga bagay ay mag-iiba depende sa kanilang uri. Mukhang kumplikado ba iyon? Bigyan natin ng kahulugan ito ngayon. Kunin ang pinakasimpleng halimbawa: mga hayop. Lumikha ng klase ng Animal na may iisang speak() na paraan, at dalawang subclass — Cat at Dog .

public class Animal {

   public void speak() {
      
       System.out.println("Hello!");
   }
}

public class Dog extends Animal {
  
   @Override
   public void speak() {
       System.out.println ("Woof-woof!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

Ngayon ay susubukan naming magdeklara ng isang Animal reference variable at magtalaga ng isang Dog object dito.

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.speak();
   }
}

Anong paraan sa tingin mo ang tatawagin? Animal.speak() o Dog.speak() ? Ang pamamaraan sa klase ng Aso ay tatawaging: Woof-woof! Gumawa kami ng Animal reference, ngunit ang object ay kumikilos na parang Aso . Kung kinakailangan, maaari itong kumilos tulad ng isang pusa, kabayo, o iba pang hayop. Ang mahalagang bagay ay magtalaga ng isang partikular na subclass sa pangkalahatang sangguniang variable ng Animal . Makatuwiran ito, dahil lahat ng aso ay hayop. Iyon ang nasa isip namin noong sinabi naming "magiiba ang pag-uugali ng mga bagay depende sa uri nila." Kung gumawa kami ng object ng Cat ...

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.speak();
}

ang speak() method ay magpapakita ng "Meow!" Ngunit ano ang ibig nating sabihin sa 'kakayahang magtrabaho kasama ang ilang uri na parang pareho silang uri'? Ito rin ay medyo prangka. Isipin natin na gumagawa tayo ng barbershop para sa mga hayop. Ang aming barbershop ay dapat na makapagbigay ng trim sa anumang hayop, kaya gumawa kami ng trim() method na may Animal parameter (ang hayop ay nagpapagupit).

public class AnimalBarbershop {

   public void trim(Animal animal) {

       System.out.println("The haircut is done!"); 
   }
}

At ngayon ay maaari na nating ipasa ang mga bagay na Pusa at Aso sa trim() na paraan!

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.trim(cat);
   barbershop.trim(dog);
}

At narito ang malinaw na halimbawa: gumagana ang klase ng AnimalBarbershop sa mga uri ng Pusa at Aso na parang pareho silang uri. Kasabay nito, ang Pusa at Aso ay may iba't ibang pag-uugali: magkaiba silang nagsasalita.

Bakit kailangan natin ng OOP?

Bakit lumitaw ang OOP bilang isang bagong konsepto ng programming? Ang mga programmer ay may mga gumaganang tool, tulad ng mga procedural na wika. Ano ang nag-udyok sa kanila na mag-imbento ng isang bagong bagay? Higit sa lahat, ang pagiging kumplikado ng mga gawain na kanilang hinarap. Kung 60 taon na ang nakararaan ang gawain ng programmer ay tulad ng "suriin ang ilang mathematical expression", ngayon ay maaaring ito ay tulad ng "implement 7 different endings para sa larong STALKER, depende sa mga kumbinasyon ng mga desisyon ng player na ginawa sa mga puntong A, B, C, DE , at F sa laro." Tulad ng nakikita mo, ang mga gawain ay malinaw na naging mas kumplikado sa nakalipas na mga dekada. At bilang isang resulta, ang mga uri ng data ay naging mas kumplikado. Ito ay isa pang dahilan kung bakit lumitaw ang OOP. Ang isang mathematical expression ay madaling masuri gamit ang ordinaryong primitives. Walang mga bagay na kailangan dito. Ngunit ang gawain sa mga pagtatapos ng laro ay mahirap ilarawan nang hindi gumagamit ng mga pasadyang klase. Iyon ay sinabi, medyo madaling ilarawan ito gamit ang mga klase at bagay. Malinaw, kakailanganin namin ng ilang klase: Game, Stalker, Ending, PlayerDecision, GameEvent, at iba pa. Sa madaling salita, kahit na hindi nagsisimulang lutasin ang problema, madali nating "mag-sketch" ng solusyon sa ating ulo. Ang pagtaas ng pagiging kumplikado ng mga gawain ay nagpilit sa mga programmer na hatiin ang mga ito sa mga bahagi. Ngunit hindi ito napakadaling gawin sa procedural programming. At kadalasan ang isang programa ay parang puno na may maraming sanga na kumakatawan sa lahat ng posibleng mga landas ng pagpapatupad. Depende sa ilang mga kundisyon, ang isang sangay ng programa o iba pa ay naisakatuparan. Para sa maliliit na programa, ito ay maginhawa, ngunit napakahirap na hatiin ang isang malaking problema sa mga bahagi. Ito ay isa pang dahilan para sa paglitaw ng OOP. Ang paradigm na ito ay nagbigay sa mga programmer ng kakayahang hatiin ang isang programa sa isang grupo ng mga "modules" (mga klase), na ang bawat isa ay gumagawa ng sarili nitong bahagi ng trabaho. Sa pamamagitan ng pakikipag-ugnayan sa isa't isa, nagagawa ng lahat ng mga bagay ang gawain ng aming programa. Bilang karagdagan, maaari naming muling gamitin ang aming code sa ibang lugar sa programa, na nakakatipid din ng maraming oras.