Mga prinsipyo ng OOP

Kamusta! Naisip mo na ba kung bakit ang Java ay dinisenyo sa paraang ito? Sa kahulugan na lumikha ka ng mga klase, batay sa mga ito - mga bagay, ang mga klase ay may mga pamamaraan, atbp. Ngunit bakit ang istraktura ng wika ay tulad na ang mga programa ay binubuo ng mga klase at bagay, at hindi ng iba pa? Bakit naimbento at inilagay sa unahan ang konsepto ng "bagay"? Gumagana ba ang lahat ng mga wika sa ganitong paraan at, kung hindi, anong mga benepisyo ang ibinibigay nito sa Java? Tulad ng nakikita mo, maraming mga katanungan :) Subukan nating sagutin ang bawat isa sa mga ito sa panayam ngayon.

Mga prinsipyo ng OOP:

1. Mana
2. Abstraction
3. Encapsulation
4. Polymorphism

Ano ang object-oriented programming (OOP)

Siyempre, ang Java ay binubuo ng mga bagay at klase para sa isang dahilan. Ito ay hindi kapritso ng mga tagalikha nito, o maging ang kanilang imbensyon. Mayroong maraming iba pang mga wika na batay sa mga bagay. Ang unang naturang wika ay tinawag na Simula, at ito ay naimbento noong 1960s sa Norway. Sa iba pang mga bagay, ipinakilala ng Simula ang mga konsepto ng " klase " at " pamamaraan ". Kristen Nygaard at Ole Johan Dahl - mga tagalikha ng Simula Tila ang Simula ay isang sinaunang wika ayon sa mga pamantayan ng programming, ngunit ang kanilang "pamilya" na koneksyon sa Java ay nakikita ng mata. Malamang, madali mong mabasa ang code na nakasulat dito at ipaliwanag sa mga pangkalahatang tuntunin 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 halimbawa ng code ay kinuha mula sa artikulong Simula - 50 taon ng OOP . Tulad ng nakikita mo, ang Java at ang ninuno nito ay hindi gaanong naiiba sa bawat isa :) Ito ay dahil sa ang katunayan na ang hitsura ng Simula ay minarkahan ang pagsilang ng isang bagong konsepto - object-oriented programming. Ibinigay ng Wikipedia ang sumusunod na kahulugan ng OOP: Ang Object-oriented programming (OOP) ay isang programming methodology na nakabatay sa pagrepresenta sa isang programa bilang isang koleksyon ng mga bagay, bawat isa ay isang instance ng isang partikular na klase, at ang mga klase ay bumubuo ng isang inheritance hierarchy. Ito ay, sa aking opinyon, napaka-matagumpay. Kamakailan ay nagsimula kang mag-aral ng Java, ngunit halos walang mga salita dito na hindi pamilyar sa iyo :) Ngayon, ang OOP ang pinakakaraniwang pamamaraan ng programming. Bukod sa Java, ang mga prinsipyo ng OOP ay ginagamit sa maraming tanyag na wika na maaaring narinig mo na. Ang mga ito ay C++ (aktibong ginagamit ito ng mga developer ng computer game), Objective-C at Swift (nagsusulat sila ng mga programa para sa mga Apple device), Python (pinaka-in demand sa machine learning), PHP (isa sa mga pinakasikat na wika sa web development), JavaScript (mas simpleng sabihin kung ano ang hindi nila ginagawa dito) at marami pang iba. Sa totoo lang, ano ang mga "prinsipyo" na ito ng OOP? Sabihin natin sa iyo nang mas detalyado.

Mga prinsipyo ng OOP

Ito ang mga pangunahing kaalaman. 4 na pangunahing tampok na magkasamang bumubuo ng object-oriented programming paradigm. Ang pag-unawa sa kanila ay ang susi sa pagiging isang matagumpay na programmer.

Prinsipyo 1. Pamana

Ang magandang balita ay pamilyar ka na sa ilan sa mga prinsipyo ng OOP! :) Nakaranas na kami ng pamana ng ilang beses sa mga lecture, at nagkaroon kami ng oras para gawin ito. Ang inheritance ay isang mekanismo na nagbibigay-daan sa iyong ilarawan ang isang bagong klase batay sa isang umiiral na (magulang) isa. Sa kasong ito, ang mga katangian at functionality ng parent na klase ay hiniram ng bagong klase. Bakit kailangan ang mana at anong mga benepisyo ang ibinibigay nito? Una sa lahat, muling paggamit ng code. Ang mga field at pamamaraan na inilarawan sa mga parent na klase 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 ilagay ang mga ito sa parent class Auto. Magagamit mo ang mga ito sa mga descendant na klase nang walang anumang problema. Solid na mga pakinabang: parehong quantitatively (mas kaunting code) at, bilang isang resulta, qualitatively (mga klase ay nagiging mas simple). Kasabay nito, ang mekanismo ng pamana ay napaka-flexible, at maaari mong idagdag ang nawawalang pag-andar sa mga inapo nang hiwalay (ilang mga field o pag-uugali na partikular sa isang partikular na klase). Sa pangkalahatan, tulad ng sa ordinaryong buhay: lahat tayo ay katulad ng ating mga magulang sa ilang mga paraan, ngunit naiiba sa kanila sa ilang mga paraan :)

