Programmazione orientata agli oggetti

ISTITUTO TECNICO INDUSTRIALE “VILLAGGIO DEI RAGAZZI” MADDALONI

1

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Programmazione Orientata agli Oggetti

Dispensa curata dal Prof. Evangelista della Ventura versione n.3 del 05/11/06

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

1

SOMMARIO 1

SOMMARIO...............................................................................................................................................................2

2

INTRODUZIONE ......................................................................................................................................................3

3

PENSARE IN TERMINI DI OGGETTI ..................................................................................................................5

4

LE CARATTERISTICE DELLA OOP....................................................................................................................8 4.1 4.2 4.3 4.4 4.5

5

INCAPSULAMENTO ................................................................................................................................................8 EREDITARIETÀ ......................................................................................................................................................9 POLIMORFISMO ...................................................................................................................................................10 SCAMBIO DI MESSAGGI .......................................................................................................................................10 CONCLUSIONE ....................................................................................................................................................11

REALIZZARE CLASSI E OGGETTI IN VISUAL BASIC ................................................................................13 5.1 LA CLASSE FRAZIONE .........................................................................................................................................14 5.1.1 Fase di analisi...........................................................................................................................................14 5.1.2 Definizione del nucleo della classe ..........................................................................................................15 5.1.3 Definizione dell’interfaccia della classe ...................................................................................................15 5.1.4 Implementazione della classe Frazione ....................................................................................................16 5.1.5 La dichiarazione degli attributi.................................................................................................................17 5.1.6 La costruzione delle Property ...................................................................................................................17 5.1.7 La costruzione dei metodi .........................................................................................................................18 5.1.8 I costruttori ...............................................................................................................................................19 5.1.9 I metodi di gestione ...................................................................................................................................19 5.1.10 L'implementazione di metodi privati .........................................................................................................20 5.1.11 Uso di istanze della classe Frazione .........................................................................................................20 5.2 LA CLASSE ORARIO ............................................................................................................................................21 5.2.1 Fase di analisi...........................................................................................................................................21 5.2.2 Definizione del nucleo della classe ..........................................................................................................21 5.2.3 Definizione dell’interfaccia della classe ...................................................................................................22 5.2.4 La dichiarazione degli attributi.................................................................................................................22 5.2.5 La costruzione delle Property ...................................................................................................................23 5.2.6 I costruttori ...............................................................................................................................................24 5.2.7 I metodi di gestione ...................................................................................................................................24 5.2.8 L'implementazione di metodi privati .........................................................................................................25 5.2.9 Uso di istanze della classe Orario ............................................................................................................25

6

BIBLIOGRAFIA ......................................................................................................................................................27

PROF. DELLA VENTURA EVANGELISTA

2

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

2 INTRODUZIONE La programmazione orientata agli oggetti o, più sinteticamente, OOP (Object Oriented Programming) è un modo diverso da quello classico di considerare la programmazione dei computer.

Quello che cambia fondamentalmente con la OOP è il modo di operare con i dati. Per intenderci facciamo questo esempio: Si supponga di poter aprire porte e finestre attraverso comandi vocali.

Ci sono due metodi fondamentali per interagire con le cose: Il primo metodo specifica prima l'azione, poi la cosa (l'oggetto) sulla quale eseguire l'azione: Aprire: Finestra.

Se poi volete passare alla porta, abbiamo un messaggio simile: Aprire: Porta Ma c'è un altro metodo: proviamo a dire prima l'oggetto e poi l'azione che si vuole compiere su questo oggetto: Finestra: Aprire

Sembra un passaggio da poco, ma abbiamo spostato l'obiettivo dalle azioni agli oggetti.

Essere incentrato sulle azioni, sulle funzioni, sulle operazioni è un approccio classico dei calcolatori.

Dopotutto, il linguaggio macchina dei calcolatori è effettivamente qualcosa del tipo: indicazione dell'operazione, dati sui quali l'operazione deve essere eseguita.

Tutta la programmazione strutturata procedurale è impostata in questo modo: • • •

prima elenco tutti i dati necessari e poi scrivo tutte le operazioni necessarie a modificare questi dati per ottenere i risultati; Con la metodologia TopDown si ragiona in termini di funzionalità, vedendo il problema come un insieme di azioni scomponibili in azioni più semplici Quando si richiama una funzione si premette l’azione ai dati cioè si scrive: nomefunzione(parametro1, parametro2).

Supponiamo che il problema sia di leggere, ordinare e stampare in insieme di dati (ad esempio, una lista di indirizzi).

Esiste allora la struttura dati generali (es. un array di stringhe contenenti gli indirizzi) e tre moduli funzionali separati, uno per la lettura dei dati ed il riempimento della struttura, uno per effettuare l'ordinamento di questi dati, uno per la stampa in bella copia o presentazione dei dati.

PROF. DELLA VENTURA EVANGELISTA

3

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Ognuno di questi tre moduli funzionali può essere diviso in altri moduli, ad esempio la presentazione dei dati può avvenire secondo diverse modalità, a video e a stampa; ogni tipo di presentazione è svolto da un separato modulo funzionale.

Quando si parla della programmazione procedurale, si citano come vantaggi: •

l’eliminazione di stesso codice ripetuto più volte in uno stesso programma;

•

la riusabilità dei sottoprogrammi creati all’interno di altri programmi;

•

la facilità di manutenzione del codice.

Niente di più vero se confrontato con la costruzione di un unico blocco di programma che contiene tutte le istruzioni necessarie a svolgere il suo compito!

Questi metodi procedurali, estremamente potenti, efficaci e "naturali" (per il processore), entrano in difficoltà di fronte a questioni di stampo "ingegneristico": l'adattabilità a mutate condizioni e la riusabilità delle funzioni.

Difatti cosa succede quando si aggiungono nuovi dati che le funzioni precedentemente create non prevedevano?

Nella migliore delle ipotesi devo riscrivere una parte delle funzioni, aggiungere parametri nelle loro dichiarazioni, rendere la funzione esaustiva rispetto ai nuovi dati, verificare l’interfacciamento tra le varie funzioni quando si scambiano i nuovi dati, ecc.. Tradotto: tanto, ma tanto lavoro in più non previsto!

Il disegno strutturato forza una struttura gerarchica top-down nel sistema con un oggetto che è al top: il programma principale. Ma i sistemi reali non hanno un top! Quale sarebbe, infatti, il top di un foglio elettronico? Quindi, il metodo di progettazione top down non funziona.

Ci sono molti motivi per affermare questo, uno fra tutti è che la descrizione di complessi sistemi non è gerarchica.

