11 - Introduzione alla Programmazione Orientata agli Oggetti (Object Oriented Programming – OOP)

(1)

11 - Introduzione alla

Programmazione Orientata agli Oggetti (Object Oriented Programming – OOP)

Programmazione e analisi di dati Modulo A: Programmazione in Java

Paolo Milazzo

Dipartimento di Informatica, Universit`a di Pisa http://pages.di.unipi.it/milazzo

milazzo di.unipi.it

Corso di Laurea Magistrale in Informatica Umanistica A.A. 2019/2020

(2)

Sommario

1 Programmazione Orientata agli Oggetti: concetti

2 Programmazione Orientata agli Oggetti: highlights

(3)

Programmazione imperativa (1)

Abbiamo visto come programmare utilizzando i seguenti tipi di dati:

Tipi di dato primitivi(int, double, char, boolean, ecc...) Le stringhe

Gliarray

I programmi fatti fino ad ora consistevano di una sequenza di comandi

strutture di controllo (cicli, scelte condizionali, ecc...) ed eventualmentemetodi ausiliari

che consentivano di manipolare i dati per calcolare il risultato voluto.

Questo modo di programmare prende il nome di

PROGRAMMAZIONE IMPERATIVA

(4)

Programmazione imperativa (2)

Nella programmazione imperativa:

Un programma prevede unostato globale costituito dai valori delle sue variabili

I comandi del programmamodificano lo stato fino a raggiungere uno stato finale(che include il risultato)

(5)

Programmazione imperativa (3)

Ad esempio, il seguente programma (che calcola il prodotto di x e y):

int x =10 , y =3 , p =0;

for (int i =0; i < y ; i ++) p += x ;

ha la seguente dinamica:

(6)

Programmazione orientata agli oggetti (1)

Sebbene sia possibile scrivere programmi interessanti con i tipi di dato visti fino ad ora, spesso i programmi hanno bisogno di manipolare strutture dati che rappresentano pi`u fedelmente le entit`a del mondo reale.

Ad esempio, immaginate di dover scrivere programmi per la gestione di...

Conti bancari: ogni conto bancario ha un proprio saldo, un proprio intestatario, una propria lista di movimenti, ecc...

Dipendenti: ogni dipendente di un’azienda ha una propria matricola, un proprio stipendio, un proprio orario di lavoro, ecc...

Parchi macchine: ogni automobile ha la propria targa, il proprio contachilometri, il proprio storico delle manutenzioni, ecc...

Rettangoli: ogni rettangolo ha la propria base, altezza e posizione nel piano.

Scrivere un programma di questo tipo usando solo interi, array e strighe pu`o diventare abbastanza complicato...

(7)

Programmazione orientata agli oggetti (2)

Notate che ogni entit`a del mondo reale (e.g. il conto bancario) prevede un proprio stato interno (e.g. saldo, ecc...) e delle propriefunzionalit`a (e.g.

versamento, prelievo, ecc...)

Per questo motivo un linguaggio di programmazioneORIENTATO AGLI OGGETTI (tipo Java) fornisce meccanismi per definire nuovi tipi di dato basati sul concetto di classe

Unaclasse definisce un insieme di oggetti(conti bancari, dipendenti, automobili, rettangoli, ecc...).

Un oggetto`e una struttura dotata di:

proprievariabili (che rappresentano il suo stato) propri metodi(che realizzano le sue funzionalit`a)

(8)

Primo esempio di programmazione con oggetti (1)

Scriviamo un programma che usa un conto corrente Consiste di due classi:

UsaConto che contiene il main del programma

ContoCorrente che descrive gli oggettiche rappresentano i conti correnti

p u b l i c c l a s s U s a C o n t o {

p u b l i c s t a t i c v o i d m a i n ( S t r i n g [] a r g s ) {

// c r e a un n u o v o c o n t o c o r r e n t e i n i z i a l i z z a t o con 1 0 0 0 e u r o C o n t o C o r r e n t e cc = new C o n t o C o r r e n t e ( 1 0 0 0 ) ;

// v e r s a 700 e u r o cc . v e r s a ( 7 0 0 ) ;

// fa un po ’ di p r e l i e v i , c o n t r o l l a n d o p r i m a il s a l d o if ( cc . saldo > 2 0 0 ) cc . p r e l e v a ( 2 0 0 ) ;

if ( cc . saldo > 9 0 0 ) cc . p r e l e v a ( 9 0 0 ) ;

S y s t e m . out . p r i n t l n (" S a l d o f i n a l e : " + cc . s a l d o );

} }

(9)

Primo esempio di programmazione con oggetti (2)