Prinsipyo 2. Abstraksyon

Ito ay isang napakasimpleng prinsipyo. Ang ibig sabihin ng abstraction ay ang pag-highlight sa mga pangunahing, pinaka makabuluhang katangian ng isang bagay at vice versa - pagtatapon ng pangalawa, hindi gaanong mahalaga. Huwag nating baguhin ang gulong at tandaan ang isang halimbawa mula sa isang lumang lecture tungkol sa mga klase. Sabihin nating gumagawa tayo ng file cabinet ng mga empleyado ng kumpanya. Upang lumikha ng mga bagay ng empleyado, nagsulat kami ng isang klase Employee. Anong mga katangian ang mahalaga para sa kanilang paglalarawan sa file ng kumpanya? Buong pangalan, petsa ng kapanganakan, numero ng social security, numero ng pagkakakilanlan ng buwis. Ngunit hindi malamang na sa isang card ng ganitong uri kailangan namin ang kanyang taas, mata at kulay ng buhok. Hindi kailangan ng kumpanya ang impormasyong ito tungkol sa empleyado. Samakatuwid, para sa klase Employeeay itatakda namin ang mga variable String name, int age, int socialInsuranceNumberat int taxNumber, at iiwan namin ang impormasyon na hindi kailangan para sa amin, tulad ng kulay ng mata, at abstract ito. Ngunit kung gagawa tayo ng catalog ng mga modelo ng larawan para sa isang ahensya, ang sitwasyon ay kapansin-pansing nagbabago. Upang ilarawan ang isang modelo ng fashion, ang taas, kulay ng mata at kulay ng buhok ay napakahalaga sa amin, ngunit ang numero ng TIN ay hindi kailangan. Samakatuwid, sa klase Modellumikha kami ng mga variable String height, String hair, String eyes.

Prinsipyo 3: Encapsulation

Na-encounter na namin ito. Ang encapsulation sa Java ay nangangahulugang nililimitahan ang pag-access sa data at ang kakayahang baguhin ito. Tulad ng nakikita mo, ito ay batay sa salitang "capsule". Sa "capsule" na ito ay nagtatago kami ng ilang mahalagang data para sa amin na hindi namin gustong baguhin ng sinuman. Isang simpleng halimbawa mula sa buhay. Mayroon kang pangalan at apelyido. Lahat ng kakilala mo ay kilala sila. Ngunit wala silang access upang baguhin ang iyong pangalan at apelyido. Ang prosesong ito, maaaring sabihin ng isa, ay "naka-encapsulated" sa opisina ng pasaporte: maaari mo lamang baguhin ang iyong pangalan at apelyido doon, at ikaw lamang ang makakagawa nito. Ang ibang "mga user" ay may read-only na access sa iyong pangalan at apelyido :) Isa pang halimbawa ay ang pera sa iyong apartment. Ang pag-iiwan sa kanila nang malinaw sa gitna ng silid ay hindi magandang ideya. Ang sinumang "gumagamit" (isang taong pumupunta sa iyong tahanan) ay magagawang baguhin ang numero ng iyong pera, i.e. kunin sila. Mas mainam na i-encapsulate ang mga ito sa isang safe. Ikaw lang ang magkakaroon ng access at tanging may espesyal na code. Ang mga halatang halimbawa ng encapsulation na nakatrabaho mo na ay ang mga access modifier ( private, publicatbp.) at getter-setter. Kung ang field ageng klase Catay hindi naka-encapsulated, sinuman ay maaaring sumulat ng:

Cat.age = -1000;

At ang mekanismo ng encapsulation ay nagbibigay-daan sa amin na protektahan ang field agegamit ang isang setter method, kung saan maaari kaming maglagay ng check na ang edad ay hindi maaaring negatibong numero.

Prinsipyo 4. Polymorphism

Ang polymorphism ay ang kakayahang tratuhin ang maraming uri na parang pareho silang uri. Sa kasong ito, ang pag-uugali ng mga bagay ay mag-iiba depende sa uri kung saan sila nabibilang. Mukhang medyo kumplikado? Alamin natin ngayon. Kunin natin ang pinakasimpleng halimbawa - mga hayop. Gumawa tayo ng isang klase Animalna may iisang pamamaraan - voice(), at dalawa sa mga inapo nito - Catat Dog.

public class Animal {

   public void voice() {

       System.out.println("Voice!");
   }
}

public class Dog extends Animal {


   @Override
   public void voice() {
       System.out.println("Bow-wow!");
   }
}

public class Cat extends Animal {

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

Ngayon subukan nating lumikha ng isang link Animalat italaga ito ng isang bagay Dog.

public class Main {