I sistemi hanno la necessità di collaborare, le parti che compongono un sistema hanno necessità di scambiarsi informazioni semplici, ma indispensabili per il funzionamento dello stesso sistema.

Ad esempio, il “sistema ascensore” deve poter interagire con la persona per poter funzionare: nessun ascensore si muove se non pigiamo il tasto al piano. Quindi, è più facile descriverlo attraverso uno scambio di messaggi fra alcune entità o attori del sistema (es. persona e ascensore) che non attraverso una gerarchia.

Negli anni ’70, parallelamente a questa scuola di pensiero se ne sviluppava un'altra, all'inizio un po' "sotterraneamente" e solo negli ambienti accademici e poi con diffusione sempre maggiore: si proponeva la scuola della programmazione orientata agli oggetti, in cui il punto centrale del discorso è l'oggetto, inteso come un ente software non meglio definito con alcune importanti caratteristiche: auto-contenuto, disponibile al colloquio e ad essere modificato senza sforzo eccessivo.

Un oggetto è auto-contenuto in quanto contiene al suo interno (incapsula, si dice) sia i dati sia le operazioni che su questi dati operano. Un oggetto è quindi un ente software non semplicemente passivo, come può esserlo un numero, ma qualcosa un po' più attivo, un numero in grado di eseguire da solo le operazioni che interessano.

Per chi ha imparato a programmare con l'approccio procedurale, la OOP all'inizio appare un po' bizzarra. Ma poi, una volta compresa, diventa molto più naturale. E comunque alcuni concetti alla base della OOP sono indispensabili anche in ambito procedurale per essere un buon programmatore.

PROF. DELLA VENTURA EVANGELISTA

4

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

3 PENSARE IN TERMINI DI OGGETTI Con la OOP la scomposizione non si basa più sull'operazione da eseguire, ma sull'oggetto, inteso come modello dell'entità sulla quale si opera.

Il programma è adesso costituito da un insieme di entità interagenti, ciascuna provvista di un struttura dati e dell'insieme di metodi adatti a manipolare quella struttura dati. Questi metodi sono inoltre l'unico modo in cui è possibile interagire con l'oggetto.

Ciascun oggetto dunque incapsula i propri dati e ne difende l'accesso diretto da parte dell'esterno: i cambiamenti del mondo esterno non influenzano i dati all'interno e, viceversa, i dati interni non influenzano i dati esterni.

Ne segue una netta separazione tra l'interno e l'esterno che permette di recuperare i due punti deboli dell'approccio procedurale. Modifiche anche pesanti di strutture dati non hanno impatto sul resto del sistema, una volta garantita l'uniformità di comportamento dell'oggetto. A questo punto, per utilizzare un oggetto, basta sapere solamente quali sono le operazioni che si possono svolgere su di esso per poterlo utilizzare in contesti anche molto diversi tra loro.

La OOP è un modo diverso di pensare e di progettare sistemi. Non si contrappone totalmente al metodo procedurale (un singolo oggetto, alla fin fine, si costruisce con un approccio procedurale), ma è un metodo alternativo per la realizzazione di programmi complessi. Del resto, scomporre i problemi in oggetti e poi questi oggetti in oggetti più semplici è più vicino al modo in cui l'essere umano interagisce con il mondo reale, per cui la OOP dovrebbe essere una strategia di risoluzione dei problemi più semplice e naturale.

