Continua il mio articolo sulla programmazione orientata agli oggetti. Abbiamo definito nei due scorsi articoli cosa è l’ereditarietà e cosa è esattamente una interfaccia e come queste due entità siano in relazione fra loro. Abbiamo però tralasciato alcuni concetti molto importanti della programmazione ad oggetti: cosa è una classe? Come interagiscono tra loro e soprattutto, come si fa ad estendere una classe?

Con i concetti descritti finora, possiamo già dare un significato all’entità “classe“.

Una classe altro non è che l’insieme dei metodi, delle proprietà e degli attributi di un particolare oggetto.

Nella programmazione procedurale, come ad esempio nel C, capitava spesso di trovarsi di fronte a problemi come avere bisogno di una entità in grado di gestire da sola i propri problemi.

Esempio:

Un esempio lampante che mi viene in mente (dovuto probabilmente alle mille ore dedicate all’esame di Reti di Calcolatori), è quello in cui bisognava realizzare una comunicazione con un server nel quale si lavorava con le varie socket e poi bisognava spedire e ricevere dati. Al tempo, per l’esame realizzai un file che aveva i metodi Connect, Send, Receive, CloseConnection (nel caso TCP ovviamente). Questo file lo importavo nel main e tramite quelle 4 funzioni lavoravo direttamente con il server. E se avessi dovuto lavorare con 2 server diversi contemporaneamente? Non potevo di certo usare le stesse funzioni perchè logicamente erano dedicate al primo server e quindi o creavo un thread parallelo (che su windows è un mezzo casino abbastanza complicato), oppure risolvevo creando altre 4 funzioni, Connect2, Send2, Receive2, CloseConnection2, con tutti i problemi che ne derivavano… Ovvero che se avessi dovuto contattare un 3° server sarebbe stata la fine, se poi usavo RPC con tutta la questione dei puntatori sarei completamente collassato a terra. L’esame per fortuna è passato e ora mi dedico al C#, che di questi problemi non ne ha nemmeno l’ombra. Con l’introduzione dei linguaggi a oggetti come Java, Smalltalk, C#, C++ e vari, basta creare una classe (un oggetto, un’entità a sé quindi), che contiene questi 4 metodi, poi creare 4 istanze di questa classe ed il gioco è fatto. In C# questa classe esiste già e si chiama ad esempio TcpClient che guarda caso ha i metodi Connect e Close e un metodo GetStream() che permette di inviare e ricevere i dati dal canale.

C# gestisce egregiamente questa caratteristica, essendo il framework completamente basato e orientato agli oggetti. Infatti, ogni singola classe deriva in maniera diretta o indiretta dalla classe object, anche i numeri interi per capirci. Quindi, fare:

object numeroIntero = 5;

oppure

int numeroIntero = 5;