p u b l i c c l a s s C o n t o C o r r e n t e {

// v a r i a b i l e che m e m o r i z z a lo s t a t o del c o n t o p u b l i c d o u b l e s a l d o ;

// c o s t r u t t o r e d e l l a c l a s s e

p u b l i c C o n t o C o r r e n t e (d o u b l e s a l d o I n i z i a l e ) { s a l d o = s a l d o I n i z i a l e ;

}

// m e t o d o per il v e r s a m e n t o di s o m m e p u b l i c v o i d v e r s a (d o u b l e s o m m a ) {

s a l d o += s o m m a ; }

// m e t o d o per il p r e l i e v o di s o m m e p u b l i c v o i d p r e l e v a (d o u b l e s o m m a ) {

saldo -= s o m m a ; }

}

(10)

Primo esempio di programmazione con oggetti (3)

Osservazioni:

La classe UsaConto non `e molto diversa dai programmi che abbiamo scritto fino ad ora...

In UsaConto:

I cc.versa() `e una invocazione di un metodo, cc.saldo `e una lettura di una variabile

In ContoCorrente:

I non c’`e il main (ce n’e’ uno solo per tutto il programma)

I c’`e una variabile (saldo) che rappresenta lo stato del conto

I ci sono due metodi (versa() e preleva()) che descrivono le funzionalit`a del conto

I c’e’ un metodo speciale (ContoCorrente()) che inizializza il conto

I il metodo ContoCorrente() `e dettocostruttoree viene richiamato quando si usa il comano new (non prevede tipo di ritorno)

I i metodi e la variabile sonopubblici(public) quindi possono essere usati anche da altre classi (e.g. UsaConto)

I nei metodi non si usa il modificatore static (capiremo pi`u avanti perch´e)

(11)

Primo esempio di programmazione con oggetti (4)

Vediamo ora come gestire pi`u conti correnti

p u b l i c c l a s s U s a D u e C o n t i {

// c r e a un n u o v o c o n t o c o r r e n t e i n i z i a l i z z a t o con 1 0 0 0 e u r o C o n t o C o r r e n t e c o n t o 1 = new C o n t o C o r r e n t e ( 1 0 0 0 ) ;

// c r e a un n u o v o c o n t o c o r r e n t e i n i z i a l i z z a t o con 200 e u r o C o n t o C o r r e n t e c o n t o 2 = new C o n t o C o r r e n t e ( 2 0 0 ) ;

// p r e l e v a 700 e u r o dal p r i m o c o n t o ...

c o n t o 1 . p r e l e v a ( 7 0 0 ) ;

// ... e li v e r s a nel s e c o n d o c o n t o 2 . v e r s a ( 7 0 0 ) ;

S y s t e m . out . p r i n t l n (" S a l d o p r i m o c o n t o : " + c o n t o 1 . s a l d o );

S y s t e m . out . p r i n t l n (" S a l d o s e c o n d o c o n t o : " + c o n t o 2 . s a l d o );

} }

(12)

L’esecuzione di un programma a oggetti (1)

In un programma basato su oggetti, lo stato

non `e pi`u uno stato unico globale (come nel caso della programmazione imperativa)

ma `e composto da tutti gli stati interni di tutti gli oggetti attivi

(13)

L’esecuzione di un programma a oggetti (2)

Per descrivere l’esecuzione di un programma a oggetti

ci si pu`o concentrare sulle invocazionidi metodi dei vari oggetti trascurando i dettagli della loro implementazione (i singoli comandi che contengono)

Un diagramma come questo fa capire che il metodo pagaStipendio() di della classe Dipendente richiama il metodo versa() di ContoCorrente

(14)

OOP e Ingegneria del Software

La programmazione orientata agli oggetti semplifica la realizzazione di programmi complessi:

1. Si identificano le varie entit`a da rappresentare tramite classi e oggetti 2. Si specificano le variabili e i metodi di ogni classe accessibili dalle

altre classi (ossia l’interfaccia pubblicadella classe)

3. Si implementano le varie classi separatamente, concentrandosi su una per volta

4. Le varie classi possono essere implementate da persone diverse indipendentemente

La disciplina che si occupa di organizzare questo lavoro `e l’Ingegneria del Software

Definisce notazioni (diagrammi), metodologie e procedure che rendono il processo di sviluppo di software complessi pi`u efficiente e affidabile.

(15)

Sommario

1 Programmazione Orientata agli Oggetti: concetti

2 Programmazione Orientata agli Oggetti: highlights

(16)

OOP Highlights (1)

Riprendiamo l’esempio del conto corrente:

p u b l i c c l a s s C o n t o C o r r e n t e { p u b l i c d o u b l e s a l d o ;

}

p u b l i c v o i d v e r s a (d o u b l e s o m m a ) { s a l d o += s o m m a ;

}