In fin dei conti, la nostra lingua parla per soggetto e predicato, ovvero per oggetto ed operazione svolta o subita da questo oggetto. È il soggetto (informaticamente, l'oggetto) è la base di ogni discorso.

La OOP non si limita a modificare l'oggetto della scomposizione: l'uso degli oggetti presenta molte altre caratteristiche interessanti che facilitano le metodologie di programmazione.

Per parlare di oggetti dobbiamo pensare in termini di oggetti. Per fortuna gli uomini pensano in termini di oggetti, quindi non sarà un grosso sforzo provarci.

Guardatevi intorno: dove si poserà il vostro sguardo lì troverete oggetti. Persone, animali, piante, computer, quaderni, etc. Abbiamo la capacità di astrazione che ci consente di vedere dei pixel (punti luminosi) su uno schermo come oggetti, persone, animali o cose, piuttosto che come puntini colorati.

Possiamo pensare in termini di spiagge anzichè di granelli di sabbia ed in termini di foreste anzichè di alberi.

Possiamo suddividere gli oggetti in due grandi categorie: oggetti animati e inanimati. I primi sono vivi, si muovono ed eseguono azioni, al contrario dei secondi. Un libro rimane sul tavolo!

Tuttavia, entrambi gli oggetti hanno una cosa in comune: hanno degli attributi, come la dimensione, la forma il colore ed il peso.

Inoltre, hanno tutti dei comportamenti (metodi): una palla rotola, rimbalza si gonfia e si sgonfia; un gatto miagola, dorme, fa le fusa, cammina e corre; un’automobile accelera, frena e svolta; un asciugamano asciuga ed assorbe l’acqua.

Gli esseri umani imparano molte cose dagli oggetti, studiando i loro attributi e osservandone i comportamenti. Avete mai visto un bambino come osserva attentamente un oggetto? Vi siete mai chiesti perché? Sta pensando in termini di oggetti!

PROF. DELLA VENTURA EVANGELISTA

5

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Oggetti diversi possono avere attributi molto simili. Ad esempio, si può fare un confronto tra adulti e bambini o tra esseri umani e scimmie. Automobili, autocarri e pattini a rotelle hanno molto in comune. Gli oggetti sono delle entità dinamiche.

Prendiamo l’esempio dell’oggetto Automobile I suoi attributi possono essere: • • • • • •

Il colore La velocità Il numero di porte Il tipo di carburante La marcia inserita …

I metodi che l’oggetto può compiere possono essere: • • • • • •

Avvia Arresta Accelera Cambia marcia Rifornisci carburante …

Oppure prendiamo l’oggetto Televisore I suoi attributi possono essere: • • • • • •

Dimensione Canali disponibili Volume Canale selezionato Luminosità …

I metodi che l’oggetto può compiere possono essere: • • • • • •

Accendi Spegni Cambia canale Alza il volume Diminuisci la luminosità …

Quando un programma orientato agli oggetti è in esecuzione possono coesistere molti oggetti della stessa specie.

Ad esempio, nel caso di un foglio elettronico ogni cella è rappresentata da un oggetto. Tutti gli oggetti della stessa specie appartengono ad una singola classe.

PROF. DELLA VENTURA EVANGELISTA

6

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Per rappresentare un oggetto possiamo utilizzare la notazione UML (Unified Modeling Language)

Auto Caratteristica

Nome dell’oggetto

Colore = blue Velocità = 72

Valore della caratteristica

Porte = 5 Carbur = Diesel

Se in uno stesso programma ho bisogno di più oggetti dello stesso tipo, devo ripetere la costruzione dell’oggetto per ognuno di essi? Non è necessario perché quello che si fa nella OOP è di creare un modello per quel tipo di oggetti che prende il nome di classe.

La classe può essere vista come lo stampo da cui si creano più oggetti. Il concetto di classe è analogo a quello di tipo per le variabili, si dice infatti che l’oggetto è di tipo classe, più precisamente si dice che l’oggetto a1 è una istanza della classe a.

Una classe specifica gli attributi e i metodi che gli oggetti devono avere.

Un oggetto non può esistere se prima non viene creata la classe a cui esso appartiene e due oggetti istanze della stessa classe hanno gli stessi attributi e metodi e si differenziano solo per i valori che agli attributi vengono assegnati.

Anche per la classe si può utilizzare la notazione UML:

Auto

Attributi

Colore Velocità Porte Carburante …

Avviati Accelera Fermati Cambia marcia …

PROF. DELLA VENTURA EVANGELISTA

Nome della classe

Metodi

7

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

4 LE CARATTERISTICE DELLA OOP Un linguaggio orientato agli oggetti ha almeno le seguenti caratteristiche: 1.

Incapsulamento degli oggetti: è basato sul concetto di oggetto reale e deve fornire, quindi, gli strumenti per definire, creare, gestire e distruggere oggetti;

2. Ereditarietà: deve fornire la possibilità di costruire nuove categorie di oggetti, riutilizzando le caratteristiche di altri oggetti e definendone di nuove; 3. Polimorfismo: deve consentire di trattare allo stesso modo (chiamare con lo stesso nome procedure che eseguono lo stesso compito) oggetti differenti e di avere la possibilità di mantenersi abbastanza generici nel farlo (avere oggetti non tipizzati).

4.1 INCAPSULAMENTO La OOP permette di incapsulare i dati (gli attributi) e le funzioni (i comportamenti) in pacchetti detti oggetti: i dati e le funzioni di un oggetto sono intimamente correlati.

Gli oggetti hanno anche la proprietà di tenere nascoste le informazioni (information hiding). Ciò significa che sebbene gli oggetti possano sapere come comunicare tra loro attraverso interfacce (le cose visibili ad altri oggetti sono l'interfaccia) ben definite, non sempre hanno la possibilità di conoscere la struttura interna di altri oggetti: i dettagli della implementazione sono nascosti all’interno di ciascun oggetto.

Le informazioni vengono nascoste (mediante l’incapsulamento) per due motivi: •

Chi usa l’oggetto NON VUOLE sapere come esso è fatto

•

Chi usa l’oggetto NON DEVE sapere come esso è fatto È possibile, infatti, guidare un’automobile senza sapere (e non VOGLIO sapere) come funziona il motore, la trasmissione e i dettagli degli altri sistemi interni.

Un software con licenza è fornito senza il codice sorgente, perché per usarlo non è necessario, anzi non DEVO sapere come è stato scritto perché altrimenti avrei la possibilità di modificarlo.

L'incapsulamento è un'ottima cosa perché limita l'effetto del cambiamento. In altre parole la struttura interna di un oggetto può cambiare drasticamente, ma se l'interfaccia rimane la stessa gli altri oggetti non ne saranno influenzati.

Un oggetto può essere rappresentato come una sfera con un guscio sul quale è definita l’interfaccia ed un nucleo che contiene tutto ciò che non può essere accessibile dall’esterno:

PROF. DELLA VENTURA EVANGELISTA

8

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Nucleo (Sezione privata)

Dimensione Volume Canale selez.

Luminosità …

Implementazione di tutti i metodi

Interfaccia (Sezione pubblica)

4.2 EREDITARIETÀ L'ereditarietà (inheritance) è il meccanismo per la creazione di nuove classi estendendo ed adattando vecchie classi.

Un oggetto della classe automobile decappottabile ha le stesse caratteristiche della classe automobile, ma il suo tetto si può aprire e chiudere.

La classe sveglia è come la classe orologio con una funzionalità e degli attributi in più.

La classe da cui si parte viene chiamata classe base, mentre la classe che si ottiene agiungendo e/o modificando attributi e metodi si chiama classe derivata. Si dice quindi che la classe derivata eredita attributi e metodi dalla classe base.

Se una classe derivata eredita da una sola classe base, allora si parla di ereditarietà singola.

Graficamente l’ereditarietà singola viene rappresentata nel seguente modo: OROLOGIO SVEGLIA

In alcuni casi accade che si voglia costruire una classe partendo da più di una classe. In tal caso si parla di ereditarietà multipla, cioè la classe derivata eredita attributi e metodi da più classi base.

La classe radiosveglia può essere vista come una classe derivata dalle classi radio e sveglia.

Graficamente l’ereditarietà multipla viene rappresentata nel seguente modo: PROF. DELLA VENTURA EVANGELISTA

9

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

SVEGLIA

RADIO

RADIOSVEGLIA

Ogni classe derivata, infine, sia ben chiaro, oltre ad ereditare tutti gli attributi e metodi delle classi basi, può contenere ulteriori attributi e metodi creati appositamente ed essa stessa può diventare una classe base per altre classi derivate, ottenendo quella che viene anche chiamata gerarchia delle classi.

OROLOGIO SVEGLIA

RADIO

RADIOSVEGLIA

4.3 POLIMORFISMO Il polimorfismo, che significa più forme, è una caratteristica della OOP che permette di ridefinire, all’interno della stessa classe e tra classi derivate da una classe base, dei metodi per meglio adattarsi alle necessità della classe in questione.

Quando all’interno della stessa classe si ridefiniscono dei metodi si parla di overloading, mentre quando i metodi vengono ridefiniti tra classe base e classe derivata si parla di overriding.

Facciamo un esempio di overloading: In un’auto la chiusura delle portiere potrebbe avvenire sia utilizzando la chiave, sia utilizzando un telecomando: quindi avrei due metodi che si chiamerebbero chiudi, ma cambiano le azioni compiute e cioè l’implementazione di tali due metodi.

L’overriding è una possibilità offerta dall’ereditarietà di poter ridefinire, all’interno di una classe derivata, dei metodi già implementati nella classe base.

Esempio: l’auto ed una moto possono essere due classi derivate dalla stessa classe base veicolo a motore; il metodo accelera esiste nella classe veicolo a motore ed anche in entrambe le classi derivate. Quello che cambia è come (implementazione) si accelera: nell’auto con un pedale, nella moto con una manopola.

La presenza del polimorfismo e della ridefinizione del metodo richiede che i linguaggi di programmazione orientati agli oggetti usino il dynamic binding. Il dynamic binding significa che l'associazione fra la chiamata di un metodo ed il codice eseguito deve essere fatta a run-time.

4.4 SCAMBIO DI MESSAGGI Ora avendo un'idea di cosa sia un oggetto, classe, ereditarietà, polimorfismo e dynamic binding, chiediamoci: CHE COSA E' UN PROGRAMMA PENSATO IN TERMINI DI OGGETTI? Un Object Oriented Program (OOP) è una collezione di oggetti che attivano metodi per calcolare la risposta. Usualmente un oggetto viene attivato nel punto in cui comincia la sua esecuzione, ma PROF. DELLA VENTURA EVANGELISTA

10

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

questa scelta è arbitraria. In principio l'esecuzione può partire da ogni oggetto, questo significa che non esiste nessuna main-line.

Ma come questi numerosi oggetti possono comunicare tra loro ed attivare i relativi metodi? Bene, si utilizza una tecnica nota come scambio di messaggi.

In ogni scambio di messaggio un oggetto può richiedere ad un altro di: •

Cambiare il suo stato

•

Restituire un’informazione

•

Attivare una funzionalità

Esistono tre parti essenziali in un messaggio: •

Destinatario: l’oggetto a cui il messaggio è indirizzato

•

Selettore: il metodo o proprietà dell’oggetto che si vuole attivare

•

Elenco di argomenti: i parametri da passare al metodo o proprietà per attivare il metodo

Riprendendo l’esempio precedente di un oggetto auto si potrebbe considerare il seguente messaggio: Auto_1.accelera(10)

In questo caso l’oggetto Auto_1 riceve il messaggio e verifica se esiste un metodo o proprietà corrispondente al selettore accelera e con lo stesso numero di argomenti, in questo caso un solo numero intero (10).

Se tale metodo o proprietà esiste viene eseguito il codice associato al metodo (in questo caso cambiare la velocità incrementandola di 10).

Attenzione: Il messaggio ed il metodo o proprietà NON sono la stessa cosa!

La differenza tra messaggio e metodo è la stessa che esiste tra chiamata a funzione e definizione di funzione.

4.5 CONCLUSIONE L'introduzione di oggetti, classi, ereditarietà polimorfismo e dynamic binding nella programmazione rappresenta un tentativo per risolvere alcuni dei più difficili problemi dello sviluppo del software.

Classi ed oggetti potrebbero diventare l'equivalente delle componenti standard intercambiabili, per cui scrivere un programma consisterebbe nella selezione delle parti da un catalogo e nel collegamento fra queste.

Si pensi al miglioramento della qualità ottenibile dal momento che il software sarebbe costruito da parti standard che sono state già testate in molti sistemi. L'ereditarietà e il dynamic binding consentono a noi di personalizzare le parti esistenti nel caso in cui queste non soddisfino a pieno i requisiti imposti dal sistema.

Ma anche in caso di personalizzazione deve essere scritto solo il codice che implementa le nuove funzionalità: quando i programmatori scrivono di meno, sbagliano di meno e ci vuole meno tempo per correggere gli errori; di conseguenza il sistema viene consegnato prima a un costo inferiore.

PROF. DELLA VENTURA EVANGELISTA

11

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Inoltre, la programmazione orientata agli oggetti ci dà un modo più naturale ed intuitivo di pensare al processo della progettazione del software, modellando gli oggetti del mondo reale, i loro attributi ed il loro comportamento.

PROF. DELLA VENTURA EVANGELISTA

12

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

5 REALIZZARE CLASSI E OGGETTI IN VISUAL BASIC Dopo aver visto nel capitolo precedente tutti i concetti teorici alla base della programmazione ad oggetti, vediamo applicarli in pratica e cioè come sia possibile costruire degli oggetti in Visual Basic.

In questo linguaggio, esempi tipici ed evidenti di oggetti sono i controlli che abitualmente inseriamo su un form: pulsanti, caselle di testo, checkbox e così via. Ma anche lo stesso form e l’applicazione che si va a realizzare sono oggetti, così come il font di un testo, un database, un documento Word o un grafico di Excel.

Fondamentalmente, un oggetto in Visual Basic è rappresentato da una classe che ne definisce le caratteristiche: in particolare, la classe di un oggetto definisce le sue proprietà, i suoi metodi e i suoi eventi.

Per rendersi conto in modo semplice ed efficace di cosa ciò significhi, basta dare un'occhiata al "visualizzatore oggetti" (o "object browser"), che potete aprire premendo F2 dall'IDE o tramite il menù "visualizza"; se date un'occhiata alle voci con l'icona del Modulo di classe vi accorgerete che essa è associata non solo ai normali controlli visibili sulla casella degli strumenti, ma anche all'oggetto ErrObject, all'oggetto StdFont, all'oggetto App ecc.

Tutti questi oggetti hanno un'interfaccia (un insieme di metodi, eventi, proprietà) definiti nelle rispettive classi, che permettono di manipolare le istanze di tali classi, cioè di agire sullo stato dell’oggetto ed interagire con esso.

Ogni istanza di una classe, un oggetto, è indipendente dalle altre, così che in uno stesso form è possibile inserire ad esempio quattro TextBox senza che debba esserci alcuna reciproca connessione tra di essi: ognuna di queste istanze è gestibile in modo del tutto indipendente dalle altre, ma la loro interfaccia è comune perché è definita per tutte dalla medesima classe TextBox. L'indipendenza reciproca delle istanze, naturalmente, non impedisce che esse possano interagire tra di loro e con altri tipi di oggetti.

PROF. DELLA VENTURA EVANGELISTA

13

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

La classe, oltre a contenere il codice per la gestione dell'interfaccia, contiene anche dati da esporre, cioè informazioni da mostrare e da modificare per chi usa l’oggetto definendo quelle che vengono chiamate proprietà; tali dati ovviamente sono replicati per ognuna delle sue istanze.

La costruzione delle classi deve essere realizzata cercando di implementarle con un tale grado di generalità da poterle eventualmente riutilizzare in altre occasioni, costruendo quelle che vengono chiamate classi base, nelle quali vengono implementate le componenti comuni ad un considerevole numero di oggetti, sfruttando le proprietà di incapsulamento e di information hiding.

Nel seguito di questa unità didattica, per cogliere le difficoltà insite in questa attività progettuale e per rendere più comprensibili le diverse fasi di sviluppo del software, condurremo la trattazione parallelamente alla gestione di due esempi, uno più semplice ed uno leggermente più complesso facendo riferimento ad oggetti che dovrebbero essere noti a tutti: la frazione e l'orario.

5.1

LA CLASSE FRAZIONE

5.1.1 FASE DI ANALISI La prima fase di analisi è mirata all'individuazione delle specifiche generali della classe che si intende produrre.

Il progetto di un prodotto software nasce da un'analisi accurata delle esigenze dell'utente che dovrà utilizzare il programma; allo stesso modo, durante la progettazione di una classe, la prima fase di analisi dovrà essere mirata a focalizzare le esigenze del programmatore committente, così da realizzare una classe della quale quest'ultimo possa poi utilizzare gli oggetti in modo ampio e circostanziato all'interno dei propri programmi.

Nel nostro caso specifico, immaginiamo di aver appurato, dopo un colloquio con il committente, quanto segue: a) La frazione deve essere espressa nella forma classica di numeratore e denominatore; b) i valori dei due termini devono essere interi; c) si vuole poi poter conoscere il valore della frazione espresso come numero reale d) l’unica operazione possibile sulla frazione sia il prodotto per un numero intero, senza ulteriori semplificazioni.

