JAVA Object Oriented Programming Concepts

Ang JAVA ay batay sa mga konsepto ng object-oriented programming, na nagpapahintulot sa iyo na lumipat sa mas mataas na antas ng abstraction upang malutas ang anumang problema sa isang makatotohanang paraan. Ang object-oriented approach ay nagkonsepto ng solusyon sa isang problema sa mga tuntunin ng real-world na mga bagay na mas madaling gamitin muli sa isang application. Halimbawa, Chair(silya), Fan(fan), Dog(Aso), Computer(computer) at iba pa. Sa JAVA, ang isang klase ay isang layout, template, o prototype na tumutukoy sa pangkalahatang pag-uugali ng isang bagay ng isang partikular na uri. Ang isang halimbawa ay isang hiwalay na pagpapatupad ng isang klase, at lahat ng mga pagkakataon ng isang klase ay may parehong mga katangian, na inilarawan sa kahulugan ng klase. Halimbawa, maaari mong tukuyin ang isang klase na pinangalanang House na may bilang ng mga silid bilang isang katangian at lumikha ng mga pagkakataon ng klase tulad ng isang dalawang silid na bahay, isang tatlong silid na bahay, at iba pa. Mga Bentahe: Nakalista sa ibaba ang ilang mga bentahe ng object-oriented na software development.

• Nabawasan ang mga gastos sa suporta sa software, pangunahin dahil sa ang katunayan na ito ay isinasagawa nang modularly.
• Pinahusay na muling paggamit ng code sa pamamagitan ng mga feature gaya ng inheritance, na nagreresulta sa mas mabilis na pag-develop ng software.
• Nadagdagang pagiging maaasahan at flexibility ng code.
• Dali ng pag-unawa dahil sa totoong mundo simulation.
• Mas mahusay na abstraction sa antas ng bagay.
• Pagbabawas sa pagiging kumplikado ng paglipat mula sa isang yugto ng pag-unlad patungo sa isa pa.

Mayroong apat na pangunahing katangian ng OOP:

• Encapsulation
• Mana
• Polymorphism
• Abstraction

Encapsulation

Ang encapsulation ay gumaganap bilang isang kontrata para sa isang bagay kung ano ang dapat nitong itago at kung ano ang dapat nitong buksan para ma-access ng iba pang mga bagay. Sa JAVA, gumagamit kami ng access modifier privateupang itago ang isang paraan at paghigpitan ang pag-access sa isang variable mula sa labas ng mundo. Ang JAVA ay mayroon ding iba't ibang access modifier: public, default, protected, private, na ginagamit upang paghigpitan ang visibility sa iba't ibang antas. Ngunit ang sukdulang layunin ay i-encapsulate ang mga bagay na hindi dapat baguhin. Ang diskarte na pinakamahusay na gumagana ay ang isang klase ay dapat magkaroon lamang ng isang dahilan upang magbago, at ginagawang realidad ng encapsulation ang disenyo ng "isang dahilan" na iyon. Ang tamang diskarte sa encapsulation ay upang itago ang mga bagay na madalas na nagbabago upang maiwasan ang pagkasira ng ibang mga klase. Mga Benepisyo: Nasa ibaba ang ilan sa mga benepisyo ng encapsulation:

• Mapoprotektahan natin ang panloob na estado ng isang bagay sa pamamagitan ng pagtatago ng mga katangian nito.
• Pinapabuti nito ang modularity ng code dahil pinipigilan nito ang mga bagay na makipag-ugnayan sa mga hindi inaasahang paraan.
• Nagpapabuti ng kakayahang magamit ng code.
• Sinusuportahan nito ang kontraktwal na relasyon ng isang partikular na entity.
• Ginagawang mas madaling mapanatili ng encapsulation ang software.
• Ang mga pagbabago sa code ay maaaring gawin nang nakapag-iisa sa bawat isa.

Polymorphism

Ang polymorphism sa programming ay ang kakayahang magbigay ng parehong interface para sa iba't ibang pinagbabatayan na mga form (mga uri ng data). Nangangahulugan ito na ang mga klase na may magkakaibang pag-andar ay nagbabahagi ng parehong interface at maaaring tawaging dynamic sa pamamagitan ng pagpasa ng mga parameter sa pamamagitan ng sanggunian. Ang isang klasikong halimbawa ay ang klase Shape(hugis) at ang lahat ng klase na nagmana mula rito: square(parisukat), circle(bilog), dodecahedron(dodecahedron), irregular polygon(irregular polygon), splat(blob), at iba pa. Sa halimbawang ito, ang bawat klase ay magkakaroon ng sarili nitong pamamaraan Draw()at ang client code ay maaaring gawin lamang:

