‫In questa lezione imparerai come creare e implementare le tue interfacce con un esempio concreto, e avrai
‫un'idea del perché le interfacce vengono utilizzate, specialmente quando le nostre classi non hanno una relazione tra loro
‫e quindi non lo fanno t condividere una classe base.
‫Quindi l'ereditarietà in quanto tale non è un'opzione.
‫Immagina di lavorare a un videogioco in cui il giocatore può distruggere cose, ma tutto ciò che distruggiamo
‫avrà un comportamento diverso a seconda di ciò che viene distrutto.
‫Ad esempio, distruggere una sedia emetterà un suono di distruzione e genererà parti di sedie distrutte.
‫Ma distruggere un'auto suonerà un suono di esplosione, creerà fuoco e distruggerà altri oggetti nelle vicinanze.
‫Per il nostro gioco, abbiamo le seguenti classi, una sedia che eredita dai mobili della classe e l'auto che
‫eredita dal veicolo della classe.
‫Quindi diamo un'occhiata a quelle classi molto velocemente.
‫Quindi abbiamo questa sedia che eredita dai mobili, e la sedia ha solo un semplice costruttore qui
‫dove impostiamo il colore e il materiale in base a ciò che viene dato all'oggetto che viene creato.
‫Ma ora, ovviamente, questa classe sta ereditando dai mobili, motivo per cui abbiamo quelle proprietà qui, colore
‫e materiale che abbiamo appena usato nella classe delle sedie.
‫E poi abbiamo il costruttore qui, che è il costruttore predefinito, dove quei valori verranno impostati per
‫impostazione predefinita.
‫Quindi il colore e il materiale saranno bianchi e lo sarebbero per impostazione predefinita.
‫E poi abbiamo anche un semplice costruttore che usa il colore e il materiale per impostarli di
‫default.
‫OK, quindi non c'è niente di eccezionale, ma ovviamente abbiamo anche un'auto e vogliamo essere in grado di distruggere la sedia
‫e l'auto, come ho affermato prima.
‫Quindi diamo un'occhiata alla macchina molto velocemente.
‫Quindi qui abbiamo la stessa storia, un'auto di sottoclasse che estende il veicolo in cui impostiamo la velocità dell'auto e il
‫colore.
‫Quindi ora stiamo usando, tra l'altro, un semplice costruttore come lo facciamo qui.
‫Ma ovviamente, avremmo potuto usare anche qui, passando la velocità e il colore.
‫OK, quindi anche questa è un'opzione valida e non dovremmo usarla qui.
‫Quindi ci sono due modi diversi, ovviamente, per farlo.
‫OK, e poi questa macchina sta ereditando dal veicolo dove ovviamente, velocità e colore devono essere definiti.
‫Quindi diamo un'occhiata alla classe del veicolo.
‫E qui possiamo vedere che questo veicolo di classe base ha una velocità, un colore, un costruttore predefinito, che imposta
‫quei due valori velocità con 120 chilometri all'ora e il colore con il bianco.
‫E poi abbiamo il semplice costruttore che imposterà la velocità e il colore in base
‫ai valori che vengono dati all'oggetto veicolo.
‫Inoltre, ovviamente, per l'oggetto ereditario, come un'auto, ad esempio.
‫OK, quindi ora che abbiamo tutte quelle classi diverse e abbiamo visto come sono strutturate, diamo
‫un'occhiata all'effettiva funzione di distruzione.
‫Quindi qual è l'approccio migliore per creare una tale funzione di distruzione?
‫Se ci pensiamo, non possiamo aggiungere una classe per fare in modo che le nostre classi ereditino da essa perché questo
‫è un linguaggio di ereditarietà singola e non un linguaggio di ereditarietà multipla che ereditiamo già da una classe.
‫Quindi l'auto eredita già dal veicolo e la sedia già eredita dai mobili.
‫Quindi non può ereditare da qualcos'altro.
‫Come, ad esempio, il veicolo qui che vedi C Sharp non lo consente perché non può avere più
‫classi base.
‫Una classe non può avere più classi base in Do diesis.
‫Quindi in più non c'è una relazione concreta tra un'auto e una sedia per condividere comunque una classe base,
‫perché sono completamente diverse da due cose, giusto?
‫Se implementiamo metodi normali chiamati metodo destroy, ad esempio, in ciascuna di quelle classi che
‫abbiamo qui, sarà difficile da mantenere.
‫E se decidessimo di cambiare completamente il sistema di distruzione o di aggiungere effetti visivi ai
‫nostri oggetti distruttibili in futuro, sarà una seccatura passare attraverso ogni classe e modificarla.
‫Perché in questo caso, abbiamo solo due sottoclassi, per così dire, giusto, ma immagina di avere 50
‫o anche 100 classi diverse, 100 diversi tipi di oggetti nel tuo gioco, quindi dovresti passare attraverso
‫ognuno di essi e regolare il codice di conseguenza.
‫Quindi questo è davvero un fardello e non vogliamo attraversarlo.
‫Ecco perché dobbiamo trovare una soluzione migliore.
‫Ciò di cui abbiamo bisogno è un modo per imporre il nostro comportamento distruttibile a ogni classe che lo utilizza, proprio come
‫un contratto.
‫E se hai visto il nostro video sulle interfacce, sai che sono contratti che possiamo creare.
‫Quindi l'approccio migliore in questo caso è usare un'interfaccia e la chiameremo distruggibile.
‫E qualsiasi classe che implementa questa interfaccia sarà costretta a seguire i nostri requisiti di distruzione
‫e personalizzarla allo stesso tempo, a seconda della classe stessa.
‫Quindi andiamo avanti e creiamo una tale interfaccia, quindi puoi andare qui al tuo progetto, aggiungere un nuovo
‫elemento e quindi selezionare l'interfaccia proprio qui e dargli un nome.
‫Quindi chiamerò questo I.
‫D stroy Elbo in modo che tu possa vedere quando usi le interfacce, aggiungi l'IA all'inizio del nome
‫del file per indicare che questa sarà un'interfaccia.
‫Quindi aggiungiamo questa interfaccia.
‫Quindi questa interfaccia avrà solo una proprietà per memorizzare il file audio che verrà eseguito una volta eseguita
‫la distruzione, che sarà il suono della distruzione, e quindi abbiamo solo un metodo che distruggerà un
‫oggetto e lo chiameremo metodo distruggere.
‫Non restituirà nulla.
‫Distruggerà solo qualcosa.
‫Quindi potrebbe, ad esempio, restituire la grafica che hai.
‫Quindi gli oggetti AI che vuoi visualizzare una volta che l'oggetto viene distrutto, ad esempio, l'auto viene distrutta o la
‫sedia viene distrutta e così via.
‫Quindi ora assicuriamoci che le nostre classi implementeranno effettivamente questa interfaccia e quindi, ovviamente, implementeranno il contenuto delle interfacce,
‫ovvero il suono di distruzione e il metodo di distruzione.
‫Come possiamo farlo?
‫Bene, andiamo alla nostra macchina, per esempio.
‫E qui la nostra macchina dovrà aggiungere una virgola qui in cima alla classe, la definizione in cima
‫e usare questa interfaccia distruttibile come.
‫Quindi ora se lo aggiungi, puoi vedere che ottieni un errore che dice che l'auto non implementa il suono
‫di distruzione dei membri dell'interfaccia oltre a distruggere.
‫Quindi possiamo mostrare potenziali correzioni e implementare tutti i membri.
‫Ad esempio, questo creerà questo codice automatico per noi.
‫Quindi creerà il vuoto distruttibile e creerà il suono della distruzione per noi.
‫Quindi quella sarebbe la versione generata automaticamente.
‫Ma possiamo anche farlo manualmente.
‫Non c'è problema con quello.
‫Quindi qui, ad esempio, possiamo implementare il suono della distruzione.
‫E poi quello che voglio essere in grado di fare è avere una proprietà per conservare gli oggetti distruttibili nelle
‫vicinanze.
‫Quindi, quando un'auto viene distrutta, dovrebbe distruggere anche l'oggetto vicino.
‫E anche questo elenco sarà di tipo I distruttibile, il che significa che può memorizzare qualsiasi oggetto che implementa questa
‫interfaccia e possiamo accedere solo a proprietà e metodi in quell'interfaccia.
‫Quindi, per crearlo, creerò un elenco pubblico di oggetti altamente distruttibili e
‫li chiamerò distruttibili nelle vicinanze.
‫Quindi ora possiamo andare avanti ed estendere il nostro costruttore, quindi da un lato vogliamo assicurarci di inizializzare
‫il suono in modo da assicurarci di avere un suono di esplosione.
‫Ad esempio, supponiamo di avere questo suono chiamato suono dell'esplosione dell'auto e tre, e quindi di
‫voler inizializzare l'elenco degli oggetti distruttibili.
‫Quindi questo sarà, ad esempio, solo un nuovo elenco di oggetti distruttibili.
‫E poi dobbiamo solo implementare anche il metodo destroy.
‫Quindi questo l'ho distrutto qui in alto, puoi vedere che non è ancora felice.
‫Si aspetta ancora che implementiamo il metodo destroy.
‫Quindi vedi, quando implementi un'interfaccia, devi implementare i suoi membri perché l'interfaccia
‫qui ha due membri.
‫Dobbiamo implementarli entrambi.
‫OK, questo significa che dobbiamo tornare qui e dobbiamo effettivamente implementare il metodo destroy.
‫Quindi facciamolo velocemente per farlo.
‫Quello che voglio aggiungere qui saranno, prima di tutto, due affermazioni.
‫Userò solo le istruzioni della riga giusta.
‫Lo farò sul semplice perché non stiamo creando un gioco qui, ma stiamo solo cercando di capire
‫i concetti di interfaccia.
‫Quindi, quando un'auto viene distrutta, dovremmo riprodurre il suono della distruzione e creare un effetto fuoco.
‫Quindi qui stiamo solo imitando come se riproducesse effettivamente il suono e dicesse solo, OK,
‫suonando l'esplosione dell'auto e tre suoni, e poi creiamo il fuoco.
‫Quindi tutto è sul fuoco.
‫Tutto brucia perché l'auto è distrutta.
‫Quindi ora esaminiamo ogni singolo distruttore nelle vicinanze e distruggiamolo effettivamente.
‫Quindi qui esamineremo ogni singolo oggetto distruttibile che si trova all'interno della nostra lista di muri distrutti
‫nelle vicinanze.
‫Lo chiamiamo distruttibile in modo che ogni singolo elemento sia un distruttobile, che in pratica è solo un
‫nome di variabile locale.
‫Quindi diciamo, OK, l'oggetto distruttibile che implementerà l'interfaccia distruttibile sarà semplicemente chiamato distruttobile nel nostro
‫ciclo for each.
‫Quindi iteriamo attraverso di esso, il che significa che iteriamo attraverso la raccolta distruttibile nelle
‫vicinanze, che è un elenco di oggetti distrutti dall'IA, fondamentalmente oggetti che lo implementano, interfaccia
‫distruttibile dall'IA e quindi chiamiamo semplicemente il metodo destroy.
‫Quindi fondamentalmente creiamo una reazione a catena qui, distruggendo tutto intorno a tutto ciò che è distrutto e anche quella
‫è un'auto e così via.
‫Quindi in questo caso, diciamo che abbiamo due macchine una accanto all'altra e hanno un mucchio di sedie una accanto
‫all'altra.
‫Quindi le auto chiameranno questo metodo di distruzione in cui distruggono gli oggetti nelle vicinanze perché, beh, è
‫un'enorme esplosione, giusto?
‫C'è un suono in arrivo e ogni elemento crea un suono.
‫Ora, puoi, ovviamente, creare un timer di cui ha bisogno fino a quando non si verifica l'effettiva esplosione dopo che
‫qualcosa ha preso fuoco.
‫Ma qui lo manterremo semplice.
‫OK, quindi stiamo distruggendo le altre auto, ma anche le altre esulta così ogni auto infetterà altri oggetti che la circondano
‫che si trovano nelle vicinanze.
‫E questo potrebbe essere, diciamo, tutto ciò che si trova a 10 metri di distanza o a cinque metri di distanza
‫o comunque a tanti centimetri se si vuole prendere il sistema americano qui.
‫Ma questo è fondamentalmente ciò che accadrà.
‫Ora, diamo un'occhiata alle sedie, perché le sedie dovranno seguire un approccio simile perché vogliamo anche
‫assicurarci che una sedia sia distruttibile, ma la distruzione di una sedia sarà molto
‫diversa.
‫OK, quindi qui aggiungeremo anche l'interfaccia.
‫Quindi l'interfaccia distruggibile dell'IA e, naturalmente, dobbiamo implementare il suono della distruzione e quella sarà
‫una distruzione molto diversa perché la sedia cadrà a pezzi e sarà il legno in frantumi
‫quello che senti.
‫Quindi sarà un suono molto diverso qui.
‫OK, e poi, naturalmente, vogliamo anche definire il suono di distruzione all'interno del nostro costruttore.
‫Quindi dirò che il suono della distruzione della sedia dovrebbe essere riprodotto.
‫Sarà sempre lo stesso.
‫Ecco perché non lo aggiungo qui nella dichiarazione del presidente.
‫Quindi sto mantenendo le cose semplici qui.
‫Certo, potresti avere sedie diverse che hanno suoni di esplosione diversi, quindi lo
‫aggiungeresti qui in alto come parametro per il tuo costruttore.
‫OK, quindi ora implementiamo effettivamente il metodo destroy.
‫E in questo caso, quello che accadrà è che distruggeremo qualcosa e, prima di tutto, distruggeremo la sedia colorata in base
‫al colore che ha la sedia, lo scriveremo.
‫Quindi suoneremo il suono della distruzione e infine genereremo parti di sedie.
‫OK, quindi nel nostro caso, lo stiamo solo scrivendo sulla console.
‫Ma immagina solo in un gioco reale come lo faresti, perché il modo migliore per distruggere qualcosa in un videogioco
‫non è fare effettivamente la cosa fisica in cui fai tutta la distruzione, che è
‫molto difficile da costruire come se fosse.
‫Non hai una grande squadra che fa tutti i tipi di cose, quindi faresti
‫semplicemente una grande esplosione o un'animazione di distruzione e poi genereresti le parti distrutte delle singole parti che giacciono intorno.
‫Quindi vedete qui non c'è alcuna reazione a catena proveniente da questo metodo di distruzione.
‫Quindi l'implementazione del metodo di distruzione per la sedia è molto diversa da quella
‫del veicolo, ma entrambi ereditano dall'interfaccia distruttibile dell'IA e devono implementare il metodo di distruzione e possono
‫farlo a modo loro.
‫Quindi fondamentalmente le interfacce ci consentono una sorta di multi ereditarietà, anche se non è realmente multi
‫ereditarietà.
‫OK, ora andiamo avanti e passiamo ai nostri programmi.
‫Sì.
‫E in realtà usa le nostre classi appena create perché.
‫Beh, altrimenti è noioso.
‫Destra.
‫Quindi andiamo avanti e creiamo due sedie.
‫Quindi abbiamo una sedia da ufficio che sarà marrone e plastica, e poi abbiamo una sedia da gioco che
‫sarà rossa e legno.
‫E poi creiamo anche una nuova macchina.
‫Quindi questa macchina avrà una velocità di 80 e sarà blu e sarà un'auto danneggiata.
‫E poi aggiungeremo le due sedie vicino a questa macchina danneggiata.
‫Quindi li aggiungiamo come distruttibili vicino alla nostra auto danneggiata.
‫Quindi la sedia da ufficio e la sedia da gioco saranno ora, se guardiamo qui come distruttibile è nelle vicinanze, perché
‫durante la creazione di un'auto, questo elenco sarà vuoto.
‫Ma poi possiamo, ovviamente, poiché è un elenco pubblico qui, possiamo aggiungere elementi ad esso, cosa che facciamo.
‫Aggiungiamo oggetti distruttibili ad esso.
‫E perché possiamo aggiungere sedie al nostro distruttore nelle vicinanze?
‫Bene, perché una sedia implementa questa interfaccia.
‫Il fatto che abbiamo chiamato I distruttibile significa che una sedia verrà ora accettata come oggetto di distruzione di tipo II, il
‫che significa che ora possiamo aggiungerla come nostro oggetto distruttibile nelle vicinanze.
‫Quindi ora possiamo andare avanti e distruggere l'auto.
‫Quindi chiamiamo semplicemente il metodo di distruzione per la nostra auto danneggiata in modo che l'esplosione possa prendere parte, il suono dell'esplosione
‫possa iniziare e tutte le cose buone.
‫Quindi eseguiamo questo.
‫E, naturalmente, questo sarà più un gioco di avventura e non tanto un gioco in cui si vede una vera grafica
‫3D o altro.
‫Quindi suoniamo il suono della distruzione, il suono dell'esplosione dell'auto.
‫Creiamo il fuoco.
‫La sedia marrone è stata distrutta.
‫Suoniamo il suono distruttivo della sedia, il suono distruttivo e il B3.
‫Quindi stiamo girando le parti della sedia per la nostra sedia marrone.
‫Poi la sedia rossa è stata distrutta.
‫Stiamo suonando il suono distruttivo della sedia, distruzione, suono e furia e poi le parti della sedia
‫per la nostra sedia rossa.
‫Quindi vedi, è praticamente tutto.
‫Ecco come puoi creare le tue interfacce e come usarle.
‫E spero che ora tu capisca cosa possono fare le interfacce per te e i vantaggi delle interfacce.
‫Quindi un nodo importante qui dalle interfacce viene utilizzato per la comunicazione tra due classi simili o non simili
‫a cui non interessa un tipo di classe che implementa l'interfaccia, proprio come la nostra macchina ha comunicato con la
‫sedia per chiamare il metodo destroy, tutto perché semplicemente implementato la stessa interfaccia che ho
‫affermato in precedenza.
‫Quindi, sebbene le interfacce possano sembrare difficili da capire, a prima vista ci forniscono grandi vantaggi.
‫Questi vantaggi sono chiamati leggibilità.
‫Quindi un'interfaccia costituisce una dichiarazione sulle intenzioni, quindi definisce la capacità della tua classe.
‫Quindi cosa è in grado di fare la tua classe?
‫Se implementi l'ordinabile I, ad esempio, stai chiaramente affermando che gli oggetti della tua classe possono
‫essere ordinati, quindi la semantica del codice.
‫Fornendo interfacce e implementandole, stai attivamente separando i concetti e l'interfaccia definisce un modello comportamentale, una
‫definizione di ciò che un oggetto può fare.
‫E separare questi concetti mantiene la semantica del tuo codice molto più chiara.
‫Allora hai il codice.
‫Le interfacce di manutenibilità aiutano a ridurre l'accoppiamento e consentono di scambiare facilmente le implementazioni per lo stesso
‫concetto senza che il codice sottostante venga interessato.
‫E poi abbiamo i modelli di design.
‫È il quadro più ampio dell'utilizzo di contratti, astrazioni e interfacce fondamentali per la programmazione orientata agli
‫oggetti.
‫Quindi comprensione umana e architettura di sistema complessa.
‫Quindi è davvero fondamentalmente solo per capirlo meglio come essere umano e quindi eredità multipla.
‫Quindi le interfacce possono essere il nostro gateway per utilizzare l'ereditarietà multipla in C diesis.
‫Quindi supponiamo di scrivere una libreria e di volerla modificabile dagli utenti.
‫Scrivi l'interfaccia e la sua implementazione della classe.
‫Altri sviluppatori che utilizzeranno la tua libreria possono comunque scrivere la propria classe di implementazione, che
‫potrebbe utilizzare tecnologie o algoritmi diversi che ottengono lo stesso risultato.
‫Questo è anche il motivo per cui incontriamo così tante interfacce nelle librerie.
‫Usiamo, ma raramente sentiamo il bisogno di scrivere le nostre interfacce perché non scriviamo noi stessi le librerie.
‫In una nota finale, l'importante è capire come vengono implementate le interfacce a questo punto.
‫Naturalmente, man mano che passeremo attraverso diverse tecnologie come WP e AP dot net e la
‫master class C, inizieremo a utilizzare di più le interfacce, che ti aiuteranno a capirle meglio in futuro.
‫Tutto bene.
‫Quindi grazie mille per aver guardato questo video.
‫Ci vediamo al prossimo.