p u b l i c v o i d p r e l e v a (d o u b l e s o m m a ) { saldo -= s o m m a ;

} }

(17)

OOP Highlights (2)

Riprendiamo anche il primo main che abbiamo considerato:

// fa un po ’ di p r e l i e v i , c o n t r o l l a n d o p r i m a il s a l d o if ( cc . saldo > 2 0 0 ) cc . p r e l e v a ( 2 0 0 ) ;

if ( cc . saldo > 9 0 0 ) cc . p r e l e v a ( 9 0 0 ) ;

} }

(18)

OOP Highlights (3)

Arricchiamo un po’ il comportamento dei metodi:

Tracciamo i movimenti stampando dei messaggi

}

S y s t e m . out . p r i n t l n (" V e r s a t i : " + s o m m a + " e u r o ");

}

p u b l i c v o i d p r e l e v a (d o u b l e s o m m a ) { saldo -= s o m m a ;

S y s t e m . out . p r i n t l n (" P r e l e v a t i : " + s o m m a + " e u r o ");

} }

(19)

OOP Highlights (4)

Abbiamo modificato la classe... dobbiamo mettere mano anche al main (e/o alle altre classi che la usano)?

NO!

Highlight: se non modifichiamo l’interfaccia pubblica (nomi dei metodi, parametri, valori di ritorno) possiamo modificare la classe senza

compromettere il resto del programma

Pi`u facile fare manutenzione e aggiornamenti a parti del programma!

(20)

OOP Highlights (5)

Modifiche all’interfaccia pubblica richiedono invece di modificare anche i chiamanti (in questo caso il main)

Esempio: consentiamo il prelievo solo se c’e’ la disponibilit`a

}

// r e s t i t u i s c e f a l s e se non ci s o n o a b b a s t a n z a s o l d i p u b l i c b o o l e a n p r e l e v a (d o u b l e s o m m a ) {

if ( saldo < s o m m a ) r e t u r n f a l s e; e l s e {

saldo -= s o m m a ;

r e t u r n t r u e; }

} }

(21)

OOP Highlights (6)

Modifichiamo di conseguenza il main:

// fa un po ’ di p r e l i e v i , c o n t r o l l a n d o p r i m a il s a l d o . // p o s s o t e n e r e c o n t o o m e n o del r i s u l t a t o ( t r u e / f a l s e ) if (! cc . p r e l e v a ( 2 0 0 ) ) S y s t e m . out . p r i n t l n (" F a l l i t o ");

cc . p r e l e v a ( 9 0 0 ) ;

} }

(22)

OOP Highlights (7)

Prima abbiamo aggiunto la stampa dei messaggi per tracciare le operazioni sul conto...

ma chi vieta all’utilizzatore di questa classe di modificare a mano il saldo?

cc . s a l d o = 1 0 0 0 0 0 0 0 ;

(23)

OOP Highlights (8)

Il saldo `e pubblico (public)

se vogliamo evitare che sia modificabile dall’esterno della classe lo dobbiamo trasformare in privato (private)

p u b l i c c l a s s C o n t o C o r r e n t e {

// ora e ’ v i s i b i l e s o l o all ’ i n t e r n o di q u e s t a c l a s s e p r i v a t e d o u b l e s a l d o ;

}

p u b l i c b o o l e a n p r e l e v a (d o u b l e s o m m a ) { if ( saldo < s o m m a ) r e t u r n f a l s e; e l s e {

(24)

OOP Highlights (9)

Ora siamo sicuri che le modifiche al saldo avverranno solo tramite i metodi Ma.... come far`a il main a stampare il saldo?

Idee?

(25)

OOP Highlights (10)

Soluzione: Aggiungiamo un metodo

p u b l i c c l a s s C o n t o C o r r e n t e { p r i v a t e d o u b l e s a l d o ;

}

p u b l i c b o o l e a n p r e l e v a (d o u b l e s o m m a ) { if ( saldo < s o m m a ) r e t u r n f a l s e; e l s e {

}

// r e s t i t u i s c e il s a l d o a chi ne ha b i s o g n o p u b l i c d o u b l e o t t i e n i S a l d o () {

r e t u r n s a l d o ;

(26)

OOP Highlights (11)

Il metodo che abbiamo aggiunto consente di accedere al saldo solo “in lettura”

In questo modo il valore del saldo è sempre sotto controllodei metodi Highlight: la proprietà per cui i dati che rappresentano lo stato interno di un oggetto possono essere accessibili solo tramite i metodi dell’oggetto stesso è detta INCAPSULAMENTO

L’incapsulamento consente di gestire un oggetto come una “scatola nera” (black box).

Dall’esterno si sa cosa fa un oggetto, ma non come lo fa...