Fondamenti di programmazione

ad oggetti

Introduzione

Programmi semplici e non orientati agli oggetti possono constare di unalunga lista di istruzioni (statements). Programmi più complessiraggruppano spesso piccoli blocchi di istruzioni in funzioni o sub-routines, ciascuna delle quali realizza un obiettivo particola r e . Per programmi così strutturati è piuttosto comune che qualche dato siaglobale e cioè accessibile e modificabile da qualsiasi sezione delprogramma. Con l'aumento della dimensione dei programmi, permetteread ogni funzione di modificare qualsiasi dato rende inevitabile lapropagazione di numerosi errori (bugs).

L’approccio della programmazione orientata agli oggetti, d'ora in poichiamata OOP, invece, fa sì che il programmatore localizzi i dati dovenon siano direttamente accessibili dal resto del programma. Ai dati stessisi può accedere chiamando delle funzioni scritte in modo particolare, comunemente definite metodi, le quali, o sonoimpacchettate con i dati oppure ereditate da “ o gg etti clas s e. Tali funzioniagiscono come intermediari per recuperare o modificare i dati checontrollano. L’unità di programmazione nella quale i dati sono associatiad una serie di metodi per gestirli viene definita in OOP un oggetto.

L’architettura Software

L’architettura software di un programma informatico è l’insieme di datistrutturali necessari per ragionare su di esso: tali dati comprendono glielementi del software, le relazioni che intercorrono tra di essi e leproprietà degli uni e delle altre. Per definizione, l’architettura softwareè l’insieme di regole pratiche, criteri e schemi di progettazione cheregolano: • la suddivisione del problema e del sistema informatico che si devecostruire per risolverlo in moduli discreti;

• le tecniche per creare interfacce fra tali moduli;• le tecniche per gestire la struttura generale ed il flusso del programma;

• le tecniche per interfacciare il sistema all’ambiente (cioè al linguag-gio di programmazione); • l’uso corretto di approcci, tecniche e strumenti di sviluppo e distri-

buzione. Gli scopi primari dell’architettura sono: - la definizione dell’ambiente un sistema (e cioè del linguaggio informatico

relativo) e la definizione dei suoi requisiti non funzionali, di quelle qualità sonorelative a ciò che esso è e non a ciò che fa (requisiti funzionali). Sono requisiti non funzionali quelli osservabili a runtime, come ad esempio la sicurezza e la facilità di utilizzo e quelli incorporati nella struttura statica del sistema come, ad esempio, la manutenibilità el’espansibilità.

La definizione del progetto informatico viene seguita da quella dellasua realizzazione funzionale in accordo con le regole dell’architettura.

L’architettura è importante perché: • limita la complessità del programma consentendone la suddivi- sione in elementi più semplici (moduli o subroutines); • fa sì che vengano applicate le procedure migliori (best practice);• conferisce consistenza e uniformità;• consente il riutilizzo di moduli (subroutines) del programma.

Obiect Oriented Programming

L’OOP è una filosofia di progettazione che utilizza linguaggi diprogrammazione diversi da quelli impiegati dai vecchi linguaggiprocedurali (come il Pascal ed il C). È un tipo di programmazione in cui gli sviluppatori non si limitano adefinire il tipo di dati in una struttura dati (una struttura dati è un modoparticolare di immagazzinare ed organizzare dati in un computer dimodo che possano essere utilizzati in modo efficiente) ma definisconoanche i tipi di operazioni (funzioni) che possono essere applicate adessa. Così la struttura dati diventa un oggetto che comprende sia dati chefunzioni.

I programmatori, inoltre, possono mettere in relazione i vari oggetti(un oggetto può ereditare le caratteristiche di un altro). Uno dei principali vantaggi delle tecniche OOP, rispetto alletecniche procedurali, consiste nel fatto che offrono al programmatore la possibilità di creare moduli autosostenibili che non devonoessere modificati se si aggiunge un nuovo tipo di oggetto, rendendoil programma più facile da modificare (meno rigido). Un programma orientato agli oggetti conterrà di solito differenti tipidi oggetti ed ogni tipo corrisponderà o ad un serie particolare di daticomplessi da gestire, oppure ad un elemento od un concetto delmondo reale, come per esempio un conto corrente postale, un calci-atore o una macchina per il movimento . Un programma potrebbe benissimo contenere più copie dello stesso

