Differenza tra interfaccia e classe astratta in Java & C #

2019

Interfaccia e classe astratta contribuiscono entrambi al "tipo incompleto" in OOP. A volte abbiamo bisogno di una superclasse per definire "cosa fare" ma, non "come fare", è come fare la parte verrà implementata dalla classe derivata in base alle sue necessità, " interfaccia " fornire una soluzione a questo. A volte abbiamo bisogno di una classe superclasse che definisce una struttura generalizzata che può essere implementata da classi derivate e una struttura specifica che può essere utilizzata dalle classi derivate, " abstract class " fornisce una soluzione a questo. La differenza fondamentale tra l'interfaccia e la classe astratta è che l'interfaccia è completamente incompleta e la classe astratta è parzialmente incompleta.

Grafico comparativo

Base per il confronto	Interfaccia	Classe astratta
Di base	Quando hai solo la conoscenza dei requisiti e non della sua implementazione, usi "Interfaccia".	Quando conosci parzialmente le implementazioni, usi "Classi astratte".
metodi	L'interfaccia contiene solo metodi astratti.	La classe astratta contiene metodi astratti e metodi concreti.
Modificatore di accesso dei metodi	I metodi di interfaccia sono sempre "Pubblico" e "Astratto", anche se non lo dichiariamo. Quindi, si può dire come 100%, pura classe astratta.	Non è obbligatorio che il metodo in classe astratta sia pubblico e astratto. Può avere anche metodi concreti.
Modificatore limitato per i metodi	Un metodo di interfaccia non può essere dichiarato con i seguenti modificatori: Pubblico: privato e protetto Abstract: finale, statico, sincronizzato, nativo, strictfp.	Non ci sono restrizioni sui modificatori della variabile di classe astratta.
Modificatore di accesso delle variabili	Il modificatore di accesso consentito per le variabili di interfaccia è pubblico, statico e finale, indipendentemente dal fatto che lo dichiariamo o meno.	Le variabili in classe astratta non devono essere pubbliche, statiche, definitive.
Modificatori limitati per variabili	Le variabili di interfaccia non possono essere dichiarate come private, protette, transitorie, volatili.	Non ci sono restrizioni sui modificatori di variabili di classe astratte.
Inizializzazione di variabili	Le variabili di interfaccia devono essere inizializzate al momento della sua dichiarazione.	Non è obbligatorio che le variabili di classe astratte debbano essere inizializzate al momento della sua dichiarazione.
Istanza e blocchi statici	Interfaccia interna, non è possibile dichiarare un'istanza o un blocco statico.	La classe astratta consente al suo interno un'istanza o un blocco statico.
Costruttori	Non è possibile dichiarare il costruttore all'interno dell'interfaccia.	È possibile dichiarare il costruttore all'interno di una classe astratta.

Definizione di interfaccia

Java non consente l'ereditarietà multipla. Cioè, una singola classe non può ereditare più di una classe alla volta. La ragione di ciò può essere spiegata con un esempio. Supponiamo di avere due classi genitore, A e B e una classe derivata C. La classe derivata C eredita entrambe le classi A e B. Ora, entrambe hanno la classe A e B hanno il metodo set (), allora sarà una domanda per la classe C quello che il metodo set () della classe dovrebbe ereditare. La soluzione a questo problema è "interfaccia".

