Contenuto

• Tabella di comparazione
• Definizione di interfaccia
• Definizione di classe astratta
• Conclusione:

Le classi Interface e Abstract contribuiscono entrambe al "tipo incompleto" in OOP. A volte abbiamo bisogno di una superclasse per definire "cosa fare" ma, non "come fare", è come fare parte sarà implementata dalla classe derivata in base alle sue necessità, "interfaccia"Fornire una soluzione a questo. A volte abbiamo bisogno di una classe superclasse che definisca una struttura generalizzata che può essere implementata da classi derivate e una struttura specificata che può essere utilizzata dalle classi derivate, "classe astratta"Fornisce una soluzione a questo. La differenza fondamentale tra interfaccia e classe astratta è che l'interfaccia è completamente incompleta e la classe astratta è parzialmente incompleta.

1. Tabella di comparazione
2. Definizione
3. Differenze chiave
4. Conclusione

Tabella di comparazione

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 ai metodi	I metodi di interfaccia sono sempre "Pubblico" e "Astratto", anche se non lo dichiariamo. Quindi, si può dire al 100%, pura classe astratta.	Non è obbligatorio che il metodo in classe astratta sia pubblico e astratto. Può avere anche metodi concreti.
Modificatore limitato per metodi	Un metodo di interfaccia non può essere dichiarato con i seguenti modificatori: Pubblico: privato e protetto Riassunto: 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 nella classe astratta non devono necessariamente 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 inizializzare le variabili di classe astratte al momento della sua dichiarazione.
Istanza e blocchi statici	Nell'interfaccia interna non è possibile dichiarare un'istanza o un blocco statico.	La classe astratta consente un'istanza o un blocco statico al suo interno.
Costruttori	Non è possibile dichiarare il costruttore all'interno dell'interfaccia.	Puoi 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. Il motivo dietro questo può essere spiegato con un esempio. Supponiamo di avere due classi principali, A e B e una classe derivata C. La classe derivata C eredita sia le classi A che B.Ora, entrambi hanno la classe A e B hanno il metodo set (), quindi sarà una domanda per la classe C quella che il metodo set () della classe dovrebbe ereditare. La soluzione a questo problema è "interfaccia".

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

access_specifier interfaccia nome_interfaccia {tipo-metodo-ritorno1 (elenco parametri); tipo-metodo-nome-ritorno2 (elenco parametri); digitare final-varname1 = valore; digitare final-varname2 = value; // ... return-type method-nameN (elenco parametri); digitare final-varnameN = value; }

L'identificatore di accesso è dichiarato pubblico perché le classi devono implementare l'interfaccia.

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

Interfaccia in Java:

• Le variabili di un'interfaccia sono per impostazione predefinita 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, finali, 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 sono 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 implementa Interface_name {// class-body}

Per ereditare un'interfaccia, una classe usa 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 le variabili.
• Il nome dell'interfaccia è preceduto da una I maiuscola ed è ereditato da due punti (:).

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

class nome_classe: nome_interfaccia {// class-body}

Definizione di classe astratta

Una classe che contiene uno o più metodi astratti viene chiamata classe astratta e una classe viene dichiarata astratta utilizzando la parola chiave "abstract", preceduta dalla parola chiave "class" all'inizio della dichiarazione di classe. Poiché la classe astratta contiene il metodo astratto, costituisce un tipo incompleto. Pertanto, 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, altrimenti non deve essere dichiarata come astratta. L'attributo astratto viene ereditato fino a quando non viene raggiunta la completa implementazione dei metodi astratti.

La classe astratta può contenere anche metodi concreti che possono essere utilizzati dalla classe derivata così com'è. Tuttavia, 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 (parametro_list) {// metodo concreto} return_type method_name4 (parametro_elenco) {// 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 una classe ha almeno una funzione virtuale, la classe diventa una classe astratta. Invece della parola chiave "astratto", la parola "virtuale" viene utilizzata per dichiarare un metodo astratto.

1. Quando hai la conoscenza di "ciò che è richiesto" ma non di "come sarebbe implementato", allora l'interfaccia deve essere utilizzata. D'altra parte, se sai cosa è richiesto e sai parzialmente come sarebbe implementato, usa una classe astratta.
2. Un'interfaccia ha tutti i suoi metodi astratti ma, una classe astratta ha alcuni metodi astratti e alcuni metodi concreti.
3. I metodi all'interno di un'interfaccia sono pubblici e astratti, quindi, è anche chiamato come una classe astratta pura. D'altra parte, i metodi all'interno di un abstract non sono limitati a essere solo pubblici e astratti.
4. Un metodo di interfaccia non può mai essere privato, protetto, definitivo, statico, sincronizzato, nativo o strictfp. D'altra parte, non ci sono restrizioni ai metodi di una classe astratta.
5. Le variabili in un'interfaccia sono pubbliche e definitive, indipendentemente dal fatto che le dichiariamo o meno, mentre non esiste una tale restrizione per le variabili di una classe astratta solo pubbliche e definitive.
6. Le variabili in un'interfaccia non possono mai essere transitorie private o volatili, mentre non vi è alcuna restrizione alle variabili in una classe astratta.
7. 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.
8. All'interno di un'interfaccia non è possibile dichiarare un'istanza o un blocco statico, ma è possibile dichiarare un'istanza o un blocco statico all'interno di una classe astratta.
9. 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 esigenze, il concetto di interfaccia e classe astratta aiuta a farlo.