7. Java e la progettazione ad oggetti Linguaggio e fasi di progettazione. appunti java pag. 47

Transcript

1 appunti java pag Java e la progettazione ad oggetti Nei paragrafi precedenti si è mostrato che una classe di Java è la veste che assume una pluralità di cose: programmi standalone; applet; classi che definiscono nuovi oggetti. In generale per passare dalla programmazione imperativa-procedurale del Pascal alla programmazione ad oggetti in Java è necessario ricostruire un quadro di riferimento concettuale nuovo. In Pascal si ragiona in termini di Algoritmi e di Strutture Dati, come indicato fin dalle origini dal progettista del Pascal Niklaus Wirth che intitola un suo testo fondamentale Programmi=Algoritmi+StruttureDati. Nella programmazione ad oggetti si potrebbe dire che un Programma è una Costruzione tipo Lego e i mattoni che la compongono sono gli Oggetti. Un oggetto (più esattamente una classe) è un contenitore costituito dai Dati che lo caratterizzano e dalle Operazioni che intervengono su quei dati. In termini più precisi una classe è un entità unica costituita da tre parti essenziali: NOME (che individua la classe univocamente) ATTRIBUTI o CAMPI (Dati che caratterizzano la classe) METODI (Servizi forniti dalla classe o Operazioni che intervengono sugli attributi) Linguaggio e fasi di progettazione In precedenza si sono utilizzate alcune classi presenti nel "jdk" di java quali String, StringBuffer, Integer o Double e si è visto il manuale della documentazione di Java e la sua organizzazione in "Packages" che sono raggruppamenti di classi affini. Ora si cercheranno di definire alcuni criteri necessari per progettare un programma con una metodologia orientata agli oggetti Object Oriented (OO). Di norma si parte da una Situazione Problematica (situazione più o meno definita dalle esigenze dell'utente finale) e si affrontano diverse fasi che, in sequenza, sono: l'analisi, il Disegno e la vera e propria Programmazione. FASI Analisi preliminare DOCUMENTI Def. CASI D'USO Disegno o specifica Disegno CLASSI Codifica e Test CODICE Java

2 appunti java pag. 48 a) Nella fase di analisi OOA si analizza la situazione problematica e si definiscono i "casi d'uso" finali, i requisiti, le funzionalità richieste dall'utente. Occorre porsi dal punto di vista dell'utilizzatore finale e usare le conoscenze di sistema che di norma sono spesso esterne all ambito dell'informatica. Ai casi d'uso individuati si assegna un nome e si schematizza la situazione con il diagramma dei casi d'uso, eventualmente accompagnato da un testo esplicativo. b) Nella fase di disegno OOD, che segue l'individuazione dei casi d'uso, si devono individuare le classi (o le gerarchie di classi) necessarie, rispondendo alla domanda "chi fa che cosa?". Questa domanda può essere tradotta come "quali Classi devono fornire i servizi necessari per realizzare le funzionalità individuate nei casi d'uso?" Si decidono le caratteristiche informative, il tipo di dati e le caratteristiche relazionali che definiscono gli attributi (campi o data member) della classe. Si individuano quali servizi quelle classi devono fornire. Ovvero quali operazioni (metodi) sono necessarie per manipolare un oggetto di quella classe. Si definiscono i costruttori della classe. Si individuano le relazioni tra le classi progettate. Sotto è disegnato lo schema di rappresentazione di un Classe. <Nome> <Attributi> <Costruttori> <Metodi> c) Nella fase di programmazione o codifica OOP, che segue il disegno delle classi, si produce la codifica vera e propria delle classi e dei metodi individuati e si testa con un programma di prova il funzionamento dei casi d'uso desiderati.