Esempio:

PROF. DELLA VENTURA EVANGELISTA

3 18 ⋅6 = 2 2

14

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

5.1.2

DEFINIZIONE DEL

NUCLEO DELLA CLASSE

Occorre a questo punto individuare la struttura astratta sulla quale costruire la classe di cui il committente utilizzerà diverse istanze.

Per prima cosa è necessario definire quali saranno gli attributi privati che comporranno la classe.

Normalmente tali attributi compongono il nucleo di una classe, cioè quella parte non direttamente accessibile dall’esterno e che pertanto ognuno può realizzare come ritiene più opportuno: quello che però è poi importante è definire un interfaccia che rispecchi appieno le richieste del committente, cioè che corrisponda all’idea che il committente ha dell’oggetto stesso.

Nel nostro esempio, definiremo due attributi distinti, uno che conservi il valore del numeratore ed un altro per il denominatore.

Un’altra possibilità poteva essere quella di utilizzare un array con due soli elementi, dove nel primo avremmo messo il numeratore e nel secondo il denominatore.

La scelta tra una soluzione o l’altra non deve influire su come il committente debba usare la nostra classe, cioè egli deve usarla secondo la definizione della frazione data nella fase di analisi.

Frazione - Num - Den

5.1.3 DEFINIZIONE DELL’INTERFACCIA DELLA CLASSE Una volta definito il nucleo della classe si passa alla definizione dell’interfaccia, cioè di quella parte della classe che rappresenta, all’esterno, la classe.