Shape shape = new Shape();

Shape.area()upang makuha ang tamang pag-uugali ng anumang hugis Ang kagandahan ng polymorphism ay ang code, na gumagana sa iba't ibang klase, ay hindi kailangang malaman kung aling klase ang ginagamit nito, dahil lahat sila ay gumagana sa parehong prinsipyo. Ang prosesong ginagamit ng mga object-oriented programming language upang ipatupad ang dynamic polymorphism ay tinatawag na dynamic binding. Tandaan: Ang polymorphism ay ang kakayahang pumili ng mas tiyak na mga pamamaraan na isasagawa depende sa bagay. Ang polymorphism ay nangyayari kapag ang mga abstract na klase ay hindi kasama. Mga kalamangan:

• Paglikha ng reusable code. Ibig sabihin, kapag ang isang klase ay nalikha, naipatupad, at nasubok, maaari itong malayang magamit nang hindi nababahala tungkol sa kung ano ang eksaktong nakasulat dito.
• Nagbibigay-daan ito para sa mas generic at maluwag na pinagsamang code.
• Ang oras ng compilation ay nabawasan, na nagpapabilis sa pag-unlad.
• Dynamic na pag-uugnay.
• Ang parehong interface ay maaaring gamitin upang lumikha ng mga pamamaraan na may iba't ibang mga pagpapatupad.
• Ang buong pagpapatupad ay maaaring palitan sa pamamagitan ng paggamit ng parehong paraan ng mga lagda.

Pamamaraang overriding bilang bahagi ng polymorphism. Ang isang override ay nakikipag-ugnayan sa dalawang pamamaraan: isang paraan sa parent na klase at isang paraan sa nagmula na klase. Ang mga pamamaraang ito ay may parehong pangalan at mga lagda. Binibigyang-daan ka ng overriding na gawin ang parehong operasyon sa iba't ibang paraan para sa iba't ibang uri ng mga bagay. Halimbawa:

while(it.hasNext()) {
Shape s = (Shape) it.next();
totalArea += s.area(dim); //будет применен полиморфизм и вызван нужный метод для каждого an object.
}

Overloading ng pamamaraan o ad-hoc polymorphism o static polymorphism Ang overloading ay nakikipag-ugnayan sa maraming pamamaraan ng parehong klase na magkapareho ang pangalan ngunit may magkakaibang mga lagda ng pamamaraan. Ang pag-reload ay nagbibigay-daan sa iyo na ilarawan ang parehong operasyon sa iba't ibang paraan para sa iba't ibang data. Minsan ito ay tinatawag na static polymorphism, ngunit sa katunayan ito ay hindi polymorphism. Ito ay walang iba kundi ang pagkakaroon lamang ng dalawang pamamaraan na may parehong mga pangalan, ngunit ibang listahan ng mga argumento. Ang pag-reboot ay walang kinalaman sa mana at polymorphism. At ang isang overloaded na paraan ay hindi pareho sa isang overridden na paraan. Parametric Polymorphism sa pamamagitan ng Generication sa JAVA Kapag nagdedeklara ng isang klase, ang field ng pangalan ay maaaring iugnay sa iba't ibang uri, at ang pangalan ng pamamaraan ay maaaring iugnay sa iba't ibang mga parameter at mga uri ng pagbabalik. Sinusuportahan ng JAVA ang parametric polymorphism sa pamamagitan ng paggamit ng generics.

List<String> list = new ArrayList<String>();

Bakit hindi natin ma-override ang isang static na pamamaraan sa JAVA? Ang pag-override ay depende sa pagkakaroon ng isang instance ng klase. Ang ideya ng polymorphism ay maaari kang lumikha ng isang subclass, at ang mga bagay na ipinatupad ng mga subclass na iyon ay magiging iba sa parehong paraan ng parent class (na-override sa mga subclass). Ang isang static na pamamaraan ay hindi nauugnay sa anumang mga pagkakataon ng klase, kaya ang konsepto ng pag-override mismo ay hindi mailalapat. Ang mga tagalikha ng JAVA ay ginabayan ng dalawang pagsasaalang-alang na nakaimpluwensya sa pamamaraang ito. Una, may mga problema sa pagpapatupad ng code: nagkaroon ng maraming kritisismo sa Smalltalk dahil sa pagiging mabagal (pagkolekta ng basura at polymorphism ay bahagi ng problemang ito), at ang JAVA ay idinisenyo upang maiwasan ito. Ang pangalawang pagsasaalang-alang ay ang desisyon na ang target na madla ng JAVA ay mga C++ developer. Ang pagkakaroon ng mga static na pamamaraan na gumagana sa ganitong paraan ay napakapamilyar sa mga programmer ng C++, at pinabilis din ang mga bagay dahil hindi na kailangang umakyat sa hierarchy ng klase upang malaman kung aling paraan ang tatawagan. Dumiretso ka sa klase at tumawag ng isang tiyak na paraan.