3 appunti java pag Esempi di progettazione Supponiamo ad esempio di voler affrontare la semplice situazione problematica seguente: esempio 1 - "Si desidera realizzare un sistema che manipoli cerchi calcolandone l'area e determinando se un punto assegnato è interno o esterno al cerchio." Nella fase di analisi (OOA) si individueranno le esigenze dell'utente che si possono desumere dalle parole chiave del testo: possibilità di inserire i dati che definiscono un cerchio; possibilità di calcolare l'area: possibilità di sapere se un punto assegnato è interno al cerchio. Questi sono i tre casi d'uso che possiamo stabilire in prima approssimazione e schematizzare con il seguente diagramma: immetti area interno Nella fase di Disegno (OOD) si dovranno definire le classi necessarie CHE FANNO ciò che si desidera (CHI FA CHE COSA?). Per il nostro problema la classe centrale sarà il cerchio e dovrà avere come attributi raggio e centro. I metodi minimi necessari saranno: il costruttore che consente l'immissione dei dati; il metodo Area; il metodo interno. Lo schema da realizzare per disegnare tale classe è il seguente: - double Xc; - double Yc; - double raggio; Cerchio + Cerchio(double x, double y, double r) + area() : double; + interno(double x, double y) : boolean; Si potrebbero progettate non una ma due classi: la Cerchio, indispensabile, e una classe Punto che potrebbe indicare il fatto che il cerchio è dotato di un punto particolare che è il suo centro.