è esattamente la stessa identica cosa. Utilizzando una tecnica particolare comune a tutti i linguaggi managed (ovvero che si basano su un framework, quindi C#, VB.Net, Java ecc), la Reflection, e richiedendo il tipo di oggetto ad entrambi, in questo modo:

numeroIntero.GetType();

otterremo entrambe le volte System.Int32, che si riferisce appunto ad un numero intero.Ora che abbiamo chiarito a cosa ci riferiamo quando parliamo dell’entità classe, cerchiamo di chiarire meglio come interagiscono tra di loro diverse classi. Ritorniamo perciò al nostro problema iniziale. La prima cosa che balza all’occhio è che esistono 4 tipologie di acceleratore, 1 per ogni tipo di vettura. Visto che ogni acceleratore non ha funzionalità particolari, possiamo definire un enumerativo che li include tutti:

public enum TipoAcceleratore : int {
Tipo1 = 1,
Tipo2 = 2,
Tipo3 = 3,
Tipo4 = 4
}

Un’enumerativo è semplicemente una lista di oggetti, come un’insieme di categorie. L’enumerativo per antonomasia è la settimana:

public enum Settimana : int {
Lunedì = 1,
Martedì = 2,
Mercoledì = 3,
Giovedì = 4,
Venerdì = 5,
Sabato = 6,
Domenica = 7
}

Il nostro enumerativo TipoAcceleratore è definito come estensione della classe Int32, questo perchè in questo modo possiamo passare dal valore numerico dell’enumerativo a quello letterale senza problemi.Diamo ora un senso alla classe MacchinaGenerica che avevamo cominciato a vedere la volta scorsa, inseriamo perciò dei campi, ovvero dei dati appartenenti alla classe stessa:

private TipoAcceleratore _acceleratore = TipoAcceleratore.Tipo1;
private int _valAccelerazione = 0;
private int _curvatura = 0;
private string _nome = "Non ho un nome!";

//questo è il costruttore, ovvero una funzione che viene chiamata non appena viene creata la classe
public MacchinaGenerica(string nome, int accelerazione)
{
Nome = nome;
Acceleratore = (TipoAcceleratore)accelerazione;
}

public string Nome
{
get { return _nome; }
set { _nome = value; }
}

public int Curvatura
{
get { return _curvatura; }
set { _curvatura = value; }
}

public int ValoreAccelerazione
{
get { return _valAccelerazione; }
set { _valAccelerazione = value; }
}

public TipoAcceleratore Acceleratore
{
get { return _acceleratore; }
//il set è definito protetto per non fare modificare il valore dall'esterno
protected set { _acceleratore = value; }
}

C’è un pò di carne al fuoco. Cominciamo subito a vedere il costruttore. Il costruttore è una funzione che viene chiamata (eseguita) non appena viene creata un’istanza della classe, rimanendo nel paragone è un pò ciò che accade non appena viene costruita una vettura, quando il telaio viene marchiato per una ed una volta soltanto. Infatti nel costruttore noi andiamo a definire la tipologia dell’acceleratore, che può essere definito solo in questo momento e mai più, in quanto il set del campo è definito protetto (è un pò come se ogni volta che andassimo ad accendere la macchina potessimo decidere se può accelerare come una Ferrari o come una Cinquecento… non avrebbe senso!). Adesso siamo pronti per vedere un esempio di vettura vera e propria, creiamo perciò la classe Fiat500:

public class Fiat500 : MacchinaGenerica
{
public Fiat500()
: base("Fiat500", 1)
{
}
}

Come vedete è una vera banalità, quindi a voi il compito di creare le altre 3 classi… però non notate nulla? Guardando attentamente, accanto a Fiat500 c’è scritto “: MacchinaGenerica“. Questo è la modalità adottata da C# per indicare che Fiat500 in realtà estende (ovvero è una classe figlia) di MacchinaGenerica, cioè ogni istanza della classe Fiat500 è anche istanza di MacchinaGenerica (attenzione: ma non sempre è anche il contrario!). Come accadeva per object con gli interi infatti, accade che scrivendo:

Fiat500 fiat500 = new Fiat500();
MacchinaGenerica vettura = fiat500;

gli oggetti fiat500 e vettura sono la stessa identica cosa.Nelle prossime lezioni parleremo di alcune proprietà che derivano direttamente da questo discorso, come ad esempio il polimorfismo per citarne una. Oggi vi lascio, buon lavoro!

Continua il mio articolo sulla programmazione orientata agli oggetti. Ieri ho posto un problema e ho spiegato in sintesi cosa è l’ereditarietà. Oggi voglio cercare di chiarire qual’è il concetto di interfaccia ed introdurre il concetto di estensione di una classe che chiarirò poi nei prossimi articoli.

Vi ho lasciato cercando di introdurre il concetto di interfaccia. Ciò che voglio arrivare a spiegare è questo: supponiamo di avere una vettura generica che avrà per forza la funzionalità di:

1. accelerare
2. frenare
3. curvare a destra
4. curvare a sinistra

Ogni vettura esistente al mondo è anche una vettura generica. E’ logico affermare che una Ferrari è diversa da una Cinquecento, ma è vero anche che entrambe sono in grado di compiere (far compiere all’autista) queste 4 azioni, altrimenti non sarebbero autovetture (un treno ad esempio, che può solo accelerare in avanti o indietro e frenare, non è un autovettura per chiarirci). Ciò che quindi a noi interessa e che implicitamente facciamo quando andiamo a scuola guida, è imparare a districarci con questi comandi, indipendentemente dal modello di automobile che stiamo guidando. Impariamo cioè a governare un’interfaccia (volante, cambio, freno, acceleratore ecc.) a noi familiare in qualsiasi occasione, qualsiasi vettura ci venga data sotto mano.

Questo concetto è estremamente importante, perchè in questo modo noi generalizziamo il concetto di autovettura e ne astraiamo soltanto le proprietà comuni a tutte le macchine: che la porsche di James Bond abbia i retro-razzi è solo una condizione particolare della sua automobile, non vuol dire che tutte le auto abbiano i retro-razzi (magari!)

Ecco quindi che abbiamo dato un significato alla parola interfaccia, che possiamo definire come astrazione concettuale di una o più entità contenente metodi e proprietà comuni ad esse e che vogliono essere mostrati alle altre entità esterne.

Nel nostro caso particolare, volendo disegnare un diagramma potremmo definire qualcosa tipo questo:

Come si può vedere, in alto a sinistra ho posizionato l’interfaccia IMacchina che generalizza il concetto di macchina. Ho poi creato la classe MacchinaGenerica che altro non è che un oggetto di tipo IMacchina (si può vedere dal fatto che implementa l’interfaccia tramite il pallino sopra alla classe) e poi la gerarchia dei vari tipi di vetture definite dal problema, 4 in tutto: Fiat500, SeatLeon, FerrariF399 e PorscheBoxter, che estendono la classe MacchinaGenerica.

Vediamo qui sotto il codice di creazione dell’interfaccia IMacchina:

interface IMacchina
{
void Accelera();
void Frena();
void CurvaDestra();
void CurvaSinistra();
String GetNome();
}

Per il concetto di estensione di una classe, vi rimando al prossimo articolo. Per quanto riguarda invece l’implementazione di una interfaccia, la questione è abbastanza semplice. In pratica essendo che l’interfaccia è soltanto una bozza, qualcosa che noi mostriamo al mondo (vedi sopra) ma che in realtà non esiste, una classe che implenta una interfaccia deve contenere lo sviluppo codificato dei metodi abbozzati. In pratica è necessario dare un senso ai metodi e alle proprietà dell’interfaccia, tant’è che l’editor di C#, Visual Studio, dal momento che una classe implementa una interfaccia obbliga a definire tutti i metodi che vengono dichiarati.Qui sotto vi mostro il primo abbozzo della classe MacchinaGenerica:

public class MacchinaGenerica : IMacchina
{
#region IMacchina Members

public void Accelera()
{
//qui la macchina accelera
}

public void Frena()
{
//qui la macchina frena
}

public void CurvaDestra()
{
//qui curva a destra
}

public void CurvaSinistra()
{
//qui curva a sinistra
}

public string GetNome()
{
//qui dovremo ritornare il nome della macchina
}

#endregion
}

Nel prossimo articolo vedremo di dare più senso e responsabilità a questa classe, definendo inoltre il concetto di estensione di una classe. A presto!

Mi è capitata su un forum una domanda alquanto bizzarra, ma assolutamente non scontata e banale per chi non si intende di programmazione. La domanda in questione era: a cosa servono le interfacce? Effettivamente, vista da chi ha qualche anno di programmazione sul groppone potrebbe sembrare una domanda stravagante, ma pensandoci meglio, è una domanda lecita che a ripensarci, me la sono posta anch’io ai tempi. In questo articolo, con qualche semplice regola, voglio illustrare cosa sono e come funzionano i principi base della programmazione Object Oriented, quindi l’uso di interfacce, classi, classi astratte e loro proprietà come l’ereditarietà o il polimorfismo, con qualche esempio in C#.

Innanzitutto la cosa principale che ogni buon programmatore deve chiedersi appena inizia a pensare ad un programma è: quale linguaggio di programmazione uso? Come dice il mio professore di Linguaggi e modelli computazionali, non bisogna fossilizzarsi su di un linguaggio. Molto spesso, basterebbe utilizzare linguaggi più semplici o diversi per risolvere lo stesso problema in minor tempo. Faccio un esempio che può essere d’aiuto: se vi viene chiesto di realizzare un sistema di controllo per le grammatiche, che linguaggio scegliereste? C, Java, C#, VB6, Cobol, Fortrand? La risposta è che esiste un linguaggio all’infuori di tutti questi che permette di semplificare la vita in questo campo… il Prolog. Con qualche semplice istruzione avreste il vostro sistema di controllo grammaticale, senza impazzire più di tanto. Provate a fare la stessa cosa in C e molto probabilmente impazzireste! Ma non dilunghiamoci troppo, questa era solo una premessa! Detto questo, analizziamo il problema e cerchiamo di trovare un linguaggio adatto. Il problema è questo:

Si deve realizzare un sistema in grado di operare su diverse autovetture. Si supponga che l’utente, una volta scelta una qualsiasi autovettura tra quelle disponibili, possa accelerare, frenare e curvare a destra e sinistra. Le vetture disponibili sono:

1. Fiat Cinquecento, acceleratore di tipo 1
2. Seat Leon, acceleratore di tipo 2
3. Porsche Boxter, acceleratore di tipo 3
4. Ferrari F399, acceleratore di tipo 4
   

Ogni acceleratore incrementa una variabile di un valore direttamente proporzionale al tipo (ad esempio l’acceleratore di tipo 4 incrementa di 4 volte, l’acceleratore di tipo 1 incrementa di 1 volta sola). Il freno decrementa la stessa variabile di 1 ogni volta che viene premuto. Destra e sinistra impostano semplicemente una variabile che indica lo stato di curvatura dell’autovettura (ad esempio sinistra decrementa di 1, destra incrementa di 1).

Il sistema deve inoltre poter prevedere l’immissione di un’autovettura personalizzata dell’utente, con acceleratore a sua discrezione (tra i 4 disponibili).

Bene! Il problema è bene impostato. Io personalmente porterei la mia scelta su 2 linguaggi fra quelli proposti sopra: C# e Java. Perchè proprio questi? Perchè sono ad oggetti e sono orientati agli oggetti, C# e Java in particolare. Potrebbe andar bene anche VB6, con qualche ritocco.

Adesso da bravi programmatori, cerchiamo di progettare il sistema in modo che quanto descritto sopra possa essere scritto sotto forma di codice ben impostato. Personalmente, la prima cosa che mi balza all’occhio è la forte ereditarietà del sistema. Cosa intendiamo con ereditarietà? Beh è molto semplice. Se io, oggetto, ho in comune delle cose, come delle funzioni o delle proprietà, con un altro oggetto, ma sono più specializzato di lui, allora io sono una sorta di suo figlio, ho cioè una sorta di parentela con lui. Ecco che nasce il concetto di ereditarietà. Prendiamo come esempio le figure geometriche (escluso il cerchio): una figura generica probabilmente avrà come proprietà un numero finito di lati. Un quadrilatero sarà una particolare figura geometrica con 4 lati. Un triangolo una particolare figura geometrica con 3 lati e così via.

Nel nostro particolare problema, possiamo vedere che esiste una relazione tra le varie vetture… la prima è che tutte hanno un acceleratore, un freno e possono curvare a destra a sinistra e poi hanno tutte un nome che volendo è possibile visualizzare a video. Ecco che perciò potremmo creare una interfaccia, un oggetto che semplicemente mostra agli altri delle proprietà di diversi oggetti.

L’interfaccia IMacchina mostra al mondo alcuni metodi, che sono comuni a tutte le macchine: Accelera, Frena, CurvaADestra e Sinistra e una proprietà che ci restituisce il nome dell’autovettura. Per capire meglio a cosa servono le interfacce, attendete il prossimo articolo… per ora c’è già abbastanza carne al fuoco!