De beste manier om te leren is om code in actie te zien, dus genoeg theorie, laten we onze eigen
klas coderen.
Ik ga gewoon alles verwijderen en opnieuw beginnen.
En laten we zeggen dat we voor een gamingbedrijf werken en dit gamingbedrijf heeft al deze tovenaarsgames
die ze willen maken, bijna zoals Harry Potter.
Hoe kunnen we erover nadenken en objectgeoriënteerd programmeren?
Het eerste dat we nodig hebben, is dat we spelers moeten laten schrijven.
Elke speler heeft een personage dat ze moeten spelen.
Dus laten we hier een klasse maken en deze speler noemen.
Nogmaals, let op de naamgevingsconventie omdat het een klasse is.
En.
Een andere regel is dat je meestal enkelvoud wilt zijn, niet meervoud, dus je kunt geen spelerspersonages zeggen,
want ik bedoel, het is een blauwdruk van deze blauwdruk.
We gaan veel karakters maken, maar dat worden objecten.
Dus spelerkarakter, single in het enkelvoud.
Nu, hierbinnen, ga ik een paar dingen doen en ik ga je waarschuwen, dit zal er eerst verwarrend
uitzien.
Maar heb geduld met mij.
Ik zal het uitleggen.
We gaan een onderstrepingsteken definiëren, onderstrepingsteken erin, onderstrepingsteken, onderstrepingsteken.
Nu gaan we hier zelf zeggen.
En geef het dan een naam, de naam van het personage van hier, we gaan Callon nog een keer doen.
En zeg gewoon de naam van Self Doc.
Gelijk aan naam.
Oh, jongen, wat is hier net gebeurd?
Nogmaals, ik zal wachten met uitleggen wat dit doet en gewoon nog een paar regels code schrijven zodat het een
beetje logischer wordt.
Ik ga hier een andere methode schrijven en ik ga, laten we zeggen, een run-methode definiëren die
elke speler hier kan invoeren.
Ik krijg weer een raar zelfwoord en dan gewoon hier binnen, zeg maar print.
Ron.
Oké, dus ik heb net deze klas gemaakt, het is nog steeds een beetje verwarrend, we weten niet echt
wat dit erin is, wat het zelf is en deze hele nieuwe look.
Maar laten we dat even negeren en gewoon zeggen.
Speler.
Men gaat het karakter van de speler gelijk maken en die speler instantiëren.
Zodat we de speler kunnen printen en zien wat er met deze speler aan de hand is.
Als ik klik, ren dan weg.
Oké, ik krijg een foutmelding, het is een typfout, zegt dat INET één vereiste positionele argumentnaam mist.
Oké, laten we hier een pauze nemen en kijken wat hier gebeurt.
Je ziet dit inet.
Methode is een speciale methode.
Je ziet de twee onderstrepingen hier.
Dit wordt een Dundar-methode of een magische methode genoemd, en we gaan hier specifiek een video over maken.
Maar als we een klas bouwen, zie je dit meestal bovenaan.
En dit is wat vaak een constructormethode of een init-methode wordt genoemd.
En dit is automatisch koud elke keer dat we instantiëren.
Onthoud dat instantiëren betekent dat we de klasse aanroepen om een object te maken.
Dus als ik dit doe, wordt alles wat in dit codeblok staat automatisch uitgevoerd.
Dus als ik dit uitvoer, zie je dat ik de lucht hier om 9:00 uur online krijg op regel negen en toen
ik probeerde het personage van de speler te instantiëren.
Het loopt erin en dan probeert het autodidactische naam gelijk te stellen aan naam, maar het probleem is dat
ik het niet aan een argumentnaam geef, en dat is omdat wanneer we het inroepen, we accepteren wat er na zelf
is als de parameter.
We moeten het dus een naam geven van dit personage, dus laten we zeggen dat de naam Cindy is, als ik klik hier op uitvoeren.
Oke.
Het lijkt erop dat ik een spelerspersonage heb, en het laat me zelfs zien dat het een
object is op deze geheugenlocatie.
Dus op onze computers is dit waar de speler, personage, speler één zich bevindt.
Nu, heel cool, maar wat is dit zelf-trefwoord en waar is deze code online voor?
Dit is een manier voor ons om te definiëren wat self self verwijst naar het personage van de speler, het zegt, hey, dit gaat verwijzen
naar dit spelerspersonage dat we gaan maken.
Speler één, en ik wil dat de naam van zelfbedrog gelijk is aan wat de parameternaam ook is.
Zodat als ik de naam van haar dochter hier speel en ik op rennen klik.
Ik krijg Cindy en waarom is Cindy?
Nou, omdat ik haar het karakter van de perimeterspeler gaf en toen ik het maakte, gaf ik de parameter
name door.
De standaardparameter is zelf wanneer ik het erin doe.
En in klassen zie je hier dat de standaard, altijd de eerste parameter wanneer we een methode definiëren,
self is.
En nu geef ik mijn naam aan autodidact, hé, wat als ik dit hier verwijder en ik klik op uitvoeren?
U ziet dat er staat dat Object geen attribuutnaam heeft.
Want om te kunnen zeggen, hé, ik wil dat de speler een naam heeft, moet ik autodidact zeggen, want
zelf verwijst naar speler één.
Dus als je je herinnert dat toen we een lijst hadden, we DOT moesten doen en dan zouden we zeggen, voeg toe wat
iemand deze toevoegcode heeft geschreven.
En in de append-code gaat het zelf-punt zeggen.
Laten we zeggen toevoegen aan de lijst en zelf verwijst naar alles links van de punt.
Dus op deze manier kunnen we een verwijzing hebben naar iets dat in dit geval nog niet is gemaakt.
SPELER één En laat ze dat weten, hé, wanneer het is gemaakt, wanneer we instantiëren, dan
wil ik dat je ervoor zorgt dat Speler één dit naamattribuut heeft, zodat als ik een andere speler en speler
aanmaak, Tom de speler van wordt.
Als ik de speler afdruk om de naam op te geven en ik klik op uitvoeren.
Ik heb twee verschillende spelers met twee verschillende namen.
Ik was in staat om hetzelfde stuk code te gebruiken, maar had verschillende waarden omdat het zelf, elke keer dat ik dit start,
verwijst naar de eerste keer speler één, dan de eerste tweede keer speler naar nu zelf als een van die dingen.
Dat wordt echt, heel lastig om te begrijpen.
En misschien moet je deze video een paar keer bekijken.
Maar de sleutel hier zou voor u duidelijk moeten zijn.
Dat wil zeggen dat ik maar één keer code kan schrijven.
Denk aan onze hoofdtrekking.
Ik herhaal jezelf niet en ik ben in staat om het dynamisch te maken door te zeggen dat deze gegevens die we gaan creëren voor
het object dynamisch zullen zijn en dat het zal veranderen op basis van wat we het geven.
Zodat ik verschillende spelers met verschillende attributen kan maken.
Maar gebruik nog steeds dezelfde code.
Ik kan hier meerdere dingen hebben, ik kan bijvoorbeeld H hebben, en nogmaals, ik
kan zeggen dat autodidactische leeftijd gelijk is aan leeftijd en dan zal Cindy moeten slagen, laten we zeggen 44 en Thomas, 21.
Zodat hier nogmaals, als ik H.
Ze zullen verschillende attributen hebben.
Dus onthoud dat dit attributen of eigenschappen zijn die deze objecten hebben en je kunt ze openen door de puntnotatie uit te
voeren en vervolgens toegang te krijgen tot de eigenschap zelf.
Je ziet dat ik hier geen haakjes heb omdat het geen methode is.
Het onderneemt geen actie.
Het zegt gewoon: hey, ik wil toegang tot dit attribuut.
Als ik hier een stip zet, zal mijn redacteur het me echt vertellen en hebben we het symbool voor, hey, je hebt toegang tot
het attribuut, de leeftijd en de naam.
En trouwens, ik heb ook toegang om de methode uit te voeren, zodat als ik klik, uitvoeren.
Onthoud dat een run een methode is, dus ik krijg deze gebonden methode, maar hij drukt niets af, hij
onderneemt geen actie.
Dus we moeten de haakjes opnieuw toevoegen, hit, run.
En kijk, ik kan rennen, dan krijg ik er geen, dan eenentwintig, waarom krijgen we dit?
Niet omdat onthoud dat dit een functie is die niets teruggeeft als een functie niets
teruggeeft.
Wat krijgen we?
Wij krijgen niet.
Dus misschien kan ik gewoon zeggen: return done als ik klik, ren.
Daar ga je.
We hebben Don één uitgevoerd.
Nu, een laatste ding voordat ik deze video beëindig, het interessante hier is als ik speler één doe en dan speler twee
en ik print dit en ik klik op uitvoeren.
Je zult zien dat ik het personage van de speler krijg.
Maar het object, elk van deze objecten, speler één en speler twee zijn een verschillende geheugenlocatie.
Dus ik kan één stukje code, één blauwdruk gebruiken om meerdere spelers te maken, maar deze spelers zijn
niet hetzelfde.
Ze zijn gemaakt op basis van dezelfde blauwdruk, maar ze leven op verschillende plaatsen in het geheugen.
En dat is logisch, toch?
We willen niet dat Tom en Cindy dezelfde speler zijn.
Het zijn twee verschillende spelers.
Op deze manier kunnen we de boel veilig houden.
En alles wat ik bijvoorbeeld aan speler twee toevoeg, laten we zeggen dat speler twee nu kan aanvallen.
En aanval zal gewoon een eigenschap zijn die nu 50 zal zijn als ik hier niet aanval, zie je, die speler heeft dat
ook.
Aanval, maar als ik een Wyandotte-aanval speel.
Ik krijg een andere.
Object heeft geen attribuutaanval.
Ik hoop dat je de kracht van klassen begint te zien, hoewel het in het begin
misschien moeilijk te begrijpen is, wordt de kracht duidelijk wanneer we deze blauwdruk kunnen maken die we nu steeds
opnieuw kunnen gebruiken om onze eigen objecten te maken .
Laten we meer ontdekken in de volgende video.