Einföld skýring á OOP

Hlutbundin forritun (eða OOP) er eitt það illa skilið í tölvuforritun. Það er sérstaklega krefjandi fyrir byrjendur sem virðast ekki geta beitt OOP hugtökum í reynd. Þeir kunna að skilja breytilegt verkefni, ef-þá-annars, lykkjur, aðgerðir, jafnvel einingar, en hvað í ósköpunum eru flokkar, hlutir og aðferðir við ??? Af hverju þurfum við erfðir og fjölbreytni? Hvernig notarðu þessa hluti þegar þú skrifar forrit?

Við skulum skoða hvernig hægt er að skrifa forritakóðann á einfaldasta, lægsta stiginu og fara svo upp á við í átt að einhverju sem er auðveldara að stjórna hvað varðar stærð og flækjustig. Segjum sem svo að við skrifuðum kóða á heimskasta hátt sem mögulegt er: sem gríðarlegur rammi af leiðbeiningum í einni skrá. Það gæti litið svona út:

aðalforrit: ====================== ========================== =================== if ============================== ======== =================== =================== ==== ================== ================================ ============ meðan ===================================== ================= ================== =============== ===== ====================== ======================= = ===================== ============================= =============== fyrir ================================== === =================== ============================ ============= ===================================== ======= ====================== if =================== = ================== ================================ ====== annars ================= ========================== ============ ====================================== === ====================== ===================== ...

Þetta gæti staðið í þúsundir og þúsundir lína! Það gæti innihaldið mörg dæmi um eyðslusamur tvíverknað. Það væri erfitt að lesa og skilja þar sem þér vantar leiðarvísar til að minna þig á hvar hlutirnir eru að gerast.

Svo þetta er þar sem fyrsta forritunaráætlunin okkar kemur upp. Það kallast málsmeðferðarkerfi og það notar verklagsreglur eða aðgerðir til að brjóta niður endalausa rammann af kóða í meðfærilegri verk. Aðferð eða aðgerð er blokk af leiðbeiningum sem hægt er að hringja hvar sem er; það er einnig hægt að hringja ítrekað og þannig spara tvíverknað. (Aðgerð er aðferð sem skilar gildi.) Svona getur hún litið út:

aðalforrit: ====================== ========================== =================== hringja fred ============================= =============== ef ================== ================ ==== =================== kalla eric ====================== === =================== ===================== x: = bob () === =================== ===================== while ========= ======== =================== =================== ==== ================== ====================== kalla eric ========= ============== ===================== =============== ========
málsmeðferð fred: ===================================================== ===================
málsmeðferð eric: ef =================== =========================== =========== ======================================= ===== =======================
fallbob: ====================== ====================== return == =============

Þetta er mikil framför á upphaflegum kóða stöð. Hins vegar, eftir því sem forritið heldur áfram að vaxa að stærð, gæti jafnvel þetta farið úr böndunum. Við getum bætt ástandið með því að kynna hugmyndina um einingar. Eining er einfaldlega safn aðgerða og gagnagerð sem þessar aðgerðir starfa á. Almennt táknar eining samhengi abstrakt af einhverju tagi - gagnagerðin stendur ein og sér sem eitthvað þýðingarmikið og söfnun aðgerða tilheyrir tegundinni ásamt henni. Núna lítur kóðinn okkar svona út:

aðalforrit: ====================== ========================== =================== hringja fred ============================= =============== ef ================== ================ ==== =================== kalla eric ====================== === =================== ===================== x: = bob () === =================== ===================== while ========= ======== =================== =================== ==== ================== ====================== kalla eric ========= ============== ===================== =============== ========
mát Tom:
gögn: ====================== ======================
málsmeðferð fred: ===================================================== ===================
málsmeðferð eric: ef =================== =========================== =========== ======================================= ===== =======================
lok mát Tom
fallbob: ====================== ====================== return == =============

Andlega geturðu skipulagt hugsanir þínar um þetta forrit betur. Module Tom er stór kóði sem þú getur hugsað sem eina einingu. Þú þarft ekki að kafa í smáatriði þess nema þú þurfir að gera það. Það er mjög gagnleg leið til að „abstrakt“ kóðann þinn.

Nú gætirðu haldið að þetta sé allt og endirinn á að stjórna margbreytileika forritsins. Hvað meira þarftu þegar þú ert með einingar?

Það er hins vegar leið til að draga kóðann þinn á hærra stig til að gera það auðveldara að skilja og auðveldara að teygja: mótaðu forritunarlausnina þína sem safn eða net af hlutum sem vinna saman. Þetta var það sem ljómandi framsýnn Alan Kay hafði í huga þegar hann bjó til Smalltalk forritunarkerfið aftur á áttunda áratugnum hjá Xerox PARC.

