Bentornati.
Nel video precedente abbiamo imparato a conoscere il primo tipo di astrazione in Java, ovvero la classe
astratta.
In questo video, impareremo a conoscere il secondo tipo di astrazione, ovvero l'interfaccia.
Un'interfaccia è come un contratto o un insieme di regole che una classe può promettere di seguire.
Definisce un insieme di metodi, firme, metodi senza implementazioni che ogni classe che implementa l'interfaccia
deve fornire.
Un'interfaccia fornisce un modo per ottenere l'astrazione e definire un comportamento comune che più classi possono
condividere nella classe del veicolo.
Qui definiamo una classe astratta, metodi astratti e metodi non astratti.
Se osserviamo il metodo di arresto della macchina, possiamo ignorarlo.
Si può notare che l'auto non sta implementando il metodo top.
Ma pensate se è necessario implementare tutti questi metodi.
Due quattro e costringere le classi e tutti i figli del veicolo a implementare questi metodi, perché tutti
i veicoli dovrebbero partire, fermarsi e frenare in modo diverso.
Quindi creerò una nuova interfaccia e la chiamerò interfaccia veicolo.
Si può notare che si tratta di un'interfaccia pubblica per veicoli.
In questa interfaccia, è necessario definire la firma del metodo per effettuare operazioni come l'avvio del veicolo, l'arresto
e così via.
Quindi tutti i metodi che dovrei forzare, tutti i tipi di veicoli da implementare, dovrei definirli in questa
interfaccia.
Avviare il motore, ad esempio.
Il secondo metodo consiste nell'arrestare il motore.
Il terzo metodo è accelerare e il quarto è frenare.
Passiamo ora alla macchina.
Rimuoviamo l'extends vehicle per ora e rimuoviamo tutti questi metodi e questi errori e qui implementerò
l'alt vehicle più enter per implementare i metodi e possiamo vedere che abbiamo quattro metodi che dovremmo
implementare in questa classe auto.
Fare clic su OK.
Ed ecco i quattro metodi ereditati da questa interfaccia astratta.
Come si può vedere, implementando l'interfaccia del veicolo, la classe auto ha accettato di seguire le regole definite nell'interfaccia
del veicolo.
È quindi possibile definire, ad esempio, l'arresto del motore e l'accelerazione con il motore e il freno.
Implementerò lo stesso con il camion e si può vedere che posso implementare l'interfaccia dopo l'estensione della classe che
implementa l'interfaccia del veicolo alt più enter, implementare i metodi e possiamo vedere che ne
abbiamo tre perché il metodo brake è pronto.
E lasciatemi togliere il freno.
Si può notare che c'è un errore perché il veicolo contiene un vuoto astratto.
Per ora lo rimuovo e lo terrò nel freno per l'interfaccia del veicolo.
Allo stesso modo, qui nella classe camion, definirò questi messaggi, l'avvio del motore del camion, l'arresto del motore del
camion e l'accelerazione e l'azionamento del freno con il camion.
Passiamo ora alla classe Y.
E qui ho bisogno di definire un'auto, perché ora l'auto non si estende al veicolo.
V one dot start engine v two dot start engine o start perché è ereditato dal veicolo e devo cambiare
il veicolo in un camion per usare i metodi implementati dall'interfaccia.
Il veicolo non ha implementato l'interfaccia del veicolo, mentre il camion l'ha implementata, quindi devo usare
il camion invece del veicolo.
V due punti accelerano.
Lasciatemi correre e vedrete che l'avvio del motore con V uno, che è l'auto che il camion avvia e l'accelerazione
con il camion Le interfacce sono molto utili in Java perché consentono l'ereditarietà multipla, permettendo a una classe
di implementare più interfacce e di ereditare comportamenti da fonti diverse.
È molto importante notare che in Java esiste solo un mono extend dalle classi.
Quindi, per esempio, estende il veicolo qui e non posso creare, per esempio, che estende da una classe chiamata macchina
perché l'ereditarietà multipla usando extends non è consentita in Java.
Anche se è possibile creare un trucco per farlo in Java.
L'ereditarietà multipla crea un'interfaccia multipla, in modo da poter creare molti implementatori
di interfacce, ad esempio l'interfaccia macchina e altre interfacce.
In Java, quindi, l'ereditarietà multipla si ottiene utilizzando le interfacce.