Ora, il modo migliore per imparare è vedere effettivamente il codice in azione, quindi basta teoria, codifichiamo effettivamente la
nostra classe.
Ho intenzione di cancellare tutto e ricominciare da capo.
E diciamo che stiamo lavorando per un'azienda di giochi e questa azienda di giochi ha tutto questo gioco di
maghi che vogliono creare, quasi come Harry Potter.
Ora, come possiamo pensare a questo e alla programmazione orientata agli oggetti?
Bene, la prima cosa di cui avremo bisogno è che i giocatori scrivono.
Ogni giocatore ha un personaggio che deve interpretare.
Quindi creiamo una classe qui e chiamiamola giocatore.
Di nuovo, nota la convenzione di denominazione perché è una classe.
E.
Un'altra regola è che di solito volevi essere singolare, non plurale, quindi non puoi dire personaggi
giocanti perché voglio dire, è un progetto di questo progetto.
Creeremo molti personaggi, ma quelli saranno oggetti.
Quindi personaggio del giocatore, singolo al singolare.
Ora, qui dentro, farò alcune cose e vi avverto, all'inizio sembrerà confuso.
Ma abbi pazienza con me.
lo spiegherò.
Definiremo un underscore, underscore in esso, underscore, underscore.
Ora qui diremo self.
E poi dargli un nome, il nome del personaggio da qui, faremo Callon ancora una volta.
E dì semplicemente il nome di Self Doc.
Uguale al nome.
Oh, ragazzo, cosa è appena successo qui?
Ancora una volta, eviterò di spiegare cosa fa e scriverò solo qualche altra riga di codice in modo che abbia un
po' più di senso.
Scriverò un altro metodo qui e definirò, diciamo, un metodo di esecuzione che ogni
giocatore può eseguire qui.
Avrò ancora una volta questa strana autoparola e poi semplicemente qui dentro, diciamo stampa.
Ron.
Va bene, ho appena creato questa classe, è ancora un po' confusa, non sappiamo davvero cosa ci
sia dentro, cosa sia il sé e questo aspetto completamente nuovo.
Ma ignoriamolo per un secondo e diciamo semplicemente.
Giocatore.
Uno eguaglierà il personaggio del giocatore e istanzia quel giocatore.
In modo che possiamo stampare il lettore e vedere cosa succede con questo lettore.
Se clicco, corro.
Va bene, ricevo un errore, è un errore di battitura, dice INET mancante di un nome di argomento posizionale richiesto.
Va bene, facciamo una pausa qui e vediamo cosa sta succedendo qui.
Vedi questo inet.
Il metodo è un metodo speciale.
Vedete le due sottolineature qui.
Questo è chiamato metodo Dundar o metodo magico, e avremo un video specifico su questo.
Ma quando creiamo una classe, di solito lo vedi in alto.
E questo è ciò che viene spesso chiamato metodo costruttore o metodo init.
E questo è automaticamente freddo ogni volta che istanziamo.
Ricorda, istanziare significa che chiamiamo la classe per creare un oggetto.
Quindi, quando lo faccio, eseguirà automaticamente tutto ciò che è in questo blocco di codice.
Quindi, quando eseguo questo, vedi che sto mandando in onda online le 9:00 proprio qui sulla riga nove e quando
ho provato a istanziare il personaggio del giocatore.
Viene eseguito in esso e quindi prova a fare in modo che il nome da autodidatta sia uguale a nome, ma il
problema è che non lo sto dando a un nome di argomento, ed è perché quando lo chiamiamo, accettiamo tutto ciò che è
dopo self come parametro.
Significa quindi che dobbiamo dargli un nome di questo personaggio, quindi diciamo che il nome è Cindy, se clicco corri qui.
Tutto bene.
Sembra che io abbia un personaggio giocabile e, in effetti, mi mostra persino che è un oggetto
in questa posizione di memoria.
Quindi, sui nostri computer, è qui che si trova il giocatore, il personaggio, il giocatore uno.
Ora, molto bello, ma cos'è questa parola chiave personale e a cosa serve questo codice online?
Questo è un modo per noi di definire ciò che il sé si riferisce al personaggio del giocatore, sta dicendo, ehi, questo si riferirà a
questo personaggio del giocatore che creeremo.
Giocatore uno, e voglio che il nome dell'autoinganno sia uguale a qualunque sia il nome del parametro.
Quindi se suono il nome di sua figlia qui e clicco su corri.
Ho Cindy e perché è Cindy?
Bene, perché le ho dato il personaggio del giocatore perimetrale e quando l'ho istanziato, ho passato il parametro
name.
Il parametro predefinito è self quando lo faccio.
E nelle classi vedi qui che il valore predefinito, sempre il primo parametro quando definiamo un metodo
è self.
E ora do il mio nome all'autodidatta, ehi, e se tolgo questo qui e clicco su Esegui?
Vedi che dice che Object non ha un nome di attributo.
Perché per poter dire, ehi, voglio che il giocatore abbia un nome, devo dire da autodidatta perché autodidatta
si riferisce al giocatore uno.
Quindi, se ricordi quando avevamo una lista, dovevamo fare DOT e poi dicevamo, aggiungi ciò che qualcuno ha scritto
questo codice di aggiunta.
E nel codice append dirà self dot.
Diciamo che aggiungi alla lista e self si riferisce a qualunque cosa a sinistra del punto.
Quindi in questo modo ci permette di avere un riferimento a qualcosa che non è stato ancora creato in questo caso.
GIOCATORE uno E fagli sapere che, ehi, quando viene creato, quando istanziamo, quindi voglio che tu
ti assicuri che il giocatore uno abbia questo attributo del nome in modo che se creo un altro giocatore e un
altro giocatore, Tom sarà il giocatore.
Se stampo player per don name e clicco su Esegui.
Ho due giocatori diversi con due nomi diversi.
Sono stato in grado di utilizzare lo stesso pezzo di codice ma con valori diversi perché il sé, ogni volta che lo istanziamo,
si riferisce al primo giocatore una volta, quindi al primo giocatore della seconda volta a ora sé come una di quelle cose.
Questo diventa davvero, davvero difficile da capire.
E potresti dover guardare questo video un paio di volte.
Ma la chiave qui dovrebbe essere evidente per te.
Cioè, sono in grado di scrivere codice solo una volta.
Ricorda la nostra attrazione principale.
Non mi ripeto e sono in grado di renderlo dinamico dicendo che questi dati che creeremo per
l'oggetto saranno dinamici e cambieranno in base a ciò che gli diamo.
In modo che io possa creare giocatori diversi con attributi diversi.
Ma usa ancora lo stesso codice.
Ora, posso avere più cose qui, posso avere H, per esempio, e ancora una
volta, posso dire che l'età da autodidatta è uguale all'età e poi Cindy dovrà passare, diciamo 44 e Thomas, 21.
Così che qui ancora una volta, se faccio H.
Avranno attributi diversi.
Quindi ricorda, questi sono attributi o proprietà che hanno questi oggetti e puoi accedervi eseguendo la notazione
del punto e quindi accedendo alla proprietà stessa.
Vedi che non ho parentesi qui perché non è un metodo.
Non è agire.
Sta semplicemente dicendo, ehi, voglio accedere a questo attributo.
Se punto qui, il mio editore me lo dirà e avremo il simbolo per, ehi, hai accesso
all'attributo, età e nome.
E in effetti, ho anche accesso per eseguire il metodo in modo che se clicco, esegui.
Bene, ricorda, una corsa è un metodo, quindi ottengo questo metodo associato, ma non stampa nulla, non
esegue l'azione.
Quindi dobbiamo aggiungere ancora una volta le parentesi, colpire, correre.
E guarda questo, sono in grado di correre, poi non ne ottengo nessuno, poi ventuno, perché otteniamo questo?
Non perché ricordi che questa è una funzione che non restituisce nulla quando una funzione non restituisce
nulla.
Cosa otteniamo?
Non otteniamo.
Quindi forse posso solo dire ritorno fatto se clicco, corri.
Ecco qua.
Abbiamo eseguito Don uno.
Ora, un'ultima cosa prima di terminare questo video, la cosa interessante qui è se faccio il giocatore uno e poi il giocatore
due e stampo questo e faccio clic su Esegui.
Vedrai che ottengo il personaggio del giocatore.
Ma l'oggetto, ciascuno di questi oggetti, il giocatore uno e il giocatore due sono in una posizione di memoria diversa.
Quindi sono in grado di usare un pezzo di codice, un progetto per creare più giocatori, ma questi giocatori non sono
gli stessi.
Sono creati dallo stesso progetto, ma vivono in luoghi diversi della memoria.
E questo ha senso, no?
Non vogliamo che Tom e Cindy siano lo stesso giocatore.
Sono due giocatori diversi.
Quindi in questo modo possiamo tenere le cose al sicuro.
E tutto ciò che aggiungo al giocatore due, ad esempio, diciamo che il giocatore due ora può attaccare.
E l'attacco sarà solo una proprietà che ora sarà 50 se non attacco qui, vedi anche quel giocatore lo
ha.
Attacca, ma se gioco un attacco Wyandotte.
ne prendo un altro.
L'oggetto non ha attacchi di attributi.
Spero che tu stia iniziando a vedere il potere delle classi, anche se all'inizio potrebbe essere
difficile da capire, il potere diventa evidente quando siamo in grado di creare questo progetto che ora possiamo usare
più e più volte per creare i nostri oggetti .
Esploriamo di più nel prossimo video.