oggetto, una per ogni controparte del mondo reale con cui il program-ma ha a che fare. Per esempio ci potrebbe essere un oggetto calciatoreper ciascun calciatore reale della serie A e ciascuno di essi sarebbe si-mile agli altri dal punto di vista dei metodi disponibili per manipolare o leggere i suoi dati, i quali sarebbero però diversi per ogni specificoatleta (nome, età, ruolo, …). Si può immaginare che gli oggetti siano una serie di dati impacchettati inuna serie di funzioni progettate per far sì il loro utilizzo sia al contemposemplice ed appropriato. Un oggetto può inoltre essere in grado di mettere a disposizione sem-plici metodi standardizzati per eseguire determinate operazioni sui suoi dati e ciò senza rendere accessibile al resto del programma il modo in cui tali operazioni vengono realizzate.

Ciò consente di modificare la struttura interna o i metodi di unoggetto senza la necessità di modificare il resto del programma. Tale caratteristica diventa particolarmente utile se il codice di unprogramma è scritto da più di un programmatore oppure sel’obiettivo è il riutilizzo di codice tra due programmi diversi. L’OOP è una tecnologia basata non tanto sulle funzioni quanto sui daticon programmi costituiti da moduli autosufficienti (classi), ciascunaistanza dei quali (oggetto della classe) contiene tutte le informazioninecessarie per manipolare la sua struttura dati (membri). Un programma orientato agli oggetti si può considerare una collezionedi oggetti interattivi ciascuno dei quali è in grado di processare dati edi scambiare messaggi con gli altri. Ciascun oggetto è un’unità operativa autonoma, con un proprio ruolo

ed una propria responsabilità, le cui azioni (metodi) sono strettamenteassociate all’oggetto stesso. Tre dei concetti basilari, nella programmazione orientata agli oggetti,sono le classi, gli oggetti ed i metodi ma sono notevolmente importantianche concetti quali quelli di astrazione, incapsulamento, ereditarietà epolimorfismo.

Oggetti

Un oggetto è un’ entità che può eseguire, o sulla quale si può eseguire,un’insieme di attività ad essa correlate: tali attività definiscono

il suo comportamento. Gli oggetti sono le entità fondamentali chevengono utilizzate in un sistema orientato agli oggetti al momentodell’esecuzione del programma (runtime): essi interagiscono tra di loroscambiandosi informazioni e ciò anche senza essere a conoscenza di codice o dati relativi. Gli oggetti sono caratterizzati da due proprietà:

1. identità: le caratteristiche di un oggetto che permettono didistinguerlo da altri;

2. stato: descrizione dei dati (proprietà) immagazzinati nell’oggetto.

Ogni oggetto è inoltre caratterizzato dai propri metodi, che descrivonoil comportamento dell'oggetto stesso.

Così, ad esempio, l’oggetto motocicletta avrà le proprietà marca, mo-dello, capacità del serbatoio, tipo di freni, modello di cambio… ed imetodi accelerare, frenare, cambiare marcia, rifornirsi di benzina.... Formalmente, in OOP, un oggetto è definito come una delle istanzedi una classe la quale, prima di poter essere usata nel software, deveessere istanziata in un oggetto. Possono esistere molteplici istanze diuna data classe.

Classi Una classe è la rappresentazione generale di una certa tipologia di og-getti. In OOP, una classe è un costrutto usato come stampo (progetto, pro-totipo), che definisce le variabili e i metodi comuni a tutti gli oggetti di una certa specie, utilizzato per ottenere, al momento di esecuzionedel programma, delle realizzazioni specifiche della classe stessa (istanzedella classe, oggetti della classe o semplicemente oggetti). Una classe definisce dei membri costitutivi che consentono a tali istanzedi avere uno stato (attributi) ed un comportamento (metodi). Come le sue istanze, di cui è una generalizzazione, una classe consta di un nome, di una serie di attributi e di una serie di metodi. Nel mondo reale si incontrano spesso parecchi elementi

dello stesso genere. Possono esistere, per esempio, migliaia di moto-ciclette dello stesso tipo ciascuna delle quali, nel linguaggio OOP, èun’istanza della classe motocicletta. Una classe può essere rappresen-tata schematicamente come segue:

Il codice per creare un’istanza di una classe è il seguente:

Teacher

- age: int - name : string

+ Teacher (): void + DoTeach (object): boolean<<property>> + Name () : string + Age () : int

public class Teacher { } Teacher objectTeacher = new Teacher();

L’oggetto della classe Teacher, denominato objectTeacher, èstato istanziato dalla classe Teacher (instanziazione della classe).

Identificazione e progettazione di una classe

La progettazione di un software non è adeguata se, nonostante ilsoftware stesso soddisfi alle richieste per cui è stato progettato, essopresenta una o più delle seguenti caratteristiche:

1. è difficile da modificare in quanto una modifica in una suaparte si riflette su troppe altre parti del sistema (rigidità in con-trapposizione a flessibilità).

2. quando si modifica una parte si provoca inaspettatamente larottura di altre parti (fragilità in contrapposizione a robustezza).

