Salve, questa è quasi la vittoria della lotteria nell'ultima lezione che abbiamo visto come le interfacce vengono tipicamente utilizzate.
Quindi capiamo praticamente quando usare le interfacce.
Ma la domanda è: perché sono state usate le interfacce e perché invece le classi astratte non vengono utilizzate.
Quindi seguiremo il consiglio di un articolo Java efficace che risponde a questa domanda.
Ecco l'articolo 18 di Effective Java che consiglia di preferire interfacce o
classi astratte.
Non guardare gli scenari quando dovremmo usare classi astratte.
Vediamo quando dovremmo preferire le interfacce.
Gli elementi che le interfacce sono ideali per la definizione di mix.
Vediamo perché è così.
Sappiamo che ha senso.
Le nostre funzionalità aggiuntive.
Cioè sono come componenti aggiuntivi che le classi potrebbero voler supportare.
Dal momento che le funzionalità di Vixen o aggiuntive che una classe potrebbe voler supportare più di esse Nolfi
usa una classe astratta per definire un mixin, quindi non può essere usata da tutte quelle classi che già estendono qualche altra
classe e che qualche altra classe potrebbe anche essere un servizio di mixaggio .
Le lezioni astratte hanno senso.
Una classe può supportare al massimo un solo mixin. Ma se si utilizza l'interfaccia, non avremmo tali limiti.
Tutto ciò che dobbiamo fare è aggiungere gli attrezzi alla relazione plastica e implementare il metodo
nella nuova interfaccia.
Quindi è facile modificare una classe esistente che sta già estendendo alcune altre classi non del tipo, come la
definizione rappresentata per il comportamento ma senza lo stato coinvolto.
Quindi, per l'interfaccia, ricordate che in questo caso le interfacce sono prive di stateless, ma assicuratevi che anche in futuro
non avreste bisogno di alcuno stato per far parte di questo supertipo.
Ovviamente puoi creare una classe astratta con solo metodi astratti.
Ma ancora una volta non può essere usato da classi che stanno già estendendo qualche altra classe in modo che non debba
andare per interfaccia.
Java non supporta l'ereditarietà multipla.
Quindi la domanda è quando dovremmo preferire le classi astratte.
Se il tipo sta definendo l'identità principale di un sottoprocesso, allora dovresti andare con una classe astratta o
persino avere una classe concreta, ma è un'identità fondamentale.
Sarebbe rappresentato al comportamento in questo stato.
Non puoi usare un'interfaccia qui come interfaccia che conosciamo come apolidi.
Sappiamo che la nostra classe di segnalibri è definita come una classe astratta in quanto rappresenta l'identità
principale delle sue sottoclassi.
Specificamente definisce lo stato usando le variabili protette come la descrizione del titolo dell'ID non
pur mentre ci si trova nell'articolo dice anche che le classi astratte possono essere utilizzate per fornire un'implementazione scheletrica
dell'interfaccia che implementerebbe l'interfaccia e fornirebbe una qualche forma di scheletro di base per
l'implementazione implementazioni.
L'assistenza all'implementazione pro-white per i programmatori che è programmatori può estendere un'implementazione scheletrica e utilizzare
alcune delle implementazioni che i programmatori non dovranno reinventare la logica, risparmiandole così un
po 'di tempo.
E anche eventuali potenziali bug che potrebbero introdurre.
Ovviamente i programmatori sono anche liberi di ignorare la disoccupazione di implementazione scheletrica
o l'interfaccia stessa è un esempio della libreria Java con una classe o una lista dal lavoro
se il pacchetto è implementato per le interfacce e sta estendendo anche la classe astratta che è uno scheletro
implementazione dell'interfaccia di lista.
Quindi è solo approfittando di alcune delle funzionalità fornite con l'API di luglio scorso che fornisce implementazioni di questo tipo
per diverse interfacce, specialmente se si guarda a ciò che si fa con il pacchetto, si troverà
qualcuno disposto a utilizzare le abilità di quel tipo.
Osservando questa gerarchia ci si potrebbe chiedere perché l'ostilità più illecita sia in grado di implementare in modo specifico un'interfaccia di
lista poiché la lista astratta lo sta già facendo.
Non è assolutamente necessario implementarlo esplicitamente in questo caso, ma suppongo che sia fatto
per motivi di chiarezza.
Hai appena dimostrato che la nostra lista è davvero una lista.
In questo modo non è necessario sfogliare l'albero di ereditarietà per conoscere questo fatto.
Per quanto riguarda la convenzione di denominazione, le implementazioni di Skilton iniziano con la parola
chiave abstract seguita dall'interfaccia come nel caso dell'elenco astratto.
Si potrebbe voler ricordare che nella demo over indifferences avevamo un'interfaccia chiamata V che aveva
una sottoclasse astratta chiamata abstract che è fondamentalmente un'implementazione skeleton e che forniva anche l'implementazione per uno
dei metodi astratti ereditati e c'era anche la classe concreta X che esteso questa
classe scheletrica astratta.
Quindi abbiamo già implementato un'implementazione di scheletro su classi astratte che sono ottimi candidati per
tali implementazioni.
Perché no Infine, gli elementi di cui abbiamo bisogno per utilizzare il nostro più cura durante la progettazione delle nostre interfacce.
Se il codice che scrivi è utilizzato solo all'interno della tua organizzazione, molto probabilmente stai bene.
Ma se stai progettando una API pubblica, dovresti fare un brainstorming sulle firme dei metodi.
Una volta che l'API è stata rilasciata e ampiamente utilizzata, sarebbe estremamente difficile apportare modifiche.
Cioè se si aggiungono nuovi metodi in una delle proprie interfacce in una versione successiva, qualsiasi
codice gentile che implementa questa interfaccia non verrà più compilato a meno che non implementi i nuovi metodi.
Ma se i client non ricompilano il codice allora stanno bene e funzionano ancora con il tuo nuovo codice assumendo
che tu abbia usato la stessa versione del compilatore come prima.
Questo è che non hai usato una versione diversa del compilatore per compilare il tuo nuovo codice.
Ma come i clienti cercano di ricompilare.
Quindi vedranno errori di compilazione.
Si può ricordare che questa illustrazione della lezione precedente che stiamo ascoltando in
questa API Gen-Y standard è implementata da altri dischi non di ascolto di popolarità modificati.
Quindi potrebbe rompere il codice in entrambe queste API.
E questo sarebbe un problema molto serio in questo contesto.
Datums dice che se il tuo tipo si evolverà nel tempo, dovresti andare per le classi astratte.
Questo perché con lezioni astratte.
Se aggiungiamo nuovi metodi concreti, vengono automaticamente ereditati dal sottoprocesso.
Tuttavia questa raccomandazione è valida solo fino al 7 luglio a partire dall'8 luglio in poi anche in deface
consente l'aggiunta di nuovi metodi concreti che vengono automaticamente ereditati.
Quindi la facilità di evoluzione non è un grosso problema dall'8 luglio in poi.
Tuttavia, l'aggiunta di metodi astratti sta cambiando. Le firme dei metodi astratti esistenti continuerebbero a infrangere
il codice di tutti gli implementatori.
Quindi, anche con Java 8 dovresti stare attento quando crei le tue interfacce, quindi è tutto qui.
Solo per riassumere
Utilizzare le interfacce se si desidera definire ha senso.
O se vuoi che un buon rappresentante definito faccia il comportamento di sottoclassi ma senza uno stato in-nato, la
ragione principale per questo è che Jawan non supporta l'ereditarietà multipla delle classi.
Se il Rappresentante fa il comportamento con lo stato è ciò che è necessario, allora dovrebbe essere usato il Russell astratto.
Anche le classi astratte sono grandi implementazioni del calcio Whiting.
Questo è tutto.
E grazie.