Quindi abbiamo parlato dell'incapsulamento, dell'astrazione, e del terzo pilastro della speranza, si chiama ereditarietà
e l'ereditarietà consente a nuovi oggetti di assumere le proprietà di oggetti esistenti in modo da poter
ereditare le classi.
Diamo un'occhiata a un esempio.
Rimuoviamo il codice precedente che abbiamo avuto e torniamo al nostro esempio di gioco.
Vogliamo creare un nuovo gioco e abbiamo diversi tipi di utenti, quindi abbiamo utenti che possono essere maghi, che
possono essere elfi, che possono essere, non so, arcieri.
Ma tutti questi utenti hanno alcune funzionalità comuni.
E ognuno dei sub-utenti, come maghi, elfi, arcieri, ha alcune funzionalità condivise in comune, ma poi di
nuovo, forse diversi attacchi.
Quindi, usando OLP, possiamo effettivamente eseguire l'ereditarietà.
Ad esempio, supponiamo di avere un utente di classe qui e questo utente avrà, diciamo, una funzione di firma.
O il metodo Sinon, ancora una volta, riceverà il sé e quindi per ora supporremo di avere una
sorta di segno qui.
Quindi diciamo solo per ora, stampa l'accesso, perché per poter giocare, devono essere registrati.
OK, ora ti starai chiedendo, oh, dov'è il metodo init qui?
Non dovremmo avere quel metodo init che viene eseguito per primo?
Bene, potremmo, ma se non abbiamo nessuna variabile o attributo che vogliamo assegnare all'utente, beh, in quel caso avremmo
un bisogno e un metodo.
Quindi, per ora, diremo solo che non è necessario che l'utente non disponga di nient'altro che questo metodo
di accesso.
Ora, supponiamo di voler creare un gruppo di sottoclassi in modo da avere una procedura guidata di classe.
E per ora, faremo solo un passaggio qui in modo da non avere una classe vuota, ma ci consentirà comunque di
costruirla.
E poi diciamo che abbiamo anche una classe.
Archer, passerà anche quello.
Mi assicurerò che qui ci siano le parentesi.
Ora, ecco la cosa.
Idealmente, anche tutti questi maghi e arcieri sono utenti, giusto?
Quindi abbiamo utenti.
E questi utenti possono avere più forme, possono essere maghi, possono essere arcieri.
Possono essere orchi, tutti i personaggi del nostro gioco.
Ma tutti, diciamo, devono prima aver effettuato l'accesso, come possiamo assicurarci che anche tutti questi utenti
o classi abbiano accesso per l'accesso?
Bene, possiamo usare l'ereditarietà e come eseguiamo l'ereditarietà abbastanza facilmente, in realtà, tutto ciò che facciamo è
passare tra parentesi la classe genitore da cui vogliamo ereditare.
Quindi diciamo che faccio yuzu qui.
Ora, facciamo clic su Esegui qui.
Nessun errore.
Tutto sembra a posto.
E a proposito, vedi la linea verde qui mi dice che il rientro non è un multiplo di quattro perché
il rientro dovrebbe essere quattro in Python.
Quindi possiamo semplicemente fare questo.
Ma mi piace tenerlo più piccolo così è più facile da leggere.
OK, quindi creiamo un'istanza di una classe qui, ne creerò una guidata e poi dirò.
Procedura guidata ed eseguire quella classe guidata.
Ora, se stampo qui e lo faccio, diciamo la procedura guidata di stampa.
Se clicco, corro.
Vedo che l'oggetto della procedura guidata è stato creato e cosa succede se non eseguo l'accesso?
Vedo che sì, è effettivamente lì se accedo e faccio clic su Esegui.
Ehi, ho effettuato l'accesso.
Quanto è bello aver ereditato dalla classe utente questa funzionalità.
E questo è davvero, davvero potente perché ora posso estendere il mio Wizzard, giusto,
quindi diciamo che questo mago ha un innato.
Metodo.
Che verrà eseguito quando viene creata la procedura guidata e avrà un file .
Nome.
E il potere che otteniamo.
E qui, assegneremo il nome di sé a uguale nome e poi il potere da autodidatta a uguale potere.
E aggiungiamo anche un altro metodo.
Chiamalo attacco.
E questo metodo di attacco stamperà semplicemente una stringa F.
Questo dirà.
Attaccare con.
Potere di.
Diciamo potere autodidatta.
E poi faremo lo stesso per l'Arciere, quindi copierò questo codice.
Incollato qui e l'Arciere avrà il nome.
E diciamo che invece del potere, diremo che ce l'ha, diciamo.
Numero di Harrow.
E numero di frecce.
Sarà il nuovo attributo che ottiene e quindi l'attacco avrà, beh, attaccando con le frecce.
E poi avremo frecce a sinistra.
Una freccia a sinistra dirà solo il numero di errori e possiamo fare qualcosa di divertente in cui le frecce diminuiscono ogni
volta che attacchi.
Ok, ora che abbiamo questo, rendiamolo un po' più piccolo, così puoi vedere.
Ecco qua.
Ora che abbiamo questo, istanziamo il primo Schwyzer.
Con.
Diciamo Maalin con la potenza di 50.
E poi l'arciere.
Saremo istanziati.
Come Robin con, diciamo, da cinquecento eroi o meno a cento ore.
Quindi ora il mago e l'arciere avranno.
Bene, avranno l'accesso.
Ma avranno anche l'attacco, ma unico per il loro individuo.
Classi.
E avranno anche proprietà diverse.
Diamo un'occhiata se dovessi fare Wizard Dot.
Sig. Procedura guidata.
Un punto.
E dirò.
Attacco.
E lasciami tornare indietro.
La mia intelligenza del codice.
Vedremo che abbiamo alcuni errori.
Ecco, qual è il cosa dice, nome indefinito sé, e questo perché ho dimenticato me stesso e le parentesi.
Quindi ricorda che dobbiamo sempre dare il primo parametro self.
Se scorriamo verso il basso e andiamo su Wizard Dot, vediamo che abbiamo nome, potere e attacco.
Se clicco attacca qui e corro.
Vediamo che sto attaccando con una potenza di 50 se eseguo un attacco con un punto con l'arciere.
In tal caso, attaccherò con le frecce, frecce a sinistra cento.
Ma entrambi hanno la funzione di accesso contemporaneamente.
Quanto è bello che questo sia il potere dell'ereditarietà.
Stiamo mantenendo il nostro codice asciutto, giusto, stiamo astraendo la parte del codice che entrambi condividono, ma poi cambiamo
le cose in base a ciò di cui ciascuno ha bisogno.
Quindi, ad esempio, potrei avere metodi e proprietà diversi su Wizzard rispetto a Archer, ma
anche avere una funzionalità utente condivisa che hanno e in questo modo mantenere il suo codice organizzato e pulito.
Ora, riportiamo lo zoom in modo che tu possa vederlo chiaramente.
Ora, questa idea di eredità è davvero, davvero potente.
E la chiave qui è che abbiamo una classe di accoppiamento e classi per bambini.
Ora, a volte queste classi figlie sono chiamate sottoclassi o classi derivate perché sono sottoclassi di
utente o derivate dalla classe utente.
Approfondiamo ancora un po' questo argomento nel prossimo video.