Classi astratte ed interfacce

Nella programmazione ad oggetti spesso può crearsi il dubbio sulla differenza tra un’interfaccia e una classe astratta e sulle modalità per cui sia necessario utilizzare una a discapito dell’altra.
Vediamo per prima cosa cosa sono entrambe per poi fare delle considerazioni sul loro utilizzo.

1. Interfacce

Un’interfaccia è un tipo di dato (paragonabile ad una classe) con le seguenti caratteristiche:

  • Risulta composta solo da metodi astratti;
  • ogni metodo dichiarato in un’interfaccia deve essere implementato nella sottoclasse;
  • Non ha attributi e quindi non può avere uno stato;
  • Permette l’ereditarietà multipla, in quanto una classe può essere figlia di più interfacce

Un’interfaccia può essere vista come punto di incontro tra componenti simili che hanno una struttura interna diversa.

2. Classi astratte

Citando wikipedia, la classe astratta da sola non può essere istanziata, viene progettata soltanto per svolgere la funzione di classe base e da cui le classi derivate possono ereditare i metodi. Le caratteristiche “incomplete” della classe astratta vengono condivise da un gruppo di sotto-classi figlie, che vi aggiungono caratteristiche diverse, in modo da colmare le “lacune” della classe base astratta.
Una classe astratta possiede le seguenti caratteristiche:

  • Non può essere istanziata;
  • Contiene almeno un metodo astratto;
  • Può avere attributi e quindi avere uno stato;
  • Una classe può essere figlia di una sola classe astratta.

Questo processo di astrazione ha lo scopo di creare una struttura base che semplifica il processo di sviluppo del software o che indirizza la programmazione delle classi figlie.
Utilizzando una classe astratta è possibile inoltre definire delle implementazioni di default di metodi nel caso in cui i figli non le implementino.

3. Classe astratta o interfaccia?

Quando definiamo una classe astratta stiamo definendo le caratteristiche generiche di un oggetto (cosa un oggetto è), che saranno implementate genericamente dalle classi figlie. Nel caso invece di un’interfaccia definiamo ciò che un oggetto può fare, e siamo conseguentemente obbligati a definire, nella classe figlia, le implementazioni a questa capacità.
Quindi un oggetto è solo di un tipo (può essere figlio di una sola classe astratta) ma può avere tante abilità diverse (può ereditare da diverse interface).
Per esempio la classe string (in c#) ha la seguente dichiarazione:

public sealed class String : IComparable, ICloneable, IConvertible,
IComparable<string>, IEnumerable<char>, IEnumerable, IEquatable<string>

Come si può notare le interface indicano tutte le cose che questo oggetto può fare, le capacità che deve implementare per poter essere definito string.

Usare una interfaccia quando voglio un contratto per chi implementa l’interfaccia sul comportamento che questo deve avere. Una interfaccia è un guscio vuoto, molto leggero a livello di CPU, che non può fare nulla, è solo un pattern.
Le classi astratte sono effettivamente classi, possono sia definire dei comportamenti generici (metodi astratti) che un comportamento di default (metodi concreti).

Indice

Share
Ultimi articoli
Join

Newsletter

Nessuno spam, solo articoli interessanti ;)

Focus

Post correlati

semaphoreslim

SmaphoreSlim 101

SemaphoreSlim è una classe che permette la sincronizzazione di n thread che hanno una risorsa (scarsa) condivisa limitandone l’uso ad un numero massimo.

interlocked

Interlocked 101

La sincronizzazione dei thread è un elemento fondamentale nella programmazione asincrona, ne ho infatti parlato in vari post. La soluzione più versatile è sicuramente utilizzare

event

Come testare gli eventi

Testare che degli eventi siano stato effettivamente lanciati in C# non è immediato. Tipicamente è possibile testare che un evento venga lanciato aspettando un ManualResetEvent

Codice Pragmatico

Contatti

Per informazioni, dubbi o consulenze non esitate a contattarmi.

Lascia un messaggio

Ricevi le ultime news

Iscrivi alla newsletter

Solo articoli interessanti, promesso ;)