In tale fase è necessario rispondere in modo completo alle richieste avanzate dal committente in fase di analisi del problema.

Va ricordato che il numero ed il tipo di queste funzionalità pubbliche, che in Visual Basic prendono il nome di proprietà e metodi, definiscono la completezza e l'efficienza della classe, poiché descrivono il livello di manipolabilità della stessa e possono essere considerati indipendenti da quale sia stata la definizione del nucleo e cioè da quali siano stati gli attributi e funzionalità private definiti.

Questo perché tale interfaccia è come il committente vede l’oggetto; quello che egli non vede, per l’information hiding precedentemente definita, è l’implementazione di tali funzionalità che ovviamente dovrà necessariamente fare riferimento alla definizione del nucleo.

A proposito delle proprietà e dei metodi è necessario fare delle precisazioni: •

Le proprietà vengono utilizzate normalmente per modificare o leggere lo stato di un oggetto, cioè assegnare o restituire il valore degli attributi, che devono essere privati.

•

Per leggere un valore dello stato dell’oggetto si utilizza la Property Get con la seguente sintassi: Public Property Get Nomeproprietà(…) as tipo

PROF. DELLA VENTURA EVANGELISTA

15

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

•

Per assegnare un valore ad un attributo dell’oggetto si utilizza la Property Let con la seguente sintassi: Public Property Let Nomeproprietà(…)

•

Quando le property Get e Let fanno riferimento alla stessa proprietà, bisogna utilizzare lo stesso nome Nomeproprietà.

•

Possono esistere proprietà di sola lettura, la Property Get, senza la necessità della corrispondente proprietà di scrittura, la Property Let.

•

Non esistono proprietà private, cioè definite all’interno del nucleo e non disponibili verso l’esterno: non avrebbero senso.

•

I metodi sono definiti come classiche funzioni o procedure ed hanno come scopo quello di far compiere delle azioni all’oggetto come anche interagire con altri oggetti.

•

I metodi possono essere sia pubblici che privati: i metodi privati non possono essere richiamati da chi utilizza l’oggetto, ma vengono richiamati solo da altri metodi e dalle proprietà.

È necessario quindi mettere a disposizione delle funzionalità che permettano di assegnare dei valori agli attributi dell’oggetto; di leggere i valori degli attributi dell’oggetto; di eseguire dell’azioni sull’oggetto; di interagire con altri oggetti.

Nel nostro caso specifico, risulta abbastanza semplice individuare che la classe deve possedere: • • •

Due proprietà che permettono di restituire ed assegnare valori al numeratore ed al denominatore Una proprietà che restituisca il valore reale della frazione Un metodo che permetta di calcolare il prodotto della frazione per un numero intero Un metodo che permetta di visualizzare la frazione nella forma Num/Den.

Frazione - Num - Den

+ (PGet) Numeratore + (PGet) Denominatore + (PLet) Numeratore + (PLet) Denominatore + (PGet) ValoreReale + (M) Prodotto + (M) Mostra

5.1.4 IMPLEMENTAZIONE DELLA CLASSE FRAZIONE Una volta terminata la progettazione della classe, occorre procedere alla sua formalizzazione in base alla sintassi prevista dal linguaggio.

PROF. DELLA VENTURA EVANGELISTA

16

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

La creazione di una classe in Visual Basic comporta l'inserimento nel progetto di un modulo di classe che conterrà il codice relativo alla classe stessa.

Per inserire nel progetto un Modulo di classe occorre: selezionare dal menu Progetto la voce Inserisci Modulo di classe e, successivamente, assegnare alla proprietà Name del Modulo il nome della classe.

La struttura di un Modulo di classe è sufficientemente standardizzata e prevede nell’ordine: 1. L'inserimento dell'opzione Option Explicit che permette di assicurarsi che tutte le variabili del Modulo siano necessariamente dichiarate, in modo da evitare errori dovuti alla battitura errata di nomi di variabili all'interno del codice; 2. la dichiarazione di tutte le variabili che compongono gli attributi privati della classe; 3. L’implementazione dei metodi privati (procedure e funzioni) 4. L’implementazione delle Property 5. L’implementazione dei metodi pubblici della classe.