Interface è una pura classe astratta. La parola chiave utilizzata per creare un'interfaccia è "interfaccia". Poiché tutto il metodo all'interno dell'interfaccia è completamente astratto. L'interfaccia specifica solo ciò che una classe deve fare, ma non definisce come lo fa. Solo perché tutti i metodi dichiarati all'interno dell'interfaccia sono astratti, non viene creata alcuna istanza per un'interfaccia. La forma generale di "interfaccia" in java è:

 access_specifier interface interface_name {return-type nome-metodo1 (elenco parametri); tipo-metodo-tipo-ritorno2 (elenco-parametri); type final-varname1 = value; type final-varname2 = value; // ... return-type method-nameN (parameter-list); type final-varnameN = value; }

Lo specificatore di accesso è dichiarato pubblico perché le classi devono implementare l'interfaccia.

Non abbiamo il concetto di "Interface" in C ++. Ma, Java e C # definiscono l'interfaccia molto bene.

Interfaccia in Java:

Le variabili di un'interfaccia sono di default sempre pubbliche, statiche e finali.
Le variabili devono essere inizializzate al momento della sua dichiarazione.
Le variabili non possono mai essere dichiarate come private, protette, transitorie e volatili.
I metodi di un'interfaccia sono sempre pubblici e astratti mentre, non possono mai essere dichiarati come privati, protetti, definitivi, statici, sincronizzati, nativi e strictfp.
Non è possibile dichiarare alcun costruttore all'interno dell'interfaccia poiché lo scopo principale del costruttore è l'inizializzazione delle variabili di classe ma, nelle variabili di interfaccia, vengono inizializzate al momento della sua dichiarazione.
L'interfaccia può ereditare altre interfacce ma, la classe che implementa tale interfaccia deve implementare i metodi di tutte le interfacce ereditate.
Una classe può ereditare più di un'interfaccia alla volta e deve implementare tutti i metodi di tutte le interfacce ereditate.

La forma generale di implementazione di un'interfaccia in Java:

 class class_name implements Interface_name {// class-body}

Per ereditare un'interfaccia, una classe utilizza una parola chiave "implementa" e la classe implementa tutto il metodo dichiarato da un'interfaccia ereditata.

Interfaccia in C #:

L'interfaccia in C # è quasi simile all'interfaccia in Java tranne:

L'interfaccia in C # non dichiara variabili.
Il nome dell'interfaccia è preceduto da una I maiuscola ed è ereditato da due punti (:).

La forma generale di implementare un'interfaccia in C #:

 class class_name: interface_name {// class-body}

Definizione di Classe astratta

Una classe che contiene uno o più metodi astratti è chiamata classe astratta e una classe è dichiarata come astratta usando la parola chiave "abstract", preceduta dalla parola chiave "class" all'inizio della dichiarazione della classe. Poiché la classe astratta contiene il metodo astratto costituisce un tipo incompleto. Quindi, non è possibile creare oggetti di una classe astratta. Ogni volta che una classe eredita una classe astratta, deve implementare tutti i metodi astratti della classe astratta se non lo fa, ma deve anche essere dichiarata come astratta. L'attributo astratto viene ereditato fino a quando non viene raggiunta l'implementazione completa dei metodi astratti.

La classe astratta può anche contenere metodi concreti che possono essere utilizzati dalla classe derivata così com'è. Ma non è possibile dichiarare un costruttore astratto o un metodo statico astratto all'interno di una classe astratta. La forma generale della classe astratta in Java è la seguente:

 abstract class class_name {abstract method_name1 (); abstract method_name2 (); : return_type method_name3 (parameter_list) {// metodo concreto} return_type method_name4 (parameter_list) {// metodo concreto}};

Il concetto di una classe astratta è simile sia in Java che in C #. Una classe astratta è leggermente diversa in C ++.

In C ++ se almeno una classe ha una funzione virtuale, la classe diventa una classe astratta. Invece della parola chiave "abstract", la parola chiave "virtuale" viene utilizzata per dichiarare un metodo astratto.

Differenze chiave tra interfaccia e classe astratta in Java & C #

Quando si ha la conoscenza di "cosa è richiesto" ma non di "come sarebbe implementato", è necessario utilizzare l'interfaccia. D'altra parte, se sai cosa è necessario e in parte sai come sarebbe implementato, usa una classe astratta.
Un'interfaccia ha tutti i suoi metodi astratti ma, una classe astratta ha alcuni metodi astratti e alcuni metodi concreti.
I metodi all'interno di un'interfaccia sono pubblici e astratti quindi, è anche chiamato come una pura classe astratta. D'altra parte, i metodi all'interno di un abstract non sono limitati a essere solo pubblici e astratti.
Un metodo di interfaccia non può mai essere privato, protetto, finale, statico, sincronizzato, nativo o strictfp. D'altra parte, non ci sono restrizioni ai metodi di una classe astratta.
Le variabili in un'interfaccia sono pubbliche e definitive, sia che le dichiariamo o no, mentre non esiste una tale restrizione alle variabili di una classe astratta che sia solo pubblica e finale.
Le variabili in un'interfaccia non possono mai essere private transitori o volatili mentre, in una classe astratta, non vi è alcuna restrizione alle variabili.
La variabile di un'interfaccia deve essere inizializzata durante la dichiarazione. D'altra parte, le variabili in una classe astratta possono essere inizializzate in qualsiasi momento.
All'interno di un'interfaccia, un'istanza o un blocco statico non possono essere dichiarati ma, è possibile dichiarare un'istanza o un blocco statico all'interno di una classe astratta.
Non è possibile definire il costruttore all'interno di un'interfaccia mentre, è possibile definire il costruttore all'interno di una classe astratta.

Conclusione:

Quando è necessario creare una classe base che contiene una forma generalizzata di metodi che possono essere implementati dalle classi derivate in base alle loro necessità, il concetto di interfaccia e classe astratta aiuta a farlo.