3. è difficile riutilizzarlo in un’altra applicazione perché non lo sipuò districare dall’applicazione corrente (immobilità in contrap-posizione a riutilizzabilità).

Ciò che rende un progetto rigido, fragile ed immobile è l’interdipen-denza dei moduli al suo interno. La rigidità dipende dal fatto che un singolo cambiamento in modulodi un software, i cui moduli siano fortemente dipendenti tra di loro, provoca una cascata di cambiamenti in moduli dipendenti. Un programma è fragile se un singolo e semplice cambiamento pro-voca l’insorgere di problemi in aree che non sembrerebbero correlatea quella in cui si è realizzato il cambiamento stesso. Nell’ovviare aquesti problemi se ne provocano dei nuovi di modo che la manuten-zione del software diventa praticamente impossibile. Un progetto è immobile quando i suoi moduli, che si vogliano even-tualmente riutilizzare in un altro progetto, dipendono strettamente da altri, che non sono richiesti, di modo che risulta più conveniente ri-

scriverli ex novo piuttosto che separarli da quelli che non occorrono. Nel caso della progettazione di una classe le tecniche utilizzate varia-no da un progettatore all’altro e lo stato dell’arte è ancora, appunto,piuttosto artigianale. Esistono comunque alcuni principi che è opportuno seguire al fine di ottenere un software flessibile, robusto e riutilizzabile. Il principio di responsabilità singola: una classe dovrebbe avere una sola responsabilità, cioè una sola funzione da realizzare, per rendereminimo (uguale ad 1) il numero di possibilità di modificazioni. Il principio di apertura e chiusura: oggetti software come classi, mo-duli, funzioni devono essere espandibili ma non modificabili. Quandouna singola modificazione in un programma si riflette in una cascata di modificazioni nei moduli correlati, esso diventa rigido, fragile im-

prevedibile e non riutilizzabile. Le classi quindi devono essere co-struite in modo tale da non cambiare mai e le eventuali nuove richie-ste, cui deve andare incontro un programma, devono essere soddisfat-te non modificando il codice vecchio, già funzionante, ma aggiungen-done del nuovo. Il principio dell’inversione della dipendenza: le classi di livello gerar-chico superiore, che hanno caratteristiche più astratte e generali, nondevono dipendere da quelle di livello inferiore, con carattere più con-creto e specifico, ma deve essere il contrario: ciò per impedire cheuna modifica a livello particolare si rifletta a livello generale. Per identificare correttamente una classe è necessario riconoscere ed elencare fino al livello più elementare tutte le funzioni (operazioni)che il sistema informatico dovrà essere in grado di eseguire.

Si passa quindi a raggruppare le varie funzioni in classi (con ciascuna classe che raggrupperà funzioni dello stesso tipo). In ogni caso, una classe ben definita deve costituire un raggruppamen-to significativo di una serie di funzioni e deve consentire la riutilizza-bilità incrementando nel contempo l’espandibilità e la manutenibilitàdel sistema complessivo. Nel mondo del software è sempre consigliabile l’applicazione delconcetto del “divide et impera”. L’analisi di un sistema nella sua globalità è sempre una cosa piuttostodifficile. L’approccio migliore consiste nell’identificare prima i mo-duli del sistema e quindi analizzarli separatamente per riconoscere le classi. Un sistema informatico può essere costituito da numerose classi, la

cui gestione può comportare diversi problemi. Per risolverli i progettatori usano diverse tecniche che possono esseredivise in quattro gruppi concettuali fondamentali, che sono i quattroconcetti principali della programmazione orientata agli oggetti,denominati incapsulamento, astrazione, ereditarietà e poli-morfismo.

Incapsulamento (o segregazione delle informazioni).

L’incapsulamento è una metodica che associa codice e dati in un og-getto e li mantiene entrambi al sicuro da interferenze esterne e/o da utilizzazioni scorrette: si isolano dati e codici particolari da altri dati ecodici. Esso consiste nell’inclusione in un oggetto di un programma di tuttele risorse di cui esso ha bisogno per funzionare: fondamentalmentemetodi e dati. In OOP l’incapsulamento è realizzato principalmente tramite la crea-zione di classi le quali rendono accessibili al resto del programma (al-tre classi) metodi e proprietà ma non i dati, che risultano accessibilisolo alle funzioni immagazzinate nella stessa classe.

