Share
In het vorige artikel hebben we het concept van objectgeoriënteerde overerving geïntroduceerd, gepoogd om de termen van leken te plaatsen, en vervolgens ook op hoog niveau gekeken naar het conceptuele model van hoe het werkt binnen de context van programmeren.
Maar voordat we verder gaan en / of als je gewoon meedoet aan de serie, bekijk dan alles wat we tot nu toe hebben besproken door de vorige artikelen te lezen:
Ja - we hebben veel besproken, maar om de basis te leggen voor een beginner om een sterke plek te hebben om objectgeoriënteerde PHP te gaan schrijven, is er nog veel te onderzoeken.
Met dat gezegd, overerving is waar we beginnen om in de tussenliggende onderwerpen van het paradigma te komen, dus dit zal het laatste artikel zijn dat een blik werpt op de beginner-concepten, waarna we de serie met een samenvattende post zullen beëindigen..
Bedenk dat we overerving hebben gedefinieerd als de volgende:
Overname is wanneer een klasse fungeert als de bovenliggende klasse voor een onderliggende klasse die een aantal attributen en methoden biedt die zowel de ouder als het kind gemeenschappelijk hebben; echter, het kind als het vermogen om zijn eigen attributen te introduceren.
Het is iets minder formeel dan wat je misschien in een academisch boek vindt, of zelfs op Wikipedia, maar het verklaart het idee nog altijd in termen die het punt illustreren.
In dit artikel zullen we alle benodigde code, functies en gereserveerde woorden met betrekking tot het onderwerp bekijken, we gaan kijken hoe we het binnen PHP kunnen implementeren op een zeer, zeer eenvoudige platform-agnostische manier , En dan zullen we een daadwerkelijke implementatie bekijken van waar erfenis binnen WordPress speelt.
Dus met die set als onze routekaart voor het artikel, laten we doorgaan en aan de slag gaan.
Om overerving in objectgeoriënteerde PHP te implementeren, zijn er een aantal gereserveerde woorden waarmee we ons vertrouwd moeten maken. Gelukkig zijn de meeste woorden die we al hebben behandeld en de woorden die we niet hebben zo duidelijk dat het gemakkelijk is ze te onthouden.
Dus voordat we de code gaan bekijken, laten we eens kijken naar alle gereserveerde woorden in de taal die we moeten weten, zodat we daadwerkelijk kunnen beginnen met het maken van iets.
Accentsconagua
strekt is gereserveerd woord dat aangeeft dat een klas het kind is van een andere klas. In ons vorige artikel bijvoorbeeld, Post strekt Inhoud. We zullen dit snel in het spel zien.privaat is een kenmerk dat wordt toegepast op eigenschappen en functies, wat betekent dat ze toegankelijk zijn enkel en alleen binnen de context van de klasse waarin ze zijn gedefinieerd.beschermde is gelijkaardig aan privaat met de uitzondering dat de eigenschappen en methoden die als zodanig zijn gemarkeerd, toegankelijk zijn voor de betreffende klasse en eventuele onderliggende klassen.openbaar is het tegenovergestelde van privaat in die zin dat elke klasse - de gegeven klasse, een subklasse of een klasse van derden - toegang heeft tot de eigenschap of methode om de informatie te wijzigen of de functie te bellen.U moet ook bekend zijn met de :: operator, maar we zullen dat later in het artikel bespreken als we beginnen met het kijken naar code.
En dat is het - niets verschrikkelijk beangstigend, toch? En wat nog beter is, is dat als je in de loop van deze serie met ons meegaat, je waarschijnlijk vertrouwd bent met elk woord dat je bewaart strekt.
Hoe dan ook, met dat gezegd, laten we beginnen met het werken aan een voorbeeld.
Om aan de slag te gaan met het schrijven van een voorbeeldcode, moeten we precies uitleggen wat het is dat we proberen te modelleren (dat is tenslotte wat code is, nietwaar?).
In overeenstemming met het thema dat in deze serie wordt gebruikt - vooral in het laatste artikel - krijgen we een oudercursus Inhoud, en twee kinderlessen die elk een naam zullen krijgen Commentaar en Post, respectievelijk.
Dit zal ons in staat stellen om te zien hoe eigenschappen en methoden er zijn binnen een enkele klasse, en hoe kinderen toegang hebben tot attributen van hun ouders, evenals hoe ouders hun eigenschappen en functies kunnen beschermen tegen hun kinderen, en.
Maar de implementatie zal veel meer laten zien dan erover te praten, dus laten we beginnen met het schrijven van wat code.
In ons voorbeeld wordt de bovenliggende klasse de Inhoud omdat beide subklassen - dat wil zeggen, de Post en de Commentaar - zijn typen inhoud met unieke informatie die aan hen is gekoppeld en niet specifiek is voor de Inhoud klasse.
De sleutel tot overerving is om alle eigenschappen en methoden te identificeren die in alle klassen voorkomen en ze te laten definiëren in de bovenliggende klasse of, in onze klas, in Inhoud.
Hoewel dit kan verschillen op basis van hoe je dit bekijkt, zullen we het instellen Inhoud zodanig dat het omvat:
Eerst zullen we de code bekijken, dan zullen we alles uitleggen wat er aan de hand is.
publish_date = $ date-> format ('Y-m-d H: i: s'); $ this-> author = "; public function save ($ author, $ content) $ this-> author = $ author; $ this-> content = $ this-> format_content ($ content); $ this-> content ; openbare functie lezen () return $ this-> content; persoonlijke functie format_content ($ content) return strip_tags (stripslashes ($ content)); public function get_author () return $ this-> author;Zoals eerder vermeld, hebben we er twee beschermde attributen en a privaat attribuut. Bedenk dat dit betekent dat alle subklassen toegang hebben tot de $ publicatie_datum en de $ auteur, maar enkel en alleen de Inhoud kan toegang krijgen tot de $ inhoud attribuut.
Merk ook op dat veel van de code die u in de bovenstaande klasse ziet, elementaire objectgeoriënteerde PHP is. Er is niets dat opvalt dat rechtstreeks iets te maken heeft met overerving anders dan enkele van de toegangsmodificators die we hebben verklaard. Dat wil zeggen dat het relatief vaak voorkomt bij code die we tot nu toe hebben gezien in deze tutorial.
Een van de dingen die vermeldenswaard is, is dat de privéfunctie aanwezig is om twee dingen te demonstreren:
privaat functies zijn alleen toegankelijk binnen de context van de klasse waarin deze is gedefinieerd.Natuurlijk is deze code niet verbonden met een database of een bestandssysteem of iets anders, maar het punt blijft bestaan.
Merk op dat er in de bovenstaande code een aantal dingen zijn die we moeten toevoegen om te voldoen aan de vereisten van PHP. Ze vallen buiten het bestek van dit artikel, maar het is de moeite waard hier te wijzen:
date_default_time_set is vereist om de tijdzone in te stellen waarvan de tijd kan worden opgehaald.Post kan zijn eigen auteur hebben en de Commentaar kan ook een eigen auteur hebben. Zoals we later zullen zien, Commentaar kan zelfs de standaard publicatiedatum overschrijven.Merk ook op dat we de inhoud van de kunnen ophalen lezen methode en we kunnen de auteur ophalen van de get_author functie.
Vervolgens gaan we door en maken we het Post subklasse. Eerst zullen we de code bekijken en dan zullen we zien hoe het interageert met de Inhoud klas die we net hebben gemaakt.
author = 'Tom McFarlin'; public function post ($ content) $ this-> format_content ($ content);
De klas lijkt klein, toch? Er zijn geen eigenschappen - omdat het ze van de eigenaar overneemt Inhoud klasse - en er zijn slechts twee functies, waarvan er een uniek is voor de klas - post.
Merk op dat we in de constructor eerst een aanroep doen naar de ouderconstructor met behulp van de :: operator. U kunt hier veel meer over lezen in de handleiding, maar het volstaat om te zeggen dat de operator is gereserveerd om te verwijzen naar een aantal verschildingen buiten de klasse waarin deze is gedefinieerd. In ons geval is dat de aanroep naar de constructor van de ouder.
Vervolgens heb ik ervoor gekozen om mijn naam als auteur van de post in te stellen. Merk op dat ik de $ this trefwoord. Omdat de subklasse eigenschappen van het bovenliggende element overneemt, kan deze naar die eigenschappen verwijzen en of ze in zichzelf zijn gedefinieerd.
Merk op dat dit mogelijk is, niet alleen omdat Bericht breidt inhoud uit maar omdat het eigendom is gemarkeerd als beschermde in Inhoud, ook. Als het was gemarkeerd als privaat, dit zou niet mogelijk zijn.
Nu dat we de Post klas, we hebben ook de Commentaar klasse die, terugroepend, iemand vertegenwoordigt die een commentaar achterlaat op een bericht. Als deze code op productieniveau zou bestaan, zou er veel meer code zijn: we zouden een opmerking aan een bericht moeten relateren, bepalen of een opmerking een antwoord op een bestaande opmerking is, een status van een opmerking markeren, enzovoort.
Maar om te demonstreren erfenis, we laten dat allemaal achter ons en richten ons alleen op de dingen die de concepten kunnen aansturen.
opslaan ('John Doe', $ opmerking); Zoals u kunt zien, de Commentaar code is niet veel verschillend van de Post code. Tot op zekere hoogte - dit is goed omdat het laat zien dat we de juiste onderdelen hebben geabstraheerd naar onze basisklasse.
Hoe dan ook, merk op dat nadat we de Commentaar, we bellen naar de ouderconstructeur. Vervolgens definiëren we de toevoegen methode die verantwoordelijk is voor het nemen van de inkomende reactie en deze vervolgens opslaat door de auteur van de opmerking en de inhoud ervan door te geven aan de opslaan methode.
Het leuke is dat het opslaan methode is al gedefinieerd binnen de basisklasse, die ook alle opmaak verwerkt door het gebruik van een privaat functie, dus we krijgen die functionaliteit als we onze kinderklasse maken.
Als dat klaar is, laten we een paar voorbeelden uitvoeren om te laten zien hoe de stukjes bij elkaar passen. Om ervoor te zorgen dat deze code wordt uitgevoerd, heeft u alleen een webserver nodig, een map waaruit PHP-scripts kunnen worden uitgevoerd en een teksteditor..
Eerst maken we een instantie van Inhoud en dan zullen we een debug-verklaring oproepen zodat we kunnen zien wat een instantie van de klas is.
$ content = nieuwe inhoud (); var_dump ($ inhoud);
Als je alle werken correct toestaat, zou je alles moeten zien dat hierboven staat.
Vervolgens gaan we door en maken we een bericht. Omdat we alle informatie in de context van de klas plaatsen, hoeven we alleen maar een functie in de klas aan te roepen om de informatie weer te geven.
Bijvoorbeeld:
$ post = new Post (); echo 'De auteur van het bericht is:'. $ Post-> get_author ();
Nogmaals, aangezien we alles in de code zelf hebben ingesteld, demonstreert het eenvoudigweg bellen met de methode het concept.
Eindelijk kunnen we een maken Commentaar, bel de toevoegen methode op een instantie van de klasse, poging om kwaadaardige code door te geven (alleen om te zien dat deze is ontdaan van onze code). Als alles goed gaat, ziet u het volgende:
$ comment = new Comment (); $ comment-> add (''); echo 'De opmerking luidt:'. $ Comment-> lees ();En dat is het: onze eenvoudige demonstratie van erfenis.
Als het gaat om het kijken naar overerving in WordPress, is het eerste dat me te binnen schiet - en waarschijnlijk andere ontwikkelaars - de Widgets-API. De reden dat ik dit zeg, is omdat de API wordt aangedreven door overerving.
Natuurlijk, widgets kunnen worden gemaakt zonder de API te gebruiken, maar ik zou beweren dat dit een misstap is in de ontwikkeling. Waarom maak je het jezelf wat ingewikkelder als er al een basis is om het te doen? Maar ik dwaal af.
Het leuke van deze specifieke API is dat deze alle hoogtepunten van objectgeoriënteerd programmeren en overerven op het werk laat zien. Hier is bijvoorbeeld een voorbeeldcode die rechtstreeks uit de Codex is overgenomen:
Nu we het conceptuele model hebben besproken, gekeken naar de sleutelwoorden en methodologie, onze eigen code hebben geschreven en ons eigen voorbeeld hebben gemaakt, zou dit relatief gemakkelijk te volgen moeten zijn.
Maar hier is het ding: een van de beste manieren om beter te worden in het schrijven van elk type code is om de concepten voortdurend te oefenen. Dat wil zeggen, om de ideeën te verkennen die zijn geschreven door andere mensen die geavanceerdere dingen hebben gedaan die u eerder hebt gedaan.
Zie bijvoorbeeld het eerste voorbeeld in de WordPress Codex. En als je werkt met een latere versie van PHP die functies zoals naamruimten ondersteunt (een iets geavanceerder onderwerp), bekijk dan ook het tweede voorbeeld.
Hoe meer je de code bekijkt en plaagt, hoe meer je erover te weten komt. Maar verder gaan dan dat in dit artikel zal ons buiten het bereik van de hele serie brengen.
Naar het einde
Op dit punt hebben we al het beginnersmateriaal behandeld dat nodig is om de basis te leggen voor een beginnershandleiding voor het schrijven van objectgerichte PHP. In het laatste artikel geven we een samenvatting van alles wat we hebben behandeld, zodat we één referentie hebben voor de grote ideeën waaraan later een bladwijzer kan worden toegevoegd, die kan worden opgeslagen of waarnaar later wordt verwezen.
Daarnaast hebben we een korte periode van discussie over een vervolgserie, maar die bewaren we tot die tijd.
Voor nu, als je vragen, opmerkingen en / of feedback hebt over de inhoud, code of voorbeelden hierboven, voel je dan vrij om dit te doen in de commentaarsectie hieronder.