5.1.5 LA DICHIARAZIONE DEGLI ATTRIBUTI La dichiarazione di un attributo di una classe è del tutto analoga a quella di una variabile in un Modulo di form.

Dato però che uno degli obiettivi della programmazione orientata agli oggetti è quello di mascherare la struttura interna dell'oggetto, in generale, si preferisce definire l'insieme dei dati all'interno della sezione privata usando la parola chiave Dim, lasciando ai metodi e alle procedure Property il compito di rendere disponibile al resto dell'applicazione tali dati.

Nel nostro esempio, dichiareremo due attributi di tipo Integer per contenere il numeratore ed il denominatore.

Option Explicit Dim Num as Integer Dim Den as Integer

5.1.6 LA COSTRUZIONE DELLE PROPERTY La sintassi da utilizzare per realizzare una procedura che consente di assegnare un valore ad una proprietà dell'oggetto è: Public Property Let nome della proprietà (ByVal Valore As tipo) …

End Property

La struttura di una Property Let è simile a quella di una normale procedura e normalmente contiene il codice per verificare la validità del parametro inserito e le eventuali istruzioni per adattare il parametro alla reale struttura interna dell'oggetto.

Per il nostro esempio avremo due Property Let: Public Property Let Numeratore(ByVal N As Integer) Num = N PROF. DELLA VENTURA EVANGELISTA

17

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

End Property Public Property Let Denominatore(ByVal D As Integer) If D<>0 then Den = D End Property

La sintassi da utilizzare per realizzare una property che consente di leggere il valore di una proprietà è simile a quella di una funzione: Public Property Get nome della proprietà () As Tipo …

End Property

Nel nostro esempio: Public Property Get Numeratore() As Integer Numeratore = Num End Property Public Property Get Denominatore() As Integer Denominatore = Den End Property Public Property Get ValoreReale() As Single ValoreReale= Num/Den End Property

Esiste anche un altro tipo di routine per modificare una proprietà: si tratta della Property Set, che va utilizzata qualora la proprietà faccia riferimento a un oggetto; questo accade perché Visual Basic richiede di utilizzare l'istruzione Set per assegnare un riferimento a un oggetto, mentre per i tipi di dati fondamentali non è richiesta alcuna istruzione particolare (l'istruzione Let era necessaria nelle vecchie versioni del basic ed è stata mantenuta per compatibilità).

Per quale motivo è opportuno utilizzare una coppia di routine Property anziché dichiarare a livello di modulo una variabile pubblica Denominatore?

Anche questo secondo metodo consentirebbe di leggere e scrivere a proprio piacimento il valore della variabile; ma il problema è proprio questo: usando una variabile pubblica non ci sarebbe alcun controllo sulla correttezza dell'uso della proprietà Denominatore e quindi in questo caso uno potrebbe assegnare anche il valore zero al denominatore.

Inoltre, con una variabile pubblica non sarebbe possibile implementare una proprietà di sola lettura come per ValoreReale; cosa che risulta invece molto semplice con le routine property: basta infatti cancellare la routine Property Let (o Property Set).

5.1.7 LA COSTRUZIONE DEI METODI Una volta individuate la tipologia delle funzioni di interfaccia pubblica per la classe in oggetto, per ognuna di esse occorrerà definire esplicitamente i parametri di scambio con il mondo esterno all’oggetto e le specifiche funzionalità.

In generale, occorre prevedere nell'interfaccia pubblica i seguenti tipi di funzioni:

PROF. DELLA VENTURA EVANGELISTA

18

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

•

funzioni di inizializzazione, che chiameremo costruttori, che è utile richiamare ogni volta che viene definita una variabile del tipo associato alla classe per inizializzare correttamente tutte le variabili private;

•

i metodi di gestione dell'oggetto, legati strettamente alla tipologia della classe in esame.

5.1.8 I COSTRUTTORI Esiste un particolare costruttore adibito alla inizializzazione automatica di un oggetto. Esso si differenzia da un normale metodo poiché non deve essere esplicitamente richiamato nel programma, ma viene invocata automaticamente ogni volta che si procede alla definizione di un nuovo oggetto appartenente alla classe.

Questo metodo è infatti la risposta all'evento Inizialize associato alla classe.

Sotto molti aspetti, comunque, il costruttore si comporta come una qualsiasi altra funzione membro della classe, poiché oltre a inizializzare i campi dati dell’oggetto, può eseguire altre operazioni.

Nel nostro esempio, il costruttore implicito inizializzerà ad uno i due attributi privati.

Private Sub Class_Initialize () Num = 1 Den = 1 End Sub

Il costruttore implicito è molto utile perché permette di inizializzare tutti gli attributi che si vuole in un colpo solo, e cioè alla definizione dell’oggetto.

Questa tecnica a volte però non basta perché quando si hanno molti oggetti, accade piuttosto spesso che questi vadano inizializzati con valori differenti per i diversi attributi e quindi è necessario richiamare tutte le property necessarie. Inoltre se ci sono attributi che non prevedono property pubbliche non è più possibile modificarli una volta definito l’oggetto.

La soluzione è data dalla possibilità di definire un metodo particolare (costruttore generico) che permette di inizializzare con valori assegnati attraverso parametri gli attributi privati di un oggetto.

Nel nostro esempio un costruttore generico avrà la forma: Public Sub Inizializza (ByVal N As Integer,ByVal D As Integer) Num = N Den = D End Sub

5.1.9 I METODI DI GESTIONE Una volta definiti i costruttori, si passa all'implementazione dei metodi pubblici, che forniscono al programmatore tutte le funzionalità associate all'oggetto.

Di conseguenza, le subroutine e le funzioni che costituiscono i metodi della classe dovranno obbligatoriamente essere definite Public in modo da poter essere richiamate dalle applicazioni che utilizzano quel Modulo di classe.

Nel nostro esempio prevediamo due metodi: Il metodo Moltiplica che permette di moltiplicare la frazione per un numero intero, senza effettuare però, per semplicità, alcuna semplificazione ed il metodo Mostra per mostrare la frazione per intero.

PROF. DELLA VENTURA EVANGELISTA

19

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Public Sub Moltiplica(ByVal f As Integer) Num = Num * f End Sub Public Function Mostra() as String Mostra = Str(Num) & "/" & Str(Den) End Function

5.1.10 L'IMPLEMENTAZIONE DI METODI PRIVATI Nel nostro primo esempio non abbiamo previsto metodi privati. Tale argomento verrà affrontato nel prossimo esempio.

5.1.11 USO DI ISTANZE DELLA CLASSE FRAZIONE Per dichiarare una variabile oggetto si utilizza la sintassi Dim nomevariabile As nomedellaclasse

