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.
![Mga prinsipyo ng object-oriented programming - 1]()
Malamang na madali mong mabasa ang code na nakasulat sa wikang ito at ipaliwanag sa malawak na mga stroke kung ano ang ginagawa nito :)
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;
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;
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!");
}
}
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.speak();
}
}
public static void main(String[] args) {
Animal cat = new Cat();
cat.speak();
}
public class AnimalBarbershop {
public void trim(Animal animal) {
System.out.println("The haircut is done!");
}
}
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
AnimalBarbershop barbershop = new AnimalBarbershop();
barbershop.trim(cat);
barbershop.trim(dog);
}
GO TO FULL VERSION