4 appunti java pag. 50 In questo modo il disegno alternativo sarebbe: - double Xc; - double Yc; Punto + Punto(double x, double y) + getx( ) : double; + gety( ) : double; associazione 1 Cerchio - Punto centro; - double raggio; + Cerchio(Punto p, double r) + area() : double; + interno(punto p) : boolean; Le due alternative di disegno sono didatticamente utili per mostrare come si rappresenta una relazione tra due diverse classi. E' evidente che se si progetta una classe Punto si deve prevedere un costruttore adeguato e che per accedere dall'esterno agli attributi privati del Punto dovranno essere disegnati i due metodi getx() e gety(). Annotazioni teoriche: Modalità con cui si indicano attributi, costruttori e metodi. Il segno che li precede (-), (+), (#) indica rispettivamente che il metodo è private, public o protected. Un metodo o un attributo public (+) è SEMPRE accessibile dall'esterno della classe, un metodo o un attributo private (-) è accessibile SOLO dal codice interno alla classe; infine un metodo o un attributo protected (#) è accessibile solo dal codice della classe o delle sue sottoclassi ma non dall'esterno. Le classi possono stare tra loro in una relazione associativa di Composizione e questo si indica con la seguente simbologia Punto 1 Cerchio Punto 3..* Poligono due classi sono in relazione di composizione se la prima di esse risponde alla domanda "HA UN" e la seconda di conseguenza si configura come la parte di un tutto. Nel primo caso disegnato si dice che la classe Cerchio ha un Punto (il centro) che le appartiene come sua parte. Nel secondo caso disegnato la relazione ci informa del fatto che un Poligono deve avere come sue parti 3 o più punti. Sempre nella fase di Disegno (ma potrebbe essere realizzata contemporaneamente alla codifica) si deve definire la Documentazione della classe; questa consiste nello scrivere le specifiche o manuale d'uso di ogni metodo della classe. Tali Specifiche hanno valore contrattuale e formale, devono quindi essere precise e non contenere ambiguità. Il documento di specifica è utilizzato, quando si progetta in grande, da due diverse figure: Il programmatore di sistema, il quale costruisce il pacchetto con le nuove classi vincolandosi alle specifiche, e il

5 appunti java pag. 51 futuro utilizzatore, il quale userà le specifiche come manuale della classe per realizzare applicazioni. Per queste finalità tale manuale dovrà contenere una "intestazione" dei metodi (detta anche signature) scritta nella sintassi del linguaggio di programmazione e la descrizione per ogni metodo di: effetti prodotti dal metodo; descrizione dei parametri di input e di output; casi d'uso ed eventuali eccezioni. Disegno o specifica Classi e Relazioni tra esse Metodi e significato dei parametri Produzione del manuale Eccezioni ed esempi d uso Nome Identificatore Cerchio Campi o attributi Punto centro private double raggio Costruttori Intestazione: Cerchio(Punto p, double r) Metodi Invocazione: Effetti: Intestazione: Invocazione: Punto p=new Punto(3,4); Cerchio C=new Cerchio(p, 9); Riceve il centro p di coordinate (3,4) e il raggio 9 e costruisce un oggetto cerchio C. double area() double S=C.area(); Effetti:: determina l'area del cerchio C e l'assegna alla variabile S. Intestazione: boolean interno(punto p) Invocazione: Effetti:: boolean b=c.interno(p); determina se il punto p assegnato è o no interno al cerchio C. Restituisce true se Si, No altrimenti. Nella fase di codifica (OOP) delle Classi e dei metodi (attività specifica del programmatore di sistema) si deve scegliere l algoritmo più opportuno per implementare ciascun metodo. Di norma questa fase è lasciata libera da vincoli sia nella scelta delle strutture dati di supporto più opportune che nella scelta dell algoritmo; ovviamente tale scelta deve superare i test di funzionamento previsti dalle specifiche e gli eventuali test di efficienza (la velocità di esecuzione dipende dalla rappresentazione dei dati e dall algoritmo scelti).

6 appunti java pag. 52 Codifica e test Codifica Classi Scelta algoritmi e codifica metodi CODICE Java Test di correttezza ed efficienza Nel caso del problema da cui siamo partiti si tratterà di codificare le due Classi individuate nel disegno e di costruire un programma di prova che verifichi il funzionamento dei Casi d'uso previsti. public class Punto { private double Xc; private double Yc; public Punto(double x, double y) { Xc=x; Yc=y; public double getx() { return Xc; public double gety() { return Yc; // end Punto public class Cerchio { private Punto centro; private double raggio; public Cerchio(Punto p, double r) { centro=p; raggio=r; public double area() { double ris=math.pi*raggio*raggio; return ris; public boolean interno(punto p) { boolean ris=false; double x=p.getx(); double y=p.gety(); double xc=centro.getx(); double yc=centro.gety(); double dist=math.sqrt((x-xc)*(x-xc)+(y-yc)*(y-yc)); if (dist<=raggio) ris=true; return ris; // end Cerchio Il main() deve verificare i "casi d'uso" individuati nell'analisi, in particolare calcolare l'area e stabilire se un punto assegnato è o no interno al cerchio:

7 appunti java pag. 53 public class es01_c07 { public static void main(string arg[]) { Punto Centro=new Punto(3,4); Cerchio C=new Cerchio(Centro, 9); Punto P=new Punto(3,13); Punto Q=new Punto(4,10); Punto R=new Punto(5,13); System.out.println("Area="+C.area()); System.out.println("P interno "+C.interno(P)+", Q interno " + C.interno(Q) +", R interno "+C.interno(R)); Il programma stamperà: Area= P interno true, Q interno true, R interno false Supponiamo ad esempio di voler affrontare la situazione problematica seguente: esempio 2 - "Si desidera realizzare un programma che manipoli numeri Razionali (frazioni) e si vuole almeno la funzionalità di immissione e stampa". In un secondo momento si amplierà il sistema con altre operazioni. Analisi preliminare (definizione dei Casi d'uso) Lo schema indica i due casi d'uso indicati nel testo: immetti stampa Disegno o specifica Un numero razionale è una coppia di numeri (n,d) tali che n ε Z e d ε N0, il numeratore potrebbe avere segno negativo o essere nullo, il denominatore deve essere diverso da Zero. Questi sono gli unici due attributi previsti per la classe razionale. Le uniche operazioni che si svilupperanno provvisoriamente sono l operazione che consente di immettere costruire un razionale e quella che consente di stamparlo sul video. Il numeratore e il denominatore saranno rappresentati (memorizzati) in una forma "normalizzata" nel senso che è ammesso il segno negativo al più al numeratore, e i due numeri devono essere ridotti ai minimi termini. Se si costruisce il razionale 4/8 si memorizzerà negli attributi 1/2. A questo scopo si è previsto di progettare un metodo (private) che determina il massimo comune divisore al fine di semplificare i valori immessi dall'utente.

8 appunti java pag. 54 Lo schema di disegno della classe è il seguente: - long N; - long D; Razionale + Razionale(long n, long d) + stampa( ) : void; - mcd(long a, long b) : long; Il disegno si conclude con la specifica che consiste nella scrittura del manuale. Nome Identificatore Razionale Campi o attributi int Num; private int Den; Costruttori Intestazione:: Razionale(long Num, long Den) Metodi Invocazione: Razionale r=new Razionale(6,-4); Effetti: Riceve 6 e -4 interi e alloca l oggetto r = 3/2; se il denominatore è zero interrompe e segnala un errore irreparabile. Intestazione: void stampa() Invocazione:: Effetti:: r.stampa(); Riceve il razionale r e lo mostra a video in forma frazionaria ridotta ai minimi termini. Se il denominatore è 1 stampa il solo numeratore. Il jdk di Java mette a disposizione uno strumento (programma javadoc) che consente di stilare, oltre al codice, il testo del manuale d'uso delle classi codificate nella forma di file HTML. In questo caso si parla di "manuale on line" del sistema progettato. In particolare codificando le classi e i metodi con opportuni commenti formali e "lanciando" il programma javadoc si ottiene automaticamente la documentazione in formato <HTML>. Per l'esempio "Razionale" si farà uso di tale potenzialità. Di seguito vediamo i passi da percorrere, documentazione inclusa, in sede di codifica. Codifica, Test e manuale online La codifica di questa classe in Java dovrà rispettare le specifiche e memorizzare due numeri ridotti ai minimi termini e normalizzati nel segno. I commenti formalizzati compresi tra /** */ sono indispensabili per ottenere il manuale di documentazione online.

9 appunti java pag. 55 /** * La classe Razionale consente di immettere e stampare numeri razionali. Pinco Pallo 2 Luglio 2002 */ public class Razionale { private long N,D; //ATTRIBUTI della classe /** * Costruttore di Razionale. a numeratore, b denominatore * <p>se il parametro (denominatore) b è nullo, si ha una * interruzione con un messaggio di fallimento.</p> */ public Razionale(long a, long b) { long div = mcd(a,b); a=a/div; b=b/div; if (b<0) {N=-a; D=-b; else {N=a; D=b; /** * Stampa un Razionale nella forma n/d. void */ public void stampa() { if (D==1) System.out.println(N); else System.out.println(N+"/"+D); private static long mcd(long a, long b) { // mcd() Privato a=math.abs(a); b=math.abs(b); long ris=0; if (b!=0) { if (a!=0) { long r=1; while (r!=0) { r= a % b; a=b; b=r; ris=a; else ris=b; else { // a e b diversi da zero // a=0, b diverso da zero // b=0 inaccettabile System.out.println("Denominatore Nullo! errore fatale."); System.exit(1); return ris; Si salva il file sorgente col nome Razionale.java e dopo la compilazione si ottiene il programma oggetto Razionale.class. Per ottenere la documentazione online sotto la forma di file HTML è necessario scegliere dal menù di RealJava l'opzione <Tools> e successivamente <Javadoc Project Files..>. Dopo aver scelto la cartella nella quale salvare la documentazione si avvia il processo di generazione automatica della documentazione. Al termine, se non vengono segnalati errori, si apre la cartella e si avvia <index.html> visualizzando la documentazione di Razionale. Nella scrittura della documentazione sono da notare i TAG specifici che compaiono tra /** */ preceduti si tratta di TAG predefiniti (per definire l'autore del (per illustrare il significato dei

10 appunti java pag. 56 parametri passati al metodo) (che illustra i parametri restituiti da un metodo. Per vedere gli altri TAG disponibili leggere la documentazione di Java nella illustrazione di Javadoc. Per fare un test o usare la classe e costruire oggetti razionali è necessario creare un main program di prova come il seguente: class es02_c07 { public static void main(string args[]) { Razionale a, b, c; a=new Razionale(-3,-6); b=new Razionale(28,-8); c=new Razionale(28,-7); a.stampa(); b.stampa(); c.stampa(); eseguendo l operazione Run si ottiene come risultato: 1/2-7/2-4 In sintesi analizzando il main() si nota che: Razionale non è un tipo di dato statico come int o float ma un oggetto. Lo si deduce dal fatto che la definizione Razionale a; non è sufficiente per disporre di un dato di tipo razionale ma è necessario crearlo con il costruttore Razionale(). L operazione a=new Razionale(num,den); provvede a semplificare la frazione e a memorizzarla allocandola dinamicamente nella memoria libera del computer. Ogni invocazione del costruttore crea (istanzia) un oggetto. L invocazione di un metodo avviene sempre anteponendo all operazione l oggetto a cui deve essere applicato quel metodo. La scrittura a.stampa(); si potrebbe interpretare come l ordine applica l operazione stampa all oggetto a. Questa sintassi è tipica dell invocazione dei metodi applicati agli oggetti. Supponiamo ad esempio di voler ampliare le richieste definendo la seguente situazione problematica: esempio 3 - "Si desidera ampliare la classe razionale implementando almeno l'operazione di somma tra due razionali." Trascuriamo di disegnare i "casi d'uso" della nuova funzionalità e limitiamoci a indicare nel disegno della classe il nuovo metodo sum() che esegua la somma di due frazioni nel modo seguente: Nome Identificatore Razionale Metodi Intestazione: Razionale sum(razionale B) Invocazione:: Effetti:: Razionale C=A.sum(B); Riceve il Razionale B e lo somma a quello invocante A. Il risultato Razionale restituito è assegnato alla variabile C.

11 appunti java pag. 57 public Razionale sum(razionale r) { long nris, dris; nris = N*r.D+D*r.N; dris = D*r.D; return new Razionale(nris,dris); // METODO sum() // le variabli N e D // non vengono definite // perché sono attributi. modificando il main() si può eseguire un test nel modo seguente: class es03_c07 { public static void main(string args[]) { Razionale a, b, c, d; a=new Razionale(-3,-6); b=new Razionale(28,-8); c=new Razionale(28,-7); a.stampa(); b.stampa(); c.stampa(); d=a.sum(b); d.stampa(); Si ottiene a video: 1/2-7/ Spingiamoci oltre affrontando la seguente situazione problematica: esempio 4 - "Si desidera implementare una <finestra di Windows> che consenta alcune operazioni: almeno la creazione, il disegno sul desktop e il suo dimensionamento." OOA Crea_frame Dimensiona Disegna

12 appunti java pag. 58 OOD La classe potrebbe avere il seguente disegno - int x, y; - int width, height; - boolean stato; + Frame() Frame + setsize(int W, int H ) : void; + setbounds(int X, int Y, int W, int H ) : void; + setvisible(boolean S ) : void; x,y sono le coordinate in alto a sinistra della frame; width, height la sua larghezza e altezza espresse in pixel, lo stato indica se la frame è visibile sullo schermo; stato true o se e solo allocata nella memoria; stato false. Le specifiche del manuale potrebbero essere: Nome Identificatore Frame Campi o attributi int x, y; private int width, height; boolean visible; Costruttori Intestazione:: Frame() Metodi OOP Invocazione: Effetti: Intestazione: Frame f=new Frame(); Crea in memoria la struttura (non visibile su schermo) con dimensioni nulle. void setsize(int W, int H); Invocazione:: f.setsize(100, 100); Effetti:: Intestazione: Dimensiona f assegnando agli attributi width=100 ed height=100 void setbounds(int X, int Y, int W, int H); Invocazione:: f.setbounds(20,30, 100, 100); Effetti:: Posizione il vertice in alto a sinistra di f in (20,30) rispetto al desktop e assegna agli attributi width=100 ed height=100 Intestazione: void setvisible(boolean stato); Invocazione:: f.setvisible(true); Effetti:: Mostra sul desktop la frame f. La class Frame per fortuna, è già stata implementata dai progettisti di java e quindi possiamo limitarci a realizzare un programma di prova che mostri i casi d'uso che abbiamo definito nell'analisi.

13 appunti java pag. 59 Si noti che la classe Frame e tutti gli oggetti grafici sono contenuti nel Package java.awt. e quindi per utilizzarli in un programma è necessario "importare" il package che la contiene, come si vede nella prima riga del codice seguente. import java.awt.*; class es04_c07 { public static void main(string args[]) { Frame f=new Frame(); f.setbounds(200,150,100,100); Frame g=new Frame(); g.setsize(200,100); f.setvisible(true); g.setvisible(true); Se provate ad eseguire questo programma otterrete sulla finestra dell editor la seguente situazione: E evidente che la classe Frame è stata implementata nel linguaggio Java e quindi tutto funziona. Noterete che le Frame create non si chiudono, l unico modo di chiuderle è spegnere il computer o interrompere il processo Java, non ci siamo preoccupati di attivare un METODO che consenta di terminare il programma. Vedremo successivamente come fare. Si potrebbe affrontare un problema di progettazione di carattere gestionale come il seguente. esempio 5 - "Si desidera gestire un Conto Corrente bancario consentendo di eseguire operazioni di creazione, prelievo e versamento; inoltre si desidera anche registrare il numero di operazioni eseguite sul conto. Un cliente della banca può avere al massimo due conti correnti mentre un conto corrente ha sempre un solo titolare." OOA I Casi d'uso identificati sono:

14 appunti java pag. 60 Crea_Cliente Crea_CC Versa_Preleva Mostra OOD Le classi da progettare sono la Conto Corrente e la Cliente. E' opportuno progettare una classe Cliente per evitare la ripetizione dei dati anagrafici del Cliente nei due possibili conti correnti con lo stesso intestatario che il problema autorizza. Se i dati del cliente fossero inseriti come attributi di ogni CC si ripeterebbero inutilmente inserimenti e aggiornamenti con la quasi sicurezza di inserire incongruenze. E' evidente che le due classi devono interagire tra loro e quindi dobbiamo immaginare che tra esse ci sia una relazione associativa, infatti un CC ha sempre un Cliente e un Cliente può avere da Zero a Due Conti. L'associazione risponde ancora alla modalità "HA UN", infatti un CC ha sempre un cliente intestatario. Si può notare che questa associazione non è esattamente corrispondente a quella che intercorreva tra Cerchio e Punto, infatti un "oggetto" Cerchio "ha come sua parte obbligatoriamente un punto" questo implica che se si elimina (cancella dalla memoria) il cerchio si elimina anche il suo centro associato. Se è vero che un "oggetto" CC ha sempre come associato un "oggetto" Cliente NON è' vero che eliminando un CC deve essere eliminato anche il Cliente. Il cliente può avere un altro Conto, il Cliente non è a rigore "UN COMPONENTE" del CC. La relazione associativa si chiama in questo contesto Aggregazione. La rappresentazione grafica può essere: - int NumConto; - double Saldo; - int NumOp; - Cliente Cli; CC + CC(Cliente inte, int numc) + versa(double cifra ) : void; + preleva(double cifra ) : boolean; + mostracli( ) : void; + mostra( ) : void; Cliente - String Nome; - String Indir; - String Tel; - CC C1=null; C2=null; + Cliente( String nom, String in, String te) + setconto( CC c): void; + mostra( ) : void;

15 appunti java pag. 61 Il rombo vuoto ( in Composizione era pieno) indica che si tratta di Aggregazione e la direzione della freccia indica che la "navigabilità" va da CC a Cliente ovvero che si accede ai servizi di cliente partendo da CC e non viceversa. CC è responsabile del sistema mentre Cliente si limita a fornire a CC gli attributi anagrafici. Non è possibile accedere a CC partendo da Cliente. Questa interpretazione non consente di controllare, con facilità, che un Cliente abbia un massimo di due CC intestati come richiesto dal testo. Il sistema delle due classi può essere progettato anche in modo diverso immaginando che Cliente sia responsabile del sistema e che un Cliente "Abbia come suoi componenti" da 0 a 2 CC e che tutte le funzionalità di CC siano "navigabili" a partire da Cliente. In questo caso si realizza un'associazione di Composizione perché è legittimo pensare che un Cliente che viene eliminato comporti anche la chiusura dei conti di sua proprietà. In questo modo si controlla anche che il cliente non superi mai i due conti a lui intestati. Il diagramma della classi cambia anche per i servizi che ciascuna classe fornirà. - int NumConto; - double Saldo; - int NumOp; + CC( int numc) CC + versa(double cifra ) : void; + preleva(double cifra ) : boolean; + mostra( ) : void; 0..2 Cliente - String Nome; - String Indir; - String Tel; - CC C1=null, C2=null; + Cliente( String nom, String in, String te) + creaconto(int numc): boolean; + contouno() : CC; + contodue() : CC; + mostracc( ) : void; + mostra( ) : void; Si potrebbe pensare che il sistema debba consentire "navigabilità" nei due sensi a seconda che il sistema debba fornire servizi d'ufficio che prendono in esame totali e statistiche che partono dai Conti Correnti o servizi di sportello che si limitano ad ascoltare le richieste dei correntisti. In questo caso si evidenzia la doppia navigabilità e la relazione con le rispettive molteplicità. Il progetto delle classi potrebbe essere indicato nel seguente modo Cliente - int NumConto; - double Saldo; - int NumOp; - Cliente Cli; CC + CC(Cliente inte, int numc) + versa(double cifra ) : void; + preleva(double cifra ) : boolean; + mostracli( ) : void; + mostra( ) : void; String Nome; - String Indir; - String Tel; - CC C1=null, C2=null; + Cliente( String nom, String in, String te) + creaconto(int numc): boolean; +setconto(cc c) : void; + contouno() : CC; + contodue() : CC; + mostracc( ) : void; + mostra( ) : void;

16 appunti java pag. 62 OOP La codifica del primo dei tre progetti sarà: public class CC { private int NumConto; private double Saldo; private int NumOp; private Cliente Cli=null; // Classe Conto Corrente public CC(Cliente inte,int numc){ inte.setconto(this); Cli=inte; NumConto=numc; Saldo=0;NumOp=0; public void versa(double cifra){ Saldo=Saldo+cifra; NumOp++; public boolean preleva(double cifra){ boolean fatto=true; if (cifra<=saldo) { Saldo=Saldo-cifra; NumOp++; else { System.out.println("Saldo insufficiente! OP Fallita."); fatto=false; return fatto; public void mostracli() { Cli.mostra(); public void mostra( ){ System.out.println("Conto n "+NumConto); System.out.println("Opreazioni svolte= "+NumOp); System.out.println("Saldo= "+Saldo+"\n"); public class Cliente { // class Cliente private String Nome; private String Indir; private String Tel; private CC C1=null, C2=null; public Cliente(String nom,string ind, String tel){ Nome=nom; Indir=ind; Tel=tel;

17 appunti java pag. 63 public void setconto(cc c) { if (C1==null) C1=c; else if (C2==null) C2=c; else { System.out.println("il cliente ha giù due conti. op Fallita!"); System.exit(0); public void mostra( ){ System.out.println("Cliente :"+Nome); System.out.println("Indirizzo :"+Indir+" Telefono: "+Tel+"\n"); Il main() che verifica i casi d'uso sarà; public class es05_c07 { public static void main(string ar[]){ Cliente C1=new Cliente("Tizio","via Pioppa 2 - BO"," "); Cliente C2=new Cliente("Caio","via Olmi 3 - BO"," "); CC conto1=new CC(C1,1); CC conto2=new CC(C1,2); CC conto4=new CC(C2,4); conto1.versa(2000.0); conto2.versa(3000.0); conto4.versa(4000.0); conto1.preleva(4000.0);// fallisce supera saldo conto1.preleva(2000.0); conto2.preleva(3000.0); conto4.preleva(3000.0); conto1.mostracli(); conto1.mostra(); conto2.mostracli(); conto2.mostra(); conto4.mostracli(); conto4.mostra(); CC conto3=new CC(C1,3); // fallisce sup.2 conti L'output del programma: Saldo insufficiente! OP Fallita. Cliente :Tizio Indirizzo :via Pioppa 2 - BO Telefono: Conto n 1 Operazioni svolte= 2 Saldo= 0.0 Cliente :Tizio Indirizzo :via Pioppa 2 - BO Telefono: Conto n 2 Operazioni svolte= 2 Saldo= 0.0

18 appunti java pag. 64 Cliente :Caio Indirizzo :via Olmi 3 - BO Telefono: Conto n 4 Operazioni svolte= 2 Saldo= il cliente ha giù due conti. op Fallita! 7.3. Le classi e l ereditarietà La relazione di Generalizzazione o Ereditarietà tra classi è una delle più importanti tra quelle "supportate" dalla programmazione ad oggetti. Nell'esempio del Cerchio si è segnalata la relazione associativa di Composizione e nella Conto Corrente quella di Aggregazione, ora si vedrà la relazione associativa di Generalizzazione o Ereditarietà tra classi. Questa caratteristica molto importante consente di progettare classi complesse facendo ereditare a queste il codice scritto precedentemente per altre classi genitrici simili. Questa proprietà è un punto di forza di un linguaggio ad oggetti ma impone al progettista una visione ampia delle necessità e dell architettura che intende realizzare. Procediamo con un esempio; l'esempio, pur avendo solo utilità didattica, mostra alcuni punti di forza di questa metodologia. Dopo la precedente progettazione della classe Razionale, si potrebbe pensare alla seguente situazione problematica. esempio 6 - "Si desidera disporre, oltre ai Razionali, anche di numeri Interi e se possibile eseguire operazioni, come la somma o la sottrazione tra i due tipi diversi come avviene in matematica". OOA Crea_Numeri Operazioni Stampa_Risultati OOD Dalla matematica si sa che i numeri Interi e Razionali si possono sommare e sottrarre tra loro e si ottengono risultati interi o razionali corretti. Nel progetto si potrebbe sfruttare la caratteristica dei numeri interi che "possono essere pensati" come Razionali con denominatore uguale all'unità.

19 appunti java pag. 65 In altre parole esiste un rapporto di generalizzazione tra interi e razionali che risponde al criterio tipico dell'ereditarietà (Inheritance). Due classi stanno in una relazione di ereditarietà una classe è Figlia (Subclass) e l'altra è Genitore (Parent, Superclass), se la prima risponde al criterio di "essere un". In altre parole in Intero "E' UN" Razionale con denominatore uno e quindi l'intero è figlio di razionale che diviene la classe genitrice. Questa relazione di ereditarietà è rappresentata dal seguente schema nella figura 3: Numero Numero Fig.2 Razionale Naturale Intero Razionale Intero Razionale Naturale Fig.1 Intero Fig.3 Nulla esclude di pensare la gerarchia in modo diverso e più esteso come nelle figure 1 e 2. In esse si indica che esiste un genitore "astratto", la classe Numero, di tutti gli insiemi numerici (Razionali, Interi e Naturali). In figura 2 si evidenzia solo che sia i razionali che gli interi che i naturali sono Numeri ma tra di loro non esiste una gerarchia. Nella figura 1 si mostra che un naturale è contemporaneamente un Intero (positivo evidentemente), un Razionale (con denominatore uno) ed è anche un Numero. Si disegneranno ora Classi e Metodi del modello di Fig long N; - long D; Razionale + Razionale(long n, long d) + sum(razionale B ) : Razionale; + sub(razionale B ) : Razionale; + tostring( ) : String; - mcd(long a, long b) : long; Intero + Intero(long n)

20 appunti java pag. 66 La classe Intero è dotata del solo Costruttore infatti un intero è un Razionale e quindi la classe eredita sia gli attributi che tutti i metodi definiti per la classe genitrice. Non è necessario scrivere codice per ottenere le operazioni di somma e sottrazione tra interi. OOP Ecco il codice completo delle due classi La classe Razionale: class Razionale { private long N, D; public Razionale(long n, long d) { long div=mcd(n,d); n=n/div; d=d/div; if (d<0) {n=-n; d=-d; N=n ;D=d; public Razionale sum(razionale B) { long R=N*B.D+B.N*D; long K=D*B.D; Razionale Ris=new Razionale(R,K); return Ris; private static long mcd(long a, long b) { long x=math.abs(a);long y=math.abs(b); long ris=0; if (y!=0) { if (x!=0) { long r=1; while (r!=0) { r= x % y; x = y; y = r; ris=x; else ris=y; // x=0, y diverso da zero else { // y=0 inaccettabile System.out.println("Denominatore Nullo"); System.exit(0); return ris; // Fine mcd // Fine Class Razionale La classe Intero: public class Intero extends Razionale { public Intero(long a) { super(a,1);