Quando si genera una variabile oggetto in questo modo si crea solamente un riferimento (puntatore) e non un oggetto reale. Di conseguenza, per poterla utilizzare all'interno di un programma richiamandone i metodi pubblici, occorrerà in via preliminare creare l'oggetto vero e proprio mediante l'istruzione: Set nomevariabile = New nomedellaclasse

È possibile sintetizzare le due precedenti istruzioni in questo modo: Dim nomevariabile As New nomedellaclasse

Se nel Modulo di classe è stata inserita la risposta all’evento Initialize, questa verrà attivata subito dopo l'istruzione Set. Successivamente si potranno richiamare metodi e proprietà utilizzando la classica notazione: nomevariabile.nomemetodo

Per esempio, una procedura che confronta due frazioni potrebbe avere la forma: Private Sub Confronta Dim F1 As New Frazione Dim F2 As New Frazione ’Valore reale della prima frazione Dim r1 As Single ’Valore reale della seconda frazione Dim r2 As Single F1.Numeratore=Inputbox(“Inserisci il 1° numeratore”)

PROF. DELLA VENTURA EVANGELISTA

20

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

F1.Denominatore=Inputbox(“Inserisci il 1° denominatore”) F2.Numeratore=Inputbox(“Inserisci il 2° numeratore”) F2.Denominatore=Inputbox(“Inserisci il 2° denominatore”) r1 = F1.ValoreReale r2 = F2.ValoreReale ‘visualizzazione risultato If r1 > r2 Then MsgBox F1.Mostra() & “è maggiore di” & F2.Mostra() Else MsgBox F2.Mostra() & “è maggiore di” & F1.Mostra() End If End Sub

5.2 LA CLASSE ORARIO

5.2.1 FASE DI ANALISI La prima fase di analisi è mirata all'individuazione delle specifiche generali della classe che si intende produrre.

Nel nostro caso specifico, immaginiamo di aver appurato, dopo un colloquio con il committente, quanto segue: a) l’orario deve essere espresso mediante le classiche unità di misura (ore, minuti e secondi); b) le ore devono essere espresse in valori da 0 a 24; c) deve essere possibile il confronto tra due orari.

5.2.2 DEFINIZIONE DEL

NUCLEO DELLA CLASSE

Occorre a questo punto individuare la struttura astratta sulla quale costruire la classe di cui il committente utilizzerà diverse istanze.

Per prima cosa è necessario definire quali saranno gli attributi privati che comporranno la classe.

Nel nostro esempio, si potrebbero definire tre attributi distinti, uno per le ore, un altro per i minuti e l’ultimo per i secondi oppure, e questa è la soluzione che adotteremo, si può definire un unico attributo che esprima l’orario come il numero complessivo di secondi a partire dall’ora zero (00:00:00).

Questa considerazione ovviamente non deve influire su come il committente debba usare la nostra classe, cioè egli deve usarla secondo la definizione dell’orario data nella fase di analisi.

Accade, in alcune situazioni, che sia necessario aggiungere al nucleo anche delle funzionalità, cioè dei metodi privati, che verranno usate solo all’interno della classe e quindi non disponibili sull’interfaccia.

PROF. DELLA VENTURA EVANGELISTA

21

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Orario - Sec

La scelta di un solo attributo comporta la necessità di inserire all’interno del nucleo di due funzioni: una di conversione dei secondi complessivi in ore, minuti e secondi ed un’altra che compia l’operazione inversa.

Ovviamente, essendo nel nucleo, tali funzioni non sono utilizzabili dall’esterno sia per non farle usare impropriamente al committente, sia per non appesantire il compito di chi usa la classe che dovrebbe ricordarsi di richiamarle ogni qualvolta inserisce o vuole visualizzare un orario.

5.2.3 DEFINIZIONE DELL’INTERFACCIA DELLA CLASSE Una volta definito il nucleo della classe si passa alla definizione dell’interfaccia, cioè di quella parte della classe che rappresenta, all’esterno, la classe.

Nel nostro caso specifico, risulta abbastanza semplice individuare che la classe deve possedere almeno le proprietà che permettono di leggere o modificare separatamente i valori delle ore, dei minuti e dei secondi.

Inoltre la classe deve prevedere almeno i metodi in grado di: 1) inizializzare un orario esprimendo le ore i minuti e i secondi; 2) incrementare e decrementare il valore dell’orario; 3) confrontare un orario con un altro; 4) effettuare operazioni di input/output delle proprietà.

Orario - Sec

+ (PGet) Ore + (PGet) Minuti + (PGet) Secondi + (PLet) Ore + (PLet) Minuti + (PLet) Secondi - (M) Converti - (M) Riconverti + (M) Ricevi + (M) Comunica

5.2.4 LA DICHIARAZIONE DEGLI ATTRIBUTI La dichiarazione di un attributo di una classe è del tutto analoga a quella di una variabile in un Modulo di form.

Nel nostro esempio, verrebbe spontaneo dichiarare nella parte privata di Orario tre variabili intere: ore, minuti e secondi. Questo tipo di implementazione, però, non è il più adeguato, poiché PROF. DELLA VENTURA EVANGELISTA

22

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

creerebbe non pochi problemi nella realizzazione degli algoritmi relativi alle operazioni di confronto.

Dunque, anche per rendere più evidente il meccanismo del mascheramento che rende la visione dell'oggetto da parte dell'utente-programmatore indipendenti dalla struttura dati interna, optiamo per una struttura privata formata da un unico attributo di tipo Long di nome Sec, che contiene l’orario espresso esclusivamente in secondi.

Sarà poi compito delle singole funzioni di interfaccia trasformare, di volta in volta, il valore di questa variabile in una terna di valori interi (ore, minuti e secondi) o viceversa.

Option Explicit Dim Sec As Long

5.2.5 LA COSTRUZIONE DELLE PROPERTY A titolo di esempio riportiamo il codice relativo alla procedura per modificare il valore delle ore dell'orario lasciando inalterati minuti e secondi.

Public Property Let Ore(ByVal Nh As Byte) Dim H As Byte Dim M As Byte Dim S As Byte ‘trasformazione del valore di Sec in ore, minuti e secondi ‘mediante la chiamata ad una procedura privata della classe Call Riconverti(H,M,S) ‘modifica del valore delle ore H=Nh ‘trasformazione nel formato privato (solo secondi) ‘mediante una funzione privata della classe Sec= Converti(H,M,S) End Property

La sintassi da utilizzare per realizzare una procedura che consente di leggere il valore di una proprietà è simile a quella di una funzione: Public Property Get nome della proprietà () As Tipo …