   public static void main(String[] args) {

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

Aling paraan sa tingin mo ang tatawagin? Animal.voice()o kaya Dog.voice()? Ang pamamaraan ng klase ay tatawaging Dog: Woof-woof! Gumawa kami ng isang sanggunian Animal, ngunit ang bagay ay kumikilos tulad ng Dog. Kung kinakailangan, maaari siyang kumilos tulad ng isang pusa, kabayo o iba pang hayop. Ang pangunahing bagay ay ang magtalaga ng isang sanggunian ng isang pangkalahatang uri Animalsa isang bagay ng isang tiyak na klase ng inapo. Ito ay lohikal, dahil lahat ng aso ay hayop. Ito ang ibig naming sabihin noong sinabi naming "magiiba ang kilos ng mga bagay depende sa kung anong uri sila." Kung tayo ay gagawa ng isang bagay Cat−

public static void main(String[] args) {

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

ang pamamaraan voice()ay maglalabas ng "Meow!" Ano ang ibig sabihin ng "kakayahang magtrabaho kasama ang ilang uri na para bang pareho sila ng uri"? Ito ay medyo madali din. Isipin natin na gumagawa tayo ng hairdressing salon para sa mga hayop. Ang aming salon ng buhok ay dapat na maputol ang lahat ng mga hayop, kaya gagawa kami ng isang pamamaraan shear()("gupit") na may isang parameter Animal- ang hayop na aming puputulin.

public class AnimalBarbershop {

   public void shear(Animal animal) {

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

At ngayon ay maaari nating ipasa shearang parehong mga bagay Catat mga bagay sa pamamaraan Dog!

public static void main(String[] args) {

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

   AnimalBarbershop barbershop = new AnimalBarbershop();

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

Narito ang isang malinaw na halimbawa: ang klase AnimalBarbershopay gumagana sa mga uri Catna parang Dogpareho silang uri. Kasabay nito, mayroon silang Catiba't ibang Dogpag-uugali: iba ang kanilang paggamit ng kanilang mga boses.

Mga dahilan para sa paglitaw ng OOP

Bakit lumitaw ang bagong konsepto ng programming - OOP - ? Ang mga programmer ay may mga tool na gumagana: mga procedural na wika, halimbawa. Ano ang nag-udyok sa kanila na mag-imbento ng isang bagong bagay? Una sa lahat, ang kumplikasyon ng mga gawaing kanilang kinaharap. Kung 60 taon na ang nakalilipas ang gawain ng isang programmer ay mukhang "kalkulahin ang isang mathematical equation na ganito at ganoon," ngayon ay maaaring parang "magpatupad ng 7 magkakaibang mga pagtatapos para sa larong STALKER depende sa kung anong mga desisyon ang ginawa ng user sa mga sandali ng laro A, B, C, D , E, F at mga kumbinasyon ng mga solusyong ito." Ang mga gawain, tulad ng nakikita mo, ay malinaw na naging mas kumplikado sa nakalipas na mga dekada. Nangangahulugan ito na ang mga uri ng data ay naging mas kumplikado. Ito ay isa pang dahilan para sa paglitaw ng OOP. Ang halimbawa na may equation ay madaling malutas gamit ang ordinaryong primitives; walang mga bagay na kailangan dito. Ngunit ito ay magiging mahirap kahit na ilarawan ang problema sa mga pagtatapos ng laro nang hindi gumagamit ng ilang mga klase na iyong naimbento. Ngunit sa parehong oras, medyo madali itong ilarawan sa mga klase at bagay: malinaw na kakailanganin natin ang klase ng Laro, ang klase ng Stalker, ang klase ng Ending, ang klase ng Desisyon ng Manlalaro, ang klase ng Game Moment, at iba pa. Iyon ay, kahit na hindi nagsisimulang lutasin ang isang problema, madali nating maiisip ang "mga sketch" ng solusyon nito sa ating mga ulo. Ang pagtaas ng pagiging kumplikado ng mga problema ay nagpilit sa mga programmer na hatiin ang problema sa mga bahagi. Ngunit sa procedural programming hindi ito ganoon kadali. At madalas na ang programa ay isang "puno" ng isang grupo ng mga sanga na may lahat ng posibleng mga pagpipilian para sa operasyon nito. Depende sa ilang mga kundisyon, ang programa ay naisakatuparan sa isang sangay o iba pa. Para sa maliliit na programa ang pagpipiliang ito ay maginhawa, ngunit ang paghahati ng isang malaking gawain sa mga bahagi ay napakahirap. Ang pangangailangang ito ay naging isa pang dahilan para sa paglitaw ng OOP. Ang konseptong ito ay nagbigay sa mga programmer ng kakayahang hatiin ang isang programa sa isang grupo ng mga "modules" ng mga klase, na ang bawat isa ay gumawa ng sarili nitong bahagi ng trabaho. Ang lahat ng mga bagay, na nakikipag-ugnayan sa isa't isa, ay bumubuo sa gawain ng aming programa. Bilang karagdagan, ang code na isinulat namin ay maaaring magamit muli sa ibang lugar sa programa, na nakakatipid din ng maraming oras.