La classe è una specie di contenitore, o capsula o cella, che incapsulala serie di metodi, attributi e proprietà da fornire, a richiesta, alle altreclassi. In questo modo, l’incapsulamento permette che una classe pos-sa modificare la sua realizzazione interna senza interferire con il fun-zionamento globale del sistema. Il concetto base dell’incapsulamento è di tener segregate le modalitàdi funzionamento di una classe ma di permettere l’uso delle sue fun-zionalità. Una classe può utilizzare funzioni e/o proprietà rese disponibili daun’altra in molte maniere diverse. Nel contesto dell’OOP esistono varie tecniche che consentono a clas-si diverse di correlarsi: associazione, aggregazione e composizione.

Associazione, aggregazione e composizione.

In OOP la composizione di oggetti è un modo per combinare oggettisemplici in oggetti più complessi. Un esempio di composizione, nelmondo reale, è la relazione tra un’automobile e le sue parti:l’automobile has-a o è composta da oggetti quali il volante, i sedili,la scatola del cambio ed il motore. Se, come nei linguaggi dell’OOP, gli oggetti sono tipizzati, allorapossono essere compositi o meno e la composizione può essereconsiderata una relazione tra tipi: un oggetto di tipo composito(automobile) has a un oggetto di tipo più semplice (ruota). La composizione non va confusa con la sottotipizzazione, che è unprocedimento consistente nell’aggiungere dettagli ad un oggetto perottenere oggetti più specifici. Per esempio le automobili sono un tipo

particolare di veicoli: car is a vehicle. La sottotipizzazione non descrive una relazione tra oggetti diversi maafferma che oggetti di un certo tipo sono anche oggetti di un tipo piùgenerale. Nella notazione UML (Unifyed Modelling Language) la composizioneè rappresentata da un rombo pieno e da una linea continua.L’aggregazione, una forma più generale della composizione, è rap-presentata da un rombo vuoto e da una linea continua. composizione:

aggregazione:

Car

Pond

Carburetor

Duck

// Compositionclass Car { private: Carburetor* carb;public: Car() : carb(new Carburetor()) { } virtual ~Car() { delete carb; }};

// Aggregationclass Pond { private: std::vector<Duck*> ducks;};

L’aggregazione differisce dalla composizione in quanto non implicail possesso. Nella composizione se l’oggetto possessore viene di-strutto quelli posseduti subiscono la stessa sorte. Per esempio una università possiede diversi dipartimenti (chimi-ca,fisica, …) e ogni dipartimento ha un certo numero di professori. Sel’università chiude, i dipartimenti smettono di esistere ma i profes-sori continuano la loro esistenza. Quindi un’università può essere

considerata una composizione di dipartimenti mentre i dipartimentihanno aggregazioni di professori (un’altra differenza è che un profes-sore potrebbe lavorare in più di un dipartimento ma un dipartimentonon può far parte di più di un’università).

In OOP un’ associazione definisce una relazione tra classi di oggettiche permette ad un oggetto istanza di far sì che un altro compia un’a-zione in sua vece. Questo tipo di relazione è strutturale in quanto specifica che oggettidi un dato tipo sono connessi ad oggetti di un altro e non è collegataal comportamento.

University Department Professor