Mana

Ang inheritance ay ang pagkilos ng pagsasama ng gawi (i.e. mga pamamaraan) at estado (i.e. mga variable) ng isang baseng klase sa isang derived na klase upang maging available ang mga ito sa nagmula na klase na iyon. Ang pangunahing bentahe ng mana ay nagbibigay ito ng isang pormal na mekanismo para sa muling paggamit ng code at maiwasan ang pagdoble. Pinapalawak ng isang minanang klase ang functionality ng application sa pamamagitan ng pagkopya sa gawi ng parent class at pagdaragdag ng bagong functionality. Ginagawa nitong lubos na pinagsama ang code. Kung gusto mong baguhin ang superclass, kailangan mong malaman ang lahat ng mga detalye ng mga subclass upang hindi masira ang code. Ang inheritance ay isang paraan ng muling paggamit ng software kung saan ang isang bagong klase (subclass) ay nilikha mula sa isang umiiral na klase (superclass) na nagpapalawak ng functionality nito at gumagamit ng ilan sa mga katangian ng superclass. Kaya kung mayroon kang klase ng magulang at pagkatapos ay may lalabas na klase ng bata, mamanahin ng bata ang lahat ng bagay na mayroon ang magulang. Mga kalamangan:

• Pinahusay na paggamit muli ng code.
• Ang lohikal na kaugnayan "ay isang" (ay isang tao, isang bagay) ay itinatag. Halimbawa: Ang aso ay isang n hayop . (Ang aso ay isang hayop).
• Modularisasyon ng code.
• Ang mga pag-uulit ay hindi kasama.

kapintasan:

• Mahigpit na pinagsama: Ang isang subclass ay nakasalalay sa pagpapatupad ng isang parent na klase, na ginagawang mahigpit na pinagsama ang code.

Abstraction

Ang ibig sabihin ng abstraction ay ang pagdidisenyo ng mga klase batay sa kanilang mga interface at functionality, nang hindi isinasaalang-alang ang mga detalye ng pagpapatupad. Ang isang abstract na klase ay kumakatawan sa mga interface nang hindi kasama ang aktwal na pagpapatupad. Nakikilala nito ang pagpapatupad ng isang bagay mula sa pag-uugali nito. Pinapasimple ng abstraction ang code sa pamamagitan ng pagtatago ng mga hindi mahalagang detalye. Mga kalamangan:

• Sa paggamit ng abstraction, maaari nating paghiwalayin kung ano ang maaaring ipangkat sa ilang uri.
• Ang mga madalas na binagong katangian at pamamaraan ay maaaring ipangkat sa isang hiwalay na uri, kaya ang pangunahing uri ay hindi sasailalim sa mga pagbabago. Pinapatibay nito ang prinsipyo ng OOP: "Ang code ay dapat na bukas sa Extension, ngunit sarado sa Pagbabago . "
• Pinapasimple ng abstraction ang representasyon ng mga modelo ng domain.

Pagkakaiba sa pagitan ng abstraction at encapsulation Ang encapsulation ay isang diskarte na ginamit bilang bahagi ng abstraction. Ang encapsulation ay tumutukoy sa istraktura ng isang bagay: ang mga bagay ay naka-encapsulate ng kanilang mga katangian at itinatago ang mga ito mula sa labas ng access. Ang mga gumagamit ng isang klase ay nakikipag-ugnayan dito gamit ang mga pamamaraan nito, ngunit walang direktang access sa istraktura ng klase. Sa ganitong paraan, ini-abstract ng klase ang mga detalye ng pagpapatupad na may kaugnayan sa disenyo nito. Ang abstraction ay isang mas pangkalahatang termino. Maaari rin itong makamit, bukod sa iba pang mga bagay, gamit ang mga subclass. Halimbawa, ang isang klase List(listahan) sa karaniwang aklatan ay isang abstraction para sa isang pagkakasunud-sunod ng mga elemento, na na-index ayon sa kanilang lugar sa listahan. Ang mga partikular na halimbawa ng isang listahan Listay ArrayListo LinkedList. Ang code na nakikipag-ugnayan sa isang listahan Listay nag-abstract ng mga detalye kung aling listahan ang ginagamit nito. Kadalasan ang abstraction ay hindi posible nang hindi itinatago ang pinagbabatayan na estado gamit ang encapsulation. Kung inilantad ng isang klase ang panloob na istraktura nito, hindi nito mababago ang mga panloob na operasyon nito, at samakatuwid ay hindi maaaring i-abstract. Ano ang abstract class at abstract na pamamaraan? Nangyayari na sa panahon ng pag-unlad gusto mo ang isang base class na magbigay lamang ng isang interface sa mga nagmula nitong mga klase. Ibig sabihin, hindi mo gustong gumawa ang sinuman ng mga instance ng base class. Kailangan mong gamitin ang interface sa paraang nag-cast ka lang ng mga bagay dito (ito ay isang implicit na cast na nagbibigay-daan sa polymorphic na pag-uugali). Ito ay nakakamit sa pamamagitan ng paggawa ng klaseng ito abstract gamit ang keyword abstract. Nagpapataw ito ng ilang mga paghihigpit, tulad ng kawalan ng kakayahang lumikha ng mga pagkakataon ng isang abstract na klase; kapag gumagamit ng abstract na klase, kinakailangan na ipatupad ang mga abstract na pamamaraan. Tinitiyak nito ang polymorphism. Ang isang abstract na klase ay maaaring maglaman ng parehong abstract at kongkreto na mga pamamaraan. Kung ang hindi bababa sa isang paraan sa isang klase ay idineklara na abstract, ang buong klase ay dapat ding ideklarang abstract. Gayunpaman, ang panuntunan sa kabaligtaran na direksyon ay hindi kailangang sundin. Kung ang isang klase ay idineklara na abstract, maaaring hindi ito naglalaman ng mga abstract na pamamaraan. Ang isang pamamaraan na tumutukoy lamang sa mga lagda nito at hindi nagbibigay ng pagpapatupad ay tinatawag na abstract. Ang aktwal na pagpapatupad nito ay naiwan sa mga subclass nito, na nagpapalawak sa abstract na klase. Ang isang abstract na pamamaraan ay hindi maaaring gamitin ng isang bagay, isa pang klase lamang ang makakapagpalawig nito. Kailan mo dapat gamitin ang abstract na klase? Binibigyang-daan ka ng mga abstract na klase na tukuyin ang ilang default na gawi at ang mga subclass ay nagbibigay ng anumang partikular na gawi. Halimbawa: List(listahan) ay isang interface, sa turn AbstractListay tumutukoy sa pangunahing pag-uugali ng isang Listahan, na maaaring gamitin bilang ay o pino sa isang subclass, halimbawa, sa ArrayList(listahan array). Ano ang isang interface? Ang konsepto ng isang interface ay isang abstract na klase, ngunit ang interface (tinukoy ng keyword interface) ay nagpapatuloy ng isang hakbang. Pinipigilan nito ang anumang pagpapatupad ng isang paraan o function sa lahat. Maaari ka lamang magdeklara ng isang paraan o function, ngunit hindi ibigay ang pagpapatupad nito. Ang klase na nagpapatupad ng interface ay dapat pangalagaan ang aktwal na pagpapatupad. Ang mga interface ay lubhang kapaki-pakinabang at malawakang ginagamit sa OOP. Dahil ibinabahagi nila ang mismong interface at ang pagpapatupad, nagbibigay sila ng maraming pakinabang ng kanilang paggamit:

1. Maramihang mana .
2. Maluwag na pagkabit . Mayroong abstraction ng operasyon, tulad ng layering, at ang kongkretong pagpapatupad ay maaaring anuman: JDBC, JPA, JTA, atbp.
3. Ang interface program ay hindi ipinatupad .
4. Dynamic na binding polymorphism : Ang interface ng programming ng isang bagay ay nakalantad nang hindi inilalantad ang aktwal na pagpapatupad nito.
5. Mga antas ng abstract , paghihiwalay ng pag-andar.

Pagkakaiba sa pagitan ng interface at abstract na klase.

• Ang interface ay isang kontraktwal na relasyon sa mga klase na nagpapatupad ng interface na ito, na nagsasaad na ang pagpapatupad ay nangyayari sa paraang itinalaga ng interface. Ito ay isang walang laman na shell na may mga ipinahayag na pamamaraan.
• Tinutukoy ng abstract na klase ang ilang pangkalahatang pag-uugali at hinihiling sa mga subclass nito na tukuyin ang hindi tipikal o partikular na pag-uugali para sa kanilang klase.
• Ang mga pamamaraan at miyembro ng abstract na klase ay maaaring italaga sa anumang access modifier; sa turn, ang lahat ng paraan ng interface ay dapat na pampubliko.
• Kapag nagmamana ng abstract na klase, dapat tukuyin ng descendant class ang mga abstract na pamamaraan, habang ang isang interface ay maaaring magmana ng isa pang interface nang hindi kinakailangang tukuyin ang mga pamamaraan nito.
• Ang isang descendant na klase ay maaaring mag-extend lamang ng isang abstract na klase, ngunit ang isang interface ay maaaring mag-extend o ang isang klase ay maaaring magpatupad ng maraming iba pang mga interface.
• Maaaring tukuyin ng isang descendant class ang mga abstract na pamamaraan na may pareho o hindi gaanong mahigpit na access modifier, ngunit ang klase na nagpapatupad ng interface ay dapat tukuyin ang mga pamamaraan na may parehong antas ng visibility.
• Ang isang interface ay hindi naglalaman ng mga konstruktor, habang ang isang abstract na klase ay mayroon.
• Ang mga variable na idineklara sa Java interface ay pinal bilang default. Ang abstract na klase ay maaaring maglaman ng mga variable na hindi pangwakas.
• Ang lahat ng miyembro ng Java interface ay public. Ang mga miyembro ng isang abstract na klase ay kayang maging public, protectedatbp.

Komposisyon

Maaaring makamit ang muling paggamit ng code gamit ang parehong mana at komposisyon. Ngunit ang paggamit ng komposisyon ay nagbibigay ng mas mataas na antas ng encapsulation kaysa inheritance, dahil ang mga pagbabago sa back-end na klase ay hindi kinakailangang makakaapekto sa code na kabilang sa front-end na klase. Ang komposisyon ay isang diskarte sa disenyo na gumagamit ng "may-a" (may, kasama) na mga ugnayan sa mga klase. Parehong java inheritance at object composition ay maaaring gamitin upang muling gamitin ang code. Ang kakanyahan ng komposisyon ay upang ipahayag ang "may" relasyon sa pagitan ng mga bagay. Mag-isip tungkol sa isang upuan. May upuan ang upuan. May likod ang upuan. Ang isang upuan ay may isang tiyak na bilang ng mga binti. Ang pariralang "may isang" ay nagpapahiwatig ng isang relasyon kung saan ang upuan ay may, o hindi bababa sa gumagamit, ng isa pang bagay. Ito ay tiyak na "may-a" na relasyon, na siyang batayan ng komposisyon. Mga kalamangan:

• Kontrol ng visibility
• Ang pagpapatupad ay maaaring mapalitan sa run-time
• Maluwag na pagkabit, dahil ang klase ng interface ay hindi nakasalalay sa pagpapatupad.

Mga pagkakaiba sa pagitan ng komposisyon at mana Tandaan: Huwag gumamit ng inheritance para lang matiyak na magagamit muli ang code. Kung walang kaugnayang "ay isang" (ay), ang komposisyon ay ginagamit para sa mga layuning ito. Ang pagkakaiba sa pagitan ng komposisyon at pagsasama-sama ay nasa mga ugnayan ng bagay. Ang pagsasama-sama ay isang relasyon kung saan ang isang klase ay umaangkop sa isang koleksyon. Ito ay bahagi ng isang buong relasyon, kung saan ang bahagi ay maaaring umiral nang wala ang kabuuan. Ang ganitong mga relasyon ay mas mahina. Walang cyclic dependency. Halimbawa: order at produkto. Ang komposisyon ay isang relasyon kung saan ang isang klase ay umaangkop sa isang koleksyon. Ito ay isang bahagi ng isang buong relasyon, kung saan ang bahagi ay hindi maaaring umiral kung wala ang kabuuan. Kung masisira ang kabuuan, masisira rin ang lahat ng bahagi nito. Ito ay isang mas matibay na relasyon. Halimbawa: isang polygon at mga vertex nito, isang order at bahagi nito.