Share
Zoals beschreven in het eerste bericht in deze serie, benaderen we het concept van objectgeoriënteerd programmeren in de context van WordPress, en we doen dit voor de heel beginner.
Dat betekent dat als je nog nooit van OOP hebt gehoord, of als je nieuwsgierig bent geweest om het te leren, en jij bent iemand die geïnteresseerd is in WordPress en leert hoe je er oplossingen bovenop kunt ontwikkelen, dan is deze serie iets voor jou.
In de volgende reeks artikelen gaan we alle belangrijke aspecten van objectgeoriënteerd programmeren behandelen. Zodra we dat doen, gaan we kijken hoe we kunnen toepassen wat we hebben geleerd door een werkende oplossing voor WordPress te bouwen.
Maar eerst moeten we beginnen met de basis.
Als je 10 verschillende ontwikkelaars zou vragen naar hun definitie van een klasse, zou je er waarschijnlijk veel krijgen soortgelijk antwoorden, maar weinigen waren eigenlijk hetzelfde. In feite ging degene die ik het vaakst had horen herhalen toen ik jonger was als volgt:
Een klas is een blauwdruk voor het maken van een object.
In theorie klinkt het geweldig vooral als je weet wat een object is. Maar dat is het probleem, is het niet? We proberen te leren over objectgeoriënteerd programmeren, dus er is geen garantie dat we zelfs weten wat een object is; daarom, hoe kunnen we begrijpen dat een klasse daar als blauwdruk voor dient?
In zekere zin smeekt het de vraag.
Dus laten we een paar stappen nemen en definiëren wat een object is om duidelijker te definiëren wat een klasse is.
Het hele idee van het objectgeoriënteerde programmeerparadigma is dat we, als programmeurs, de informatie die we in de echte wereld zien gemakkelijker kunnen modelleren met behulp van constructies in een code.
In de echte wereld hebben we bijvoorbeeld objecten die kunnen worden beschreven met behulp van bijvoeglijke naamwoorden en deze objecten kunnen acties uitvoeren. Hoewel dit misschien een beetje cliché is, denk even na over een auto:
Nogmaals, een eenvoudig voorbeeld, maar het bewijst het punt dat alles wat we in de echte wereld hebben gewoonlijk kan worden gereduceerd tot een zelfstandig naamwoord dat kan worden beschreven door zijn bijvoeglijke naamwoorden en de acties die het uitvoert.
Dus laten we dit idee generaliseren naar objecten. Laten we in plaats daarvan het ene woord vervangen door het andere:
Makkelijk genoeg, toch? De kern is dat we de dingen die we in de echte wereld zien als de objecten in een programmeerparadigma zouden kunnen beschrijven. Merk op dat sommige talen eigenschappen van kenmerken aanroepen en sommige functies van oproepmethoden. Het maakt ook niet echt uit, het is allemaal hetzelfde. Ze verwijzen eenvoudigweg naar bijvoeglijke naamwoorden over respectievelijk het object en de acties die het kan nemen.
Vervolgens de meeste programmeercursussen of boeken altijd begin met een voorbeeld over hoe objecten bedoeld zijn om objecten uit de echte wereld te modelleren (vergelijkbaar met wat ik deed met het auto-voorbeeld hierboven).
En tot op zekere hoogte is daar waarheid voor. Voor diegene die hebben bezig geweest met de ontwikkeling, dan bent u waarschijnlijk bekend met hoe we mensen kunnen modelleren in de context van onze applicatie, maar die loopt voor op onszelf.
Hoewel het waar is dat we objectgeoriënteerde programmering kunnen gebruiken om objecten uit de echte wereld te modelleren, heb ik ontdekt dat ik vaker, vaker niet een meer algemene vorm van een echt object, zoals een gebruiker liever dan een persoon - en dat de acties die ze uitvoeren meer uniek voor hen zijn.
Daartoe zullen de voorbeelden die ik in dit artikel wil geven en die in de rest van deze reeks meer gericht zijn op praktische toepassingen in de computerprogrammering. Niemand zal een auto plugin schrijven en niemand gaat een dierlijk object maken (wat je ook vaak ziet en hoort in de introductiecursussen).
In plaats daarvan gaan we proberen ons wat meer te richten op objecten die eerder op het gebied van programmeren te zien zijn - niet in de echte wereld. Niet omdat objectgeoriënteerd programmeren zwak is, maar omdat de manier waarop we over het onderwijs gaan zwak is.
Dit roept natuurlijk de vraag op wat een goed voorbeeld is? Het probleem met het beantwoorden van een vraag als deze is dat het letterlijk een breed scala aan dingen kan zijn.
Dit omvat objecten zoals:
En je ziet: veel van deze dingen bestaan niet echt in de echte wereld. Blogberichten zijn bijvoorbeeld niet tastbaar. Het zijn dingen die we op onze schermen lezen. Maar betekent dit dat ze geen eigenschappen hebben zoals een datum, een tijd en een auteur? Of betekent dit dat ze geen acties hebben zoals publiceren en verwijderen?
Natuurlijk niet.
Dus terwijl we door deze reeks heengaan, gaan we het hebben over object in termen van de dingen waarmee we eerder werken.
Ik zie ons op geen enkel moment tijdens deze serie een dier programmeren - en zeker niet zo in WordPress :).
Oké, nu we een korte uitstap hebben gemaakt wat objecten zijn eigenlijk, en goede en slechte voorbeelden van elk, het is tijd om daadwerkelijk te beginnen praten over klassen en hoe ze echt dienen als blauwdrukken voor objecten.
Bij het programmeren wordt een object gemaakt vanuit een klasse. Dat betekent dat een klasse alle eigenschappen definieert die een object heeft en de acties die het kan uitvoeren, waarna de computer een object in het geheugen zal maken.
Als het gaat om lessen, hoor je ontwikkelaars misschien schrijven over het schrijven van lessen, het definiëren van klassen of het bouwen van klassen. Alle voorwaarden zijn aanvaardbaar.
Hierna hoort u mogelijk ontwikkelaars praten over het maken van objecten. Het maken van een object wordt instantiatie genoemd. Ja, het is een groot woord voor een relatief eenvoudig concept. Maar denk er als volgt aan: Wanneer u een klasse hebt, hebt u een definitie waaruit u meerdere exemplaren van een object kunt maken.
Als we een analogie met de echte wereld willen trekken, denk dan eerst aan een reeks blauwdrukken voor een huis. Het legt de plattegrond, afmetingen, muren, enzovoort vast die bouwvakkers informatie geven over hoe een huis te bouwen. Als het dan tijd is om daadwerkelijk een huis te bouwen, bouwt een team van bouwvakkers het huis op basis van de blauwdruk.
Dat is het geval met klassen, instantiatie en objecten. Klassen zijn de blauwdrukken, de computer is het team van bouwvakkers en de objecten zijn het huis. En net zoals meerdere huizen kunnen worden gebouwd vanuit een enkele blauwdruk, is dat het geval met objecten en klassen.
Als het gaat om het schrijven van code, kunnen sommige mensen het object in hun hoofd fotograferen - anderen, misschien ook niet.
Persoonlijk denk ik dat dit meer te maken heeft met hoe ieder van ons de neiging heeft om informatie te leren en te verwerken, maar ik geloof dat het mogelijk is om je mentaal voor te stellen hoe softwaresystemen samenwerken, hoe langer je code schrijft.
Hier gaan we niet naar een ingewikkeld systeem kijken; echter, zijn een voorbeeld van een klas gaan bekijken en vervolgens een visuele weergave van hoe dat eruit zou kunnen zien in termen van code en in termen van een mentaal beeld.
Omdat we te maken hebben met WordPress, is een eerste voorbeeld voor een klas misschien een blogbericht dat een blogpost vertegenwoordigt.
Toegegeven, dit zal een eenvoudig voorbeeld zijn om de ideeën van attributen en functies te demonstreren, maar we zullen verschillende constructies in meer details in toekomstige artikelen behandelen.
Dus, met dat gezegd, laten we zeggen dat we een klas gaan maken voor een blogpost. Laten we ook zeggen dat ons blogbericht een auteur heeft, een datum waarop het is gepubliceerd, of het al dan niet is gepubliceerd en de acties die moeten worden gepubliceerd en verwijderd..
Een voorbeeld van een klassendefinitie voor een blogpost met deze kenmerken en functies ziet er als volgt uit:
class Blog_Post private $ author; privé $ publicatiedatum; privé $ is_published; public function publish () // Publiceer het artikel hier public function delete () // Verwijder hier het artikel
Voor degenen die bekend zijn met objectgeoriënteerd programmeren, kun je een deel van de bovenstaande informatie herkennen, en je kunt ook herkennen dat ik bepaalde dingen (zoals de constructor) heb weggelaten. Maak je daar geen zorgen over - we zullen die concepten later behandelen.
Voor degenen die helemaal nieuw zijn in programmeren, is dit hoe een basisklasse-definitie eruit ziet. Maak je voorlopig nog geen zorgen om de woorden privaat en openbaar zoals we die later zullen behandelen.
Richt je in plaats daarvan op $ auteur, $ publicatie_datum, en $ is_published. Dit zijn de attributen. Merk op dat ze boven de functiedefinities in de klas zitten. Deze zijn analoog aan bijvoeglijke naamwoorden die de Blogpost.
Vervolgens hebben we de functies publiceren() en wissen (). Deze twee functies zijn de acties die kunnen worden ondernomen op de Blogpost. Vergeet niet, hoe objecten in de echte wereld zich kunnen verplaatsen (zoals een auto kan rijden), een blogpost kan worden gepubliceerd.
Dus wat gebeurt er wanneer u daadwerkelijk een blog post instelt? Dat wil zeggen, wanneer kunnen we een blogbericht in code maken, hoe kunnen we ons mentaal voorstellen wat er in de computer gebeurt?.
Laten we eerst eens kijken hoe een blogpost wordt geïnstantieerd. Onthoud dat geïnstantieerd een woord is, net zoals het is gebouwd voor bouwvakkers - het is hoe een object wordt gemaakt van een klas.
Laten we vervolgens eens kijken hoe we de enkele klassedefinitie kunnen gebruiken om drie verschillende blogberichten te maken:
$ first_post = new Blog_Post (); $ second_post = new Blog_Post ();
Makkelijk genoeg om te lezen, toch? Hierboven hebben we twee variabelen gemaakt die verwijzen naar twee compleet verschillende Blogpost voorwerpen.
Merk op dat, hoewel we hierover in een toekomstig artikel meer zullen spreken, het woord nieuwe is wat de computer opdraagt om een a te instantiëren Blogpost van ons uit de klassendefinitie.
Laten we dus eens kijken naar het eerste voorbeeld waarin we onze eerste instantie krijgen Blogpost.
Merk op in deze illustratie, we hebben de $ first_post variabele die verwijst naar de instantie van de Blogpost dat is gemaakt. De Blogpost bestaat in het geheugen van de computer, het heeft zijn attributen die beschikbaar zijn, evenals zijn methoden die beschikbaar zijn.
We hebben toegang tot al deze via de $ first_post variabele die naar dit object verwijst. We zullen daar later in de serie meer in detail over praten.
Maar hoe zit het met de $ second_post? Hoe werkt het dat kijk binnen de context van objectgeoriënteerd programmeren?
Als je de twee illustraties vergelijkt, zien ze er ongeveer hetzelfde uit, toch? $ first_post verwijst naar één instantie van Blogpost, $ second_post verwijst naar een tweede exemplaar van Blogpost ook al zijn ze beide kwam uit een enkele klas.
Merk op dat voor degenen die technisch slim zijn, het is mogelijk voor beide variabelen om naar één exemplaar te verwijzen, maar dat valt buiten het bestek van dit artikel.
Hoe dan ook, op dit punt moet je op hoog niveau begrijpen wat een klasse is, welke rol het speelt in objectgeoriënteerd programmeren en hoe we instanties van objecten kunnen maken die toegankelijk zijn via variabelen.
Dit laat ons nog steeds niet zien hoe we met de klassen moeten omgaan, toch? We komen daar aan, maar eerst moeten we enkele van de meer primitieve aspecten van programmeren bespreken, zoals strings, arrays, loops en conditionals..
Elk van de bovengenoemde constructies helpt ons om onze objecten leven te geven, en als we eenmaal een tournee hebben gemaakt van elk van deze, komen we terug om meer volwassen klassen te maken die echt werk kunnen doen.
Accentsconagua