A meno che non sia diversamente specificato, l’associazione è bidire-zionale, anche se può essere limitata ad una sola direzione (in UMLciò viene rappresentato con una linea continua e, rispettivamente, conuna freccia che punta in direzione della classe che viene utilizzata.Per i principianti il concetto di associazione può generare confusione,dovuta non solo a questo concetto, ma anche ai due concetti diaggregazione e composizione.

Classe A Classe BClasse A Classe B

Un modo per comprendere analogie e differenze tra questi tre utiliconcetti è quello di esaminarli assieme. L’associazione è una (*a*) relazione tra due classi in cui una delledue utilizza l’altra. L’aggregazione invece è un tipo particolare di associazione, è la (*the*) relazione tra due classi. Se un oggetto di una classe possiede (*has*) un oggetto di un’altra, se il secondo èuna parte del primo (relazione di inclusione) allora si dice che c’èun’aggregazione tra le due classi. A differenza dell’associazione,l’aggregazione specifica sempre la direzione.

public class Academy { private Secretary academySecretary = new Secretary(); }

In questo caso si può dire che Academy aggrega Secretary o che ha un (*has-a*) Secretary. Una Academy, però, può esistere anche senza un Secretary. I Courses, invece, non possono esistere senza l’Academy. La durata di vita di uno o più Courses è dipendente dalla durata divita dell’Academy. Qualora l’Academy venga chiusa i Courses ces-

Academy

- academySecretary : Secretary

<<property>> + academySecretary () : Secretary

Secretary

- name : string

Academy

- academySecretary : Secretary

<<property>> + academySecretary () : Secretary

Course

- name : string

Secretary

- name : string

D

sano di esistere e in questo è il caso si dice che l’Academy è composta diCourses: questa composizione può essere considerata come un tipoparticolare di aggregazione. Un fattore molto importante, che spesso viene dimenticato, è quellorelativo alla durata di vita. Due classi legate da una relazione di composizione sono interdipendentiper quanto riguarda la durata di vita.

Nel caso che non esista interdipendenza tra la durata di vita di diverseclassi, la relazione sarà di tipo aggregazione piuttosto che di tipocomposizione.Se se si desidera, pertanto, che due classi siano legate da unarelazione di composizione, il modo migliore per ottenere ciò consistenel definire l’una all’interno dell’altra: in questo modo la classeesterna può realizzare le sue funzionalità ed il ciclo di vita della classeinterna è legato a quello della classe esterna. In sintesi, si può affermare che l'aggregazione è un tipo particolare diassociazione e che la composizione è un tipo particolare di aggrega-zione.

Association → Aggregation → Composition

Astrazione e generalizzazione

L’astrazione consiste nel mettere l’accento sulle caratteristiche es-senziali tralasciando i dettagli specifici e le precisazioni.L’importanza dell’astrazione, essenziale nello sviluppo software,consiste nel fatto che essa consente di omettere i dettagli irrilevanti edi utilizzare nomi per gli oggetti di riferimento. Essa mette l’accento su ciò che un oggetto è o fa, piuttosto di come èrappresentato o di come funziona e questo approccio è fondamentaleper controllare la complessità di grandi programmi. Mentre l’astrazione diminuisce la complessità eliminando i dettagliirrilevanti, la generalizzazione ottiene lo stesso risultato rimpiazzan-do una serie di entità che realizzano funzioni simili con un unico co-

strutto informatico. La generalizzazione amplia un’applicazione in modo che possa com-prendere un insieme più esteso di oggetti dello stesso tipo o di tipodiverso. I linguaggi di programmazione realizzano la generalizzazione tramite variabili, parametrizzazione, tipi generici e polimorfismo. Si accentuano le somiglianze tra gli oggetti e ciò aiuta a tenere sottocontrollo la complessità, raccogliendo entità individuali in gruppi efornendo un’entità rappresentativa che si può usare per specificare ogni componente individuale di un gruppo. L’astrazione e la generalizzazione sono spesso usate di concerto. Le entità astratte vengono generalizate tramite parametrizzazione peraumentarne l’utilità.

Con la parametrizzazione, una o più parti di un’entità sonorimpiazzate da un nome nuovo e che è usato come un parametro. Si invoca l’entità astratta parametrizzata legando il parametro ad unargomento.

Classi astratte

Le classi astratte, dichiarate con la parola chiave abstract, non pos-sono essere istanziate. Possono essere utilizzate solamente come superclassi per altre classiche estendono la classe astratta. La classe astratta è un concetto la cui realizzazione si completa nelmomento in cui esso viene realizzato da una sottoclasse. Inoltre una classe può ereditare solo da una classe astratta (può peròrealizzare diverse interfacce), deve sovrascrivere tutti i suoi metodie le sue proprietà astratti e può sovrascrivere i suoi metodi e le sueproprietà virtuali. Le classi astratte sono l’ideale nella realizzazione di strutture di base.

Interfacce

Ogni classe realizza un’interfaccia fornendo una struttura (dati estato) ed un codice che specifica il funzionamento dei metodi. C’è una differenza tra la definizione di un’interfaccia e la sua imple-mentazione. Nella maggior parte dei linguaggi, questa differenza non ènetta in quanto la dichiarazione di una classe definisce un’interfaccia e contemporaneamente la realizza. Tuttavia, taluni linguaggi presentano caratteristiche che aiutano aseparare la definizione di un’interfaccia dalla sua realizzazione. Per esempio una classe astratta può definire un’interfaccia senza im-plementarla. I linguaggi che supportano l’eredità tra classi consen-tono ad una classe di ereditare un’interfaccia da una classe da cui sia-no derivate.

La metodologia della programmazione orientata agli oggetti èstrutturata in modo tale che le operazioni delle varie interfacce di unaclasse sono, in genere, indipendenti tra di loro. Il risultato è unoschema stratificato in cui i clienti di un interfaccia utilizzano i metodidichiarati nell’interfaccia stessa. Per esempio i bottoni di un apparecchio televisivo sono l’interfacciatra l’utente e i componenti elettrici ed elettronici contenuti nello chas-sis. Si preme il bottone “power” per accendere o spegnere l’apparec-chio. Nell’esempio, il televisore è l’oggetto ed ogni metodo corrisponde aduno dei bottoni che, tutti insieme, rappresentano l’interfaccia. Nella definizione più comune, un’interfaccia è la specificazione di ungruppo di metodi correlati indipendentemente dalla realizzazione dei

metodi stessi. Un televisore ha una serie di attributi (le dimensioni, lo schermo alplasma o a cristalli liquidi etc.) che tutti insieme ne costituiscono lastruttura. Una classe è la descrizione completa di un televisore, checomprende sia i suoi attributi (struttura), che i bottoni (interfaccia). In sintesi, l’interfaccia definisce la struttura isolandone la realizzazione,concetto molto utile qualora sia necessario che l’implementazione(realizzazione) sia intercambiabile. Oltre a ciò, un’interfaccia è molto utile nel caso che l’implementazio-ne cambi frequentemente. Un’interfaccia può essere impiegata per definire un modello generico e una o più classi astratte che definiscano le realizzazioni parziali del-

l’interfaccia. In questo caso, le interfacce si limitano a specificare ladichiarazione del metodo che, implicitamente è pubblico ed astratto e può comprendere proprietà che sono, sempre implicitamente, pubbliche ed astratte. Metodi e proprietà astratti sono definiti ma non implementati e, se pubblici, sono accessibili (utilizzabili) da qualsiasi blocco delprogramma. La definizione di un’interfaccia inizia con la parola chiave interfaccia. Un interfaccia di una classe astratta non può essere istanziata. Nel caso che una classe che realizza un’interfaccia non definisca tutti imetodi dell’interfaccia stessa, allora la classe deve essere dichiarataastratta e le definizioni dei metodi devono essere fornite dalla sotto-classe che estende la classe astratta.

Oltre a ciò un'interfaccia può ereditare altre interfacce. Come già ricordato in precedenza, esistono linguaggi che supportanovarie implementazioni. Il concetto di implementazione implicita edesplicita fornisce una maniera sicura per realizzare i metodi di varieinterfacce nascondendo, esponendo o preservando le identità di cia-scuno dei metodi delle interfacce anche quando le “firme” dei metodisiano le stesse.

Differenze tra una classe ed un’interfaccia

In alcuni linguaggi si può definire una classe che implementi un’in-terfaccia e sia anche in grado di supportare più di un’implementazio-ne. Quando una classe implementa un’interfaccia, un oggetto di taleclasse può essere incapsulato all’interno di un’interfaccia. Se MyLogger è una classe, che implementa ILogger, allora si puòscrivere:

ILogger log = new MyLogger();

Concettualmente una classe ed un’interfaccia sono due tipi diversi:mentre una classe pone l’accento sul concetto di incapsulamento, una

interfaccia accentua quello di astrazione, eliminando i dettagli dell'implementazione. Classe ed interfaccia sono nettamente distinte e diconseguenza è molto difficile o addirittura impossibile confrontarlein modo significativo. È invece molto utile e significativo osservare analogie e differenzetra un’interfaccia ed una classe astratta tra le quali, anche sesembrano simili, c’è una notevole differenza.

Differenze tra un’interfaccia ed una classe astratta Interfacce

• la definizione di un’interfaccia inizia con la parolachiave interface che ne caratterizza il tipo (interfac-cia); • non hanno implementazione ma devono essere im-plementate; • possono avere solo la dichiarazione, implicitamentepubblica ed astratta, dei metodi e dati, implicitamentepubblici e statici; • possono ereditare più interfacce;• possono essere utili quando l’implementazione va-ria; • rendono le implementazioni intercambiabili;• aumentano la sicurezza mantenendo nascosta l’im-plementazione.

Classi astratte • sono dichiarate per mezzo della parola chiave abstractche le caratterizza come classi; • i metodi delle classi astratte possono essere imple-mentati e devono essere estesi; • i metodi non possono avere implementazione solo sesono dichiarati astratti; • possono implementare più di un’interfaccia ma ere-ditare da una sola classe; • devono sovrascrivere tutti i metodi astratti e possonosovrascrivere quelli virtuali; • possono essere utili nella realizzazione di un model-lo; • possono essere impiegate per fornire un comporta-mento per default per una classe base; • rappresentano un modo ideale per creare gerarchie dieredità pianificate ed inoltre sono utilizzabili come ter-mini ultimi nelle gerarchie di classi.

Ereditarietà

È il processo grazie al quale un oggetto acquista le proprietà di un al-tro oggetto, il che è alla base della classificazione gerarchica. Senza l’impiego delle gerarchie, ogni oggetto richiederebbe una di-chiarazione esplicita di tutte le sue proprietà. Grazie all’ereditarietà,invece, è sufficiente definire solo le caratteristiche dell’oggetto che lorendono unico all’interno della sua classe. La classe derivata o sottoclasse può ereditare tutti i suoi attributi generalidalle classi gerarchicamente superiori da cui deriva. La creazione di una classe nuova per estensione di una classe già esi-stente viene definita ereditarietà.

public class Exception{ }

Exception

IOException

public class IOException extends Exception{ }

In accordo con l’esempio di cui sopra la nuova classe (IOException),che è una classe derivata - o sottoclasse - eredita i membri di unaclasse già esistente (Exception), che è una superclasse o classe di ba-se. La classe IOException può estendere la funzionalità della classeException, aggiungendo tipi e metodi nuovi e sovrascrivendo quellipreesistenti. Nello stesso modo in cui l’astrazione è strettamente cor-relata alla generalizzazione, l’ereditarietà è strettamente correlataalla specializzazione. Per una miglior comprensione e per ridurre la complessità è impor-

tante discutere i due concetti assieme a quello di generalizzazione. Nel mondo reale una delle più importanti relazioni tra oggetti è laspecializzazione, che può essere definita come una relazione del tipo“is-a”. Quando si dice che un cane è un mammifero si intende che un cane è un tipo specializzato di mammifero. Esso presenta tutte le caratteri-stiche dei mammiferi (animali vertebrati che respirano aria, a sanguecaldo, con peli, tre ossa nell’orecchio interno e ghiandole mammariefunzionali nelle femmine con prole giovane), ma tali caratteristichesono specializzate in quelle ben note del canis domesticus. Anche un gatto è un mammifero e, in quanto tale, ci si aspetta che es-so condivida talune caratteristiche del cane, che sono generalizzate nei mammiferi, ma differisca per quelle caratteristiche che sono spe-

cifiche per i gatti. Le relazioni di specializzazione e di generalizzazione sono sia reci-proche che gerarchiche. La specializzazione è l’altra faccia della generalizzazione: i Mammi-feri generalizzano ciò che è comune tra cani e gatti, mentre cani egatti specializzano le caratteristiche dei mammiferi nei proprisottotipi. Analogamente, a titolo di esempio, si può dire che siaIOException che SecurityException sono di tipo Exception. Essi presentano tutte le caratteristiche ed i comportamenti di una Ex-ception. Ciò significa che IOException è un genere specializzato di Exception. Anche una SecurityException è una Exception e, in quanto tale, ci siaspetta che essa condivida con IOException certe caratteristiche che

sono generalizzate in Exception, ma che differisca da essa per le ca-ratteristiche che sono specializzate in SecurityExceptions. In altri termini, Exception generalizza le caratteristiche comuni a IO-Exception ed a SecurityException, mentre IOException e SecurityEx-ception specializzano le proprie caratteristiche ed i propri comporta-menti. In OOP, la relazione di specializzazione è implementata tramite ilprincipio di ereditarietà e questo è il modo più diffuso, più naturale epiù largamente accettato di realizzare questa relazione.

Polimorfismo PPPolimorfis o è un termine generico che significaaa “molte forme”.

iù esattammmente in OOP

si possano avere più metodi, il che comporta che si possaprogettare un’interfaccia generica per un gruppo di attivitàcorrelate. Ciò permette di ridurre la complllessssssità, utilizzando una solainterfaccia per specificare una c a generale di az oni. Saràcompito d l compilatore selezionareee l’azione specifiiica, vale a dire ilmetodo, peeer ogni data situazione. La comprensione dei concetti dell’OOP è resa meno semplice dal fattoche essi sono suddivisi in quattro concetti principali ognuno dei quali èstrettamente correlato con gli altri. È quindi è necessario capirecorrettamente ogni concetto separatamente, senza perdere di vista ilmodo in cui essi sono tra loro correlati. In OOP il polimorfismo si ottiene grazie a molte differenti tecniche

denominate overloading (sovraccarico) dei metodi, overloadingdegli operatori ed overriding (sovrascrittura) dei metodi.

Overloading dei metodi

L’overloading dei metodi consiste nella possibilità di definire diver-si metodi con lo stesso nome. Nei linguaggi fortemente tipizzati a volte è desiderabile avere un cer-to numero di metodi con lo stesso nome, ma che operino su dati di ti-po diverso. Per esempio, una funzione radice quadrata potrebbe essere definita in modo da poter operare su numeri reali, numeri complessi o su matri-ci. L’algoritmo da usare in ciascun caso è diverso ed il risultato resti-tuito può non essere lo stesso. Scrivendo tre funzioni separate con lo stesso nome il programmatoreha il vantaggio di non dover ricordare nomi diversi a seconda del tipodi dati. Inoltre, se si può definire per i numeri reali un sottotipo che li

suddivida in positivi e negativi, per i reali stessi si possono scriveredue funzioni, una delle quali restituisce un numero reale quando il pa-rametro è positivo e l’altra che restituisce un numero complessoquando il parametro è negativo. Nella programmazione orientata agli oggetti qualora una serie di fun-zioni o metodi con lo stesso nome possa accettare parametri di tipodi-verso, si dice che ciascuna delle funzioni è sovraccaricata,overloaded. Per esempio:

public class MyLogger{

public void LogError(Exception e){

// Implementazione}

public bool LogError(Exception e, string message){

// implementazione}

}

Overloading degli operatori

L’overloading degli operatori (noto meno comunemente come po-lymorphism ad hoc) è un caso particolare di polimorfismo in cuiuno o più di una serie di operatori come +, - o == sono trattati comefunzioni polimorfiche e, come tali, hanno comportamenti diversi a se-conda del diverso tipo dei loro argomenti.

public class Complex{ private int real; public int Real { get { return real; } }

private int imaginary; public int Imaginary { get { return imaginary; } }

public Complex(int real, int imaginary) { this.real = real; this.imaginary = imaginary; }

public static Complex operator +(Complex c1, Complex c2) {

return new Complex (c1.Real + c2.Real, c1.Imaginary + c2.Imagina-ry); } } Nell’esempio di cui sopra è stato sovraccaricato l’operatore + persommare due numeri complessi. Le due proprietà denominate Real edImaginary sono state dichiarate rendendo accessibile solo il metodoget, mentre il costruttore (constructor) dell’oggetto richiede valoriobbligatori reali ed immaginari dal costruttore dela classe. Per esempio:

Complex num1 = new Complex(5, 7);Complex num2 = new Complex(3, 8);

// sommiamo due numeri complessi usando l’overloading di +

Complex sum = num1 + num2;

Overriding dei metodi

Le classi possono essere derivate da una o più classi esistenti (anchese non tutti i linguaggi sono in grado di supportare l’ereditarietàmul-tipla), originando così una relazione gerarchica tra le classi diorigine (classi basi o classi genitrici o superclassi, superclasses) e leclassi derivate (classi figlie o sottoclassi, subclasses). La relazione tra queste e quelle è nota comunemente come una rela-zione is - a. Per esempio la classe 'Button' potrebbe essere derivata dalla classe'Control'. Quindi, un Button is a Control. I membri strutturali e comportamentali della superclasse sonoereditati dalla sottoclasse. Le classi derivate possono definire membri strutturali (data fields) e/o

membri comportamentali addittivi (metodi) oltre a quelli che esseereditano e sono quindi specializzazioni delle relative superclassi.Ancora, qualora il linguaggio lo permetta, le classi derivate possonorimpiazzare (override) i metodi ereditati. L’overriding di un metodo, in OOP, è una caratteristica del linguag-gio che permette ad una sottoclasse di fornire una realizzazione speci-fica di un metodo che è già fornito da una delle sue superclassi. La realizzazione, nella sottoclasse, rimpiazza quella della superclassefornendo un metodo che ha lo stesso nome, gli stessi parametri e lostesso tipo di risposta di quello della superclasse. La versione del metodo che sarà eseguita sarà determinata dall’ogget-to che è usato per invocarla. Se viene usato un oggetto della super-classe verrà eseguita la versione del metodo della superclasse stessa,

ma se viene usato un oggetto della sottoclasse allora verrà eseguita la versione della sottoclasse. Una sottoclasse può dare la sua propria definizione dei metodi che,devono però avere la stessa “firma” che presentano nella superclasse.Ciò significa che il metodo della sottoclasse che viene scritto sopraquello della superclasse deve avere lo stesso nome e la stessa lista di parametri di quello della superclasse.

Per esempio: using System;public class Complex{

private int real; public int Real

{ get { return real; } }

private int imaginary; public int Imaginary { get { return imaginary; } }

public Complex(int real, int imaginary) { this.real = real; this.imaginary = imaginary; }

public static Complex operator +(Complex c1, Complex c2)

{ return new Complex(c1.Real+ c2.Real, c1.Imaginary +c2.Imaginary); }

public override string ToString() { return (String.Format("{0} + {1}i", real, imaginary)); }} Nell’esempio di cui sopra è stata estesa l’implementazione dell’ope-ratore + nella classe Complex . Questa classe possiede un metodo

sovrascritto denominato “ToString”, che sovrascrive l’implementa-zione per default del metodo standard “ToString” per supportare lacorretta conversione in stringa di un numero complesso.

Complex num1 = new Complex(5, 7);Complex num2 = new Complex(3, 8);

// Somma due numeri complessi utilizzando l’operatore +sovraccaricato

Complex sum = num1 + num2;

// Stampa i numeri e la loro somma utilizzando il metodo ToStringsovrascritto

Console.WriteLine("({0}) + ({1}) = {2}", num1, num2, sum);Console.ReadLine();