End Property

Nel nostro esempio, la Property che restituisce il valore dei minuti è: Public Property Get Minuti() As Byte Dim H As Byte Dim M As Byte Dim S As Byte ‘trasformazione del valore di Sec in ore, minuti e secondi ‘mediante la chiamata a una procedura privata della classe Call Riconverti(H,M,S) ‘restituzione del valore dei minuti PROF. DELLA VENTURA EVANGELISTA

23

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Minuti=M End Property

5.2.6 I COSTRUTTORI Esiste un particolare costruttore adibito alla inizializzazione automatica di un oggetto. Esso si differenzia da un normale metodo poiché non deve essere esplicitamente richiamato nel programma, ma viene invocata automaticamente ogni volta che si procede alla definizione di un nuovo oggetto appartenente alla classe.

Questo metodo è infatti la risposta all'evento Inizialize associato alla classe.

Sotto molti aspetti, comunque, il costruttore si comporta come una qualsiasi altra funzione membro della classe, poiché oltre a inizializzare i campi dati dell’oggetto, può eseguire altre operazioni.

Nel nostro esempio, il costruttore automatico inizializzerà a zero l'unica variabile privata della classe.

Private Sub Class_Initialize () Sec=O End Sub

Più interessante è la possibilità di definire un metodo particolare (costruttore generico) che permette di inizializzare con valori assegnati attraverso parametri le variabili private di un oggetto.

Nel nostro esempio un costruttore generico avrà la forma: Public Sub Inizializza (ByVal H As Byte, Optional ByVal M As Byte =0, Optional ByVal S as Byte =0) Sec = Converti(H,M,S) End Sub

In questo caso, se in fase di inizializzazione di una variabile di tipo Orario verrà fornito solo il valore delle ore, sarà il sistema a inizializzare automaticamente a 0 i minuti ed i secondi (valori di default).

5.2.7 I METODI DI GESTIONE Una volta definiti i costruttori, si passa all'implementazione dei metodi pubblici, che forniscono al programmatore tutte le funzionalità associate all'oggetto.

Nel nostro esempio prevediamo almeno due metodi: Il metodo Ricevi che permette di acquisire i valori dell’orario e il metodo Comunica che visualizza in un MessageBox l’orario.

In particolare, il metodo Ricevi, dopo aver acquisito tramite opportuni InputBox i valori di ore, minuti e secondi, li converte in secondi mediante la funzione privata Converti e memorizza il risultato all'interno dell'unico campo dati.

Public Sub Ricevi () Dim H As Long Dim M As Long Dim S As Long PROF. DELLA VENTURA EVANGELISTA

24

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

‘acquisizione dei valori H = InputBox("Inserire il valore delle ore") M = InputBox("Inserire il valore dei minuti") S = InputBox("Inserire il valore dei secondi") ‘assegnazione alla variabile Sec = Converti(H, M, S) End Sub

Il metodo Comunica, invece, dovrà ricorrere a un'altra funzione di servizio privata (Riconverti) per riportare l’orario nella forma utente prima di visualizzarla.

Public Function Comunica () As String Dim H As Long Dim M As Long Dim S As Long ‘calcolo di ore minuti e secondi Call Riconverti(H, M, S) ‘costruzione della stringa da visualizzare Comunica = Str(H) & ":" & Str(M) & ":" & Str(S) End Function

5.2.8 L'IMPLEMENTAZIONE DI METODI PRIVATI Per concludere l'implementazione della classe si devono, infine, sviluppare i sottoprogrammi privati che, per quanto riguarda la sintassi, hanno esattamente le stesse caratteristiche dei sottoprogrammi tradizionali.

Facendo riferimento alla classe Orario, riportiamo lo sviluppo della funzione Converti.

Private Function Converti(H As Long, M As Long, S As Long) Converti = (H*3600+M*60+S) End Function

Come abbiamo sempre detto, infine, il software deve essere corredato da chiare indicazioni sulle modalità d'uso e sul comportamento degli oggetti in condizioni anomale.

Per esempio, nel caso della classe Orario, si dovrebbero fornire all'utilizzatore informazioni circa il comportamento di un oggetto della classe nel caso in cui si tenti di inizializzarlo con valori negativi o con valori che escano dai limiti previsti o, ancora, quando in fase di conversione si venga a generare un'anomalia di calcolo (divisione per zero, overflow e così via).

5.2.9 USO DI ISTANZE DELLA CLASSE ORARIO Per dichiarare una variabile oggetto si utilizza la sintassi Dim nomevariabile As nomedellaclasse

PROF. DELLA VENTURA EVANGELISTA

25

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

Quando si genera una variabile oggetto in questo modo si crea solamente un riferimento (puntatore) e non un oggetto reale. Di conseguenza, per poterla utilizzare all'interno di un programma richiamandone i metodi pubblici, occorrerà in via preliminare creare l'oggetto vero e proprio mediante l'istruzione: Set nomevariabile = New nomedellaclasse

È possibile sintetizzare le due precedenti istruzioni in questo modo: Dim nomevariabile As New nomedellaclasse

Se nel Modulo di classe è stata inserita la risposta all’evento Initialize, questa verrà attivata subito dopo l'istruzione Set. Successivamente si potranno richiamare metodi e proprietà utilizzando la classica notazione: nomevariabile.nomemetodo

Per esempio, una procedura che confronta due orari potrebbe avere la forma: Private Sub Confronta Dim Or1 As Orario Dim Or1 As Orario ‘istanziazione degli oggetti Set Or1 = New Orario Set Or2 = New Orario ‘acquisizione dei valori Call Or1.Ricevi Call Or2.Ricevi ‘confronta Ris = A.Maggiore(B) ‘visualizzazione risultato If Ris = True Then MsgBox A.Comunica() & “viene dopo “ & B.Comunica() Else MsgBox B.Comunica() & “viene dopo “ & A.Comunica() End If End Sub

PROF. DELLA VENTURA EVANGELISTA

26

PROGRAMMAZIONE ORIENTATA AGLI OGGETTI

6 BIBLIOGRAFIA 1. JACOBSON, G. BOOCH, J. RAMBAUGH, The Unified Modeling Language: User Guide, 1999 2. R. S. PRESSMAN, Principi di Ingegneria del Software, Mc Graw Hill, 1999 3. P. MARESCA, La progettazione del software orientato agli oggetti, Programmazione.it, 2002 4. L. SANDEL, Programmazione Object Oriented, Programmazione.it, 2002 5. GARAVAGLIA, F. PETRACCHI, Visual Basic Programmazione avanzata, Zanichelli, 2001

PROF. DELLA VENTURA EVANGELISTA

27