Devo spiegare ad alcuni studenti l'uso di classi e interfacce astratte, dato che ho un background molto tecnico, vorrei sapere se mi aiuterebbe a definire una spiegazione facile per i junior.
Definizione semplice:
Quali sono gli scopi delle classi astratte, delle interfacce e qual è la differenza tra i due?
Quando è opportuno utilizzarne uno invece dell'altro?
Grazie.
Vedrò se riesco a farlo con una terminologia generica senza troppa agitazione della mano.
Un'interfaccia è come un contratto. Dice che una classe che implementa l'interfaccia accetta di implementare tutte le funzioni dichiarate (solo come firme, nessuna definizione di funzione) da quella interfaccia. La classe può farlo in qualsiasi modo scelga e fornire qualsiasi altra funzionalità, purché implementi ciascuna delle funzioni dichiarate. Un'interfaccia è utile quando si desidera essere in grado di utilizzare alcune funzionalità comuni di classi altrimenti non correlate: non condividono dettagli di implementazione, ma solo le firme delle funzioni. In C #, le dichiarazioni di funzione all'interno di interface sono implicitamente puramente virtuali.
Una classe astratta è una classe parzialmente definita che non può essere istanziata . In genere include alcune implementazioni, ma lascia alcune funzioni come pure virtuali, dichiarate solo dalla loro firma. Le funzioni virtuali pure non sono definite nella classe che le dichiara, quindi devono essere implementate da una sottoclasse (a meno che anch'essa non sia una classe astratta). Solo una sottoclasse che definisce tutte le funzioni virtuali pure può essere istanziata. Lo scopo di una classe astratta è definire un comportamento comune che può essere ereditato da più sottoclassi, senza implementare l'intera classe. In C #, la parola chiave abstract designa sia una classe astratta che un metodo virtuale puro.
In termini pratici, la differenza tra i due è che un'interfaccia definisce solo funzioni virtuali pure, mentre una classe astratta può includere anche funzioni concrete, membri o qualsiasi altro aspetto di una classe.
Un'interfaccia dice all'utente che questa classe supporterà queste funzioni .
Ad esempio:
public interface IWorker
{
void DoWork();
}
public class MyInformation : IWorker
{
public void DoWork()
{
//Do your class-specific Work
}
}
var info = new MyInformation();
info.DoWork();
Potresti chiedere qui - perché non aggiungere semplicemente il metodo in MyInformation, invece di implementare un'interfaccia?
Ecco una situazione in cui sarebbe utile:
List<IWorker> workers = GetWorkers();
foreach(var worker in workers)
worker.DoWork();
Qui non sappiamo che tipo di oggetti stiamo ricevendo. Tutto ciò che sappiamo è che implementeranno uno dei metodi definiti in IWorker. Non ci interessa come lo fanno - tutto quello che ci interessa è che supportino la tua chiamata.
Come per una classe astratta:
public abstract class Serializer
{
protected void GetAttributes()
{
//Some default implementation
}
public abstract void SaveObject(String outputPath);
}
Abbiamo una classe serializzatore, che ha alcune implementazioni di base di default - ma da sola non fa nulla. Non sa come scrivere l'output - solo come ottenere le informazioni sugli attributi.
Ora puoi avere un'implementazione concreta come:
public class XmlSerializer : Serializer
{
public override void SaveObject(String outputPath)
{
//Do your xml serializing
}
}
Che lo serializzerà in XML.
Ancora una volta, non ti interessa come serializzano, solo che lo fanno;
List<Serializer> serializers = GetWorkers();
foreach(var serializer in serializers)
serializer.SaveObject(@"C:\out.tmp");
Le interfacce sono come scheletri. Se vuoi costruire un essere umano, dovresti usare quello scheletro.
Le interfacce creano semplicemente un tipo di struttura per le classi per indicare che la classe dovrebbe avere una struttura definita e concordata. Ad esempio, tutti gli animali fanno pipì, mangiano e producono suoni. Pertanto puoi avere un'interfaccia, chiamata IAnimal , che indica solo che le classi devono Pee , Eat e MakeSound .
Le interfacce sono come semplici checklist, che dovrebbero essere implementate totalmente o nessuna. Quando vuoi utilizzare l'interfaccia IAnimal , è come se il tuo capo ti dicesse "Ehi, non creare una classe Cat a meno che tu non scriva alcuni metodi perché mangi, faccia pipì e suoni".
Le classi astratte sono come scheletri, ma con un po 'di carne anche su di loro. È solo lì per semplificare il tuo lavoro.
Puoi considerare una classe astratta come un'interfaccia, che ha già qualche implementazione.
Questa era la semplice risposta inglese. Ma dopo averlo ottenuto, per favore studia di più, per ottenere il vero concetto.
Cercherò di essere semplice.
Una classe astratta è una classe. È speciale nel fatto che non puoi creare oggetti di classe astratta. Una classe non astratta nella classe concreta chiamata.
Una classe astratta, essendo una classe, può avere elementi usuali in essa come campi, proprietà, metodi, eventi, indicizzatori, ecc. Si noti che, poiché è garantito che la classe astratta non verrà istanziata per creare oggetti, alcuni di questi elementi cab essere senza implementazioni (es. metodi senza corpo).
Un'interfaccia è una descrizione dei membri che alcune altre classi avranno di sicuro. L'interfaccia C # può descrivere solo metodi, proprietà, indicizzatori ed eventi.
Se una classe implementa l'interfaccia, allora deve implementare tutti i membri descritti dall'interfaccia.
Ciò significa che se una classe, implementando un'interfaccia, non implementa tutti i membri descritti da tale interfaccia, allora tale classe deve essere di classe astratta!
Una classe astratta può essere una classe "semi-cotta", nel senso che ha fornito pochi metodi con il corpo, ma pochi metodi non hanno corpo ecc. Un'interfaccia non può mai implementare alcun membro che descrive.
La classe astratta partecipa alla gerarchia delle classi in base all'ereditarietà. Nota che in C #, una classe può avere al massimo una classe genitore che può o meno essere astratta.
Una classe può implementare molte interfacce contemporaneamente.
Ci sono molti casi d'uso per entrambi.
Le seguenti dichiarazioni dovrebbero darti più chiarezza:
Nessuna interfaccia o classe astratta può essere istanziata.
La classe può ereditare da zero o una (astratta o concreta) classe.
L'interfaccia può ereditare da zero o più interfacce.
L'interfaccia non può ereditare una classe.
La classe astratta potrebbe avere membri con implementazione.
L'interfaccia non può avere alcun membro con implementazione.
Per essere concreti, la classe deve implementare tutti i membri nell'interfaccia.
Spero che questo aiuti.
Leggi altre domande sui tag object-oriented c#