Þó að fræjum hlutbundinna forritunar gæti hafa verið plantað í Simula 67, var það hugmynd Smalltalk og Alan Kay sem lagði OOP niður í sviðsljósið. Eftir það innblés Smalltalk beint næstum því hvert annað OOP tungumál sem við notum í dag.

Svo hver er hugmyndin á bak við OOP? Hlutur er í raun þróun mátahugtaksins. Hlutur er eining sem umlykur gögn og hegðun, þar sem hegðun er mengi aðgerða eða „aðferða“ sem starfa á gögnunum. Hljómar ógeðslega mikið eins og eining, er það ekki?

En það er fjöldi afgerandi munur. Í fyrsta lagi eru gögnin sem hlutur umbreytir falin fyrir umheiminum. Þetta er ekki tilfellið með mát.

Í öðru lagi, hlutur er venjulega miklu fínni og steypta abstrakt en mát. Það táknar oft eitthvað í hinum raunverulega heimi. Það getur verið afar lítið og einfalt. Það er miklu samheldnara en eining.

Í þriðja lagi, samkvæmt getnaði Alan Kay, er hlutur mjög líkur tölvu með sitt eigið innra ástand og samskiptareglur. Þú hefur samskipti við hlut með því að senda honum skilaboð. Þú biður hlut að gera eitthvað fyrir þig með því að senda honum skilaboð og það bregst við, rétt eins og raunverulegur tölvuþjónn á neti gæti gert. Og rétt eins og á alvöru tölvuþjóni, þá lendirðu ekki í innra ástandi þess.

Hlutur er ekki abstrakt gagnategund

… Þar sem abstrakt gagnategund er háfalútín hugtak fyrir tegund gagnagerðar.

OOP tungumál eins og Java og C ++ eru ómótun á OOP getnaði Alan Kay. Þeir gera OOP erfiðara en það þarf að vera og eru endalaus uppspretta rugl hjá mörgum. Eins og Robert C. Martin segir í „OOP vs FP,“ eru hlutir pokar með aðgerðir, ekki pokar af gögnum. Hlutir eru ekki gagnagerð.

Og hvorugt eru einingar.

Í fjórða lagi, ólíkt mát, getur hlutur erft gögn og hegðun frá öðrum hlut, „foreldri“ hlut, og bætt við aukagögnum og hegðun. Þetta getur verið mjög gagnlegt til að auka virkni forrits. Það getur sparað á tvíverknað af kóða.

Erfðir fara í hendur við annað hugtak: fjölbreytni. Þegar þú sendir skilaboð til hlutar getur hluturinn svarað með því að hringja í eina af aðferðum hans, eða það getur hringt í aðferð í móðurhlutnum. Hluturinn ákveður, ekki þú.

Flokkur er sniðmát fyrir hlutarsköpun. Það inniheldur fullkomna skilgreiningu á hvaða hlut sem er búinn til úr honum. Þegar við búum til hlut úr bekknum segjum við að samstundis gangi í bekkinn. Þetta er frekar hliðstætt því að lýsa yfir breytu af einhverri gerð úr einingunni. Þegar búið er að koma augnabliki í hlut eða tilkynnt er um gagnauppbyggingu má síðan halda áfram að hringja í aðferðir eða aðgerðir sem nota gögnin.

Með því að nota RKE gervikóða lítur dæmi okkar svona út:

aðalforrit: ====================== ===================== aDick: = nýr Dick # tafarlaus með bekknum Dick aDick.fred () # sendu skilaboð fred til aDick ===================== ========== ============ if ===================================== = =================== aDick.eric () ====================== === =================== ===================== x: = bob () === =================== ===================== while ========= ======== =================== =================== ==== ================== ===================== aDick.eric () ===== ================= ================================= ===========
skilgreina bekk Dick:
gögn: ====================== ======================
aðferð fred: ====================== =============================== ===================
aðferð eric: ef =================== =========================== =========== ======================================= ===== =======================
lokaflokkur Dick
fallbob: ====================== ====================== return == =============

Þegar þú kemst að því þá er í raun ekki mikill munur á því að hringja í málsmeðferð, að hringja í málsmeðferð úr mát eða að hringja í aðferð frá hlut. Það er einfaldlega spurning um hvernig þú velur að abstrakt gögn og hegðun (aðgerðir).

Í OOP verður þú að bera kennsl á tækifæri til að umlykja gögn og aðgerðir á hæfilegan hátt. Þú gætir fengið innblástur frá hinum raunverulega heimi. Þú gætir beitt sköpunargáfu og ímyndunarafli. Hvað sem hentar þér.

Þú munt komast að því að OOP er aðeins framlenging á málsmeðferðarforritun og einingum. Það er ekki eins erfitt og þú heldur að það sé, sérstaklega ef þú notar Smalltalk og ekki eitt af helstu tungumálum eins og Java, Python, C ++ og C #.

Fyrir nokkur dæmi um OOP, lestu Hvað er hlutbundin forritun?