Java Manual

Programmazione OO in JavaProgrammazione OO in Java

Andrea [email protected]

Istruzioni di controlloIstruzioni di controllo

Programmazione OO in Java - Andrea Bei

Istruzioni per il controllo di flussoIstruzioni per il controllo di flusso

Istruzioni di selezioneifswitch

Istruzioni di iterazionewhiledo-whilefor

Istruzioni di saltobreakcontinuereturn


Istruzione di selezione: IF Istruzione di selezione: IF -- 11

Sintassi:if(<condizione>) <istruzione_1>[else <istruzione_2>]<istruzione_1> e <istruzione_2> possono essere istruzioni singole o blocchi

Semantica:Se <condizione>=true viene eseguita l’istruzione o il blocco di istruzioni <istruzione_1> [ altrimenti viene eseguita l’istruzione o il blocco di istruzioni <istruzione_2> ]

Il ramo else si lega all’istruzione if più vicina


Istruzione di selezione: IF Istruzione di selezione: IF –– 22

Esempio 1:if (x==10) System.out.println(“il valore di x è 10”);

Esempio 2:if (x>0 && y>0)System.out.println (“coordinate positive”);else if (x>0) System.out.println(“ascissa positiva”);else if (y>0) System.out.println(“ordinata positiva”);else System.out.println(“coordinate nulle o negative”);

Esempio 3:

if (x==10) {System.out.println(“il valore di x è 10”);System.out.println(“...sono ancora nel blocco if”);

}System.out.println(“...sono fuori dal blocco if”)


Istruzione di selezione: IF Istruzione di selezione: IF –– 33

Esempio 4:


Istruzione di selezione: SWITCH Istruzione di selezione: SWITCH -- 11

Sintassi:switch(<espressione>){

case <costante 1>:[<istruzione 1>;]*case < costante 2>:[<istruzione 2>;]*…case < costante n>:[<istruzione n>;]*[default : [<istruzioneDefault>;]*]

}

Semantica:Se <espressione>=<costante i> vengono eseguite le l’istruzioni/blocchi <istruzione j> con j>=i . Se <espressione> è diversà da tutte le costanti viene eseguita l’istruzione <istruzioneDefault>

L’espressione all’interno dello switch deve essere di tipo char, byte, short o int


Istruzione di selezione: SWITCH Istruzione di selezione: SWITCH –– 22


Istruzione di iterazione: WHILE Istruzione di iterazione: WHILE -- 11

Sintassi:

while(<condizione>) <istruzione>;

Semantica:Finchè <condizione>=true viene eseguita l’istruzione/blocco <istruzione>

Esempio:int i = 0;while (i<10){

System.out.println(“Il valore di i e’: ”+i);i=i+1;

}


Istruzione di iterazione: WHILE Istruzione di iterazione: WHILE –– 22


Istruzione di iterazione: DO WHILE Istruzione di iterazione: DO WHILE --11

Sintassi:

do <istruzione> while (<condizione>);

Semantica:Viene eseguita l’istruzione/blocco <istruzione> finchè <condizione>=true. A differenza del while-do in questo caso l’istruzione/blocco viene sempre eseguita almeno una volta.

Esempio:int r = 5;do{

System.out.println(“Countdown=”+r);r--;

} while (r>0)


Istruzione di iterazione: DO WHILE Istruzione di iterazione: DO WHILE --22


Istruzione di iterazione: FOR Istruzione di iterazione: FOR -- 11

Sintassi:

for (<istr1>; <condiz>; <istr2>) <istr3>;<istr1> e <istr2> sono istruzioni semplici o liste di

istruzioni separate da virgola<istr3> è un istruzione o un blocco

Semantica:<istr1>;while (<condiz>){

<istr3><istr2>

}



Esempio 1:int x;for(x=0; x<10; x++)

System.out.println(“Counter: ”+x);

Esempio 2:for(int x=0; x<10; x++)

System.out.println(“Counter: ”+x);

Esempio 3:for(int x=0, int i=10; x<10; x+=2, i--)

System.out.println(“i=“+i+” x=“+x );


Istruzione di salto: BREAK Istruzione di salto: BREAK -- 1 1

Sintassi:break [<label>]

Semantica:restituisce il controllo all’istruzione che include quella con il break e che è marcata con <label>

L’istruzione break è usata soprattutto:All’interno dell’istruzione di switchPer uscire da un ciclo


Istruzione di salto: BREAK Istruzione di salto: BREAK -- 22

Esempio 1: Per uscire da un ciclo

java.io.FileInputStream s = new FileInputStream(“a”);while (true){

b = s.read();if (b == -1) break;System.out.println(b);

}

Osservazione rispetto all’uscita da un ciclo:while Æ cicli condizione all’iniziodo while Æ cicli condizione alla finefor Æ ciclo con contatorebreak Æ ciclo con condizione anche “in mezzo”


Istruzione di salto: BREAK Istruzione di salto: BREAK -- 33


Istruzione di salto: CONTINUE Istruzione di salto: CONTINUE -- 11

Sintassi:continue [<label>]

Semantica:forza un’iterazione anticipata del ciclo che include il blocco con il continue e che è marcato con <label>

Esempio: Stampa i numeri da 1 a 10 tranne il 5.

for (int i= 0; i<10; i++){if (i==5) continue;System.out.println(i)

}


Istruzione di salto: CONTINUE Istruzione di salto: CONTINUE -- 22


Istruzione di salto: RETURNIstruzione di salto: RETURN

Sintassi:return [<valore>]

Semantica:Istruzione di controllo usata per ritornare esplicitamente da un metodo. In altri termini fa sì che il controllo del programma venga trasferito di nuovo a “chi” ha chiamato il metodo.

Osservazione:Le istruzioni successive all’istruzione di return non vengono eseguite.



CollezioniCollezioni


CollezioniCollezioni

Una collezione è un oggetto “contenitore” di altri oggetti

La necessità di strutture dati che raggruppino oggetti è comune a molte applicazioni.• Es: mail folder (collezione di mail) , rubriche (collezione

di associazioni nome-numero di telefono) ...

Una collezione è una struttura di più alto livello rispetto agli array.

Non è necessario stabilire a priori il massimo numero degli elementi di una collezione (negli array deve essere fissato all’allocazione)E’ possibile inserire o cancellare un oggetto in qualsiasi posizione senza dover necessariamente spostare gli altri oggettiE’ possibile mantenere un ordinamento tra gli oggettiE’ possibile avere diverse politiche di accesso (es: FIFO, LIFO)


Le collezioni in JavaLe collezioni in Java

ListeMantengono un ordinamentoHanno posizioni indicizzate Possono avere diverse politiche di accesso (es:LIFO,FIFO)

Insiemi Non ammettono duplicati

MappeGestiscono un insieme di coppie (chiave,valore) e consentono l’accesso diretto del valore a partire dalla chiave


Il framework per la gestione di collezioniIl framework per la gestione di collezioniIl package java.util fornisce un framework per la gestione di collezioni costituito da:

interfacce: consentono di utilizzare un tipo di collezione senza doverne conoscere l’implementazioneclassi: implementazioni concrete dei tipi di collezione definiti dalle interfaccealgoritmi:metodi che implementano funzioni sulle collezioni come ricerca e ordinamento

I benefici dell’uso del framework sono moltepliciriduzione dell’impegno. Sono già disponibili le principali strutture dati, non occorre riscriverle.incremento di performance. Classi e algoritmi ottimizzatiincremento della qualità del codice. Si fa leva sul concetto di interfaccia. Le implementazioni di ogni interfaccia sono intercambiabili conferendo manutenibilità al codiceinteroperabilità tra metodi. Molti metodi ritornano o accettano come parametro una interfaccia del framework. E’ un modo standard di trattare aggregati di oggetti


Liste e Insiemi: interfacceListe e Insiemi: interfacce


Mappe: interfacceMappe: interfacce


ArrayList è l’implementazione più usataconviene se si hanno

prevalentemente accessi posizionali agli elementi (tempo costante)

LinkedListconviene se si hanno

prevalentemente inserimenti in testa e cancellazioni al centro (tempo costante)

HashSet è l’implementazione più usataconviene se si hanno

prevalentemente accessi diretti agli elementi (tempo costante)

TreeSetconviene se si ha necessità di

mantenere un ordinamento (tempo logaritmico rispetto agli elementi)

Liste e Insiemi: implementazioniListe e Insiemi: implementazioni


Mappe: implementazioneMappe: implementazione

HashMap è l’implementazione più usataconviene se si hanno accessi

diretti agli elementi tempo di accesso costante

TreeMapconviene se si ha necessità di

mantenere un ordinamento tra gli elementi

tempo di accesso logaritmico


IteratoriIteratori

Un iteratore fornisce metodi per eseguire una visita degli elementi di una collezione (iterare sugli elementi)

L’interfaccia Iterator fornisce i seguenti metodiObject next(): si posiziona sull’elemento successivo e lo restituisce boolean hasNext(): restituisce true se il esiste successivo elementovoid remove(): rimuove l’attuale elemento

Esempio: il metodo filtro rimuove tutti gli elementi che non soddisfano la condizione verificata dal metodo cond

static void filtro(Collection c) {Iterator i = c.iterator();while(i.hasNext())

if (!cond(i.next())) i.remove(); }


ArrayList: esempioArrayList: esempio

Notare:1) La variabile l è di tipo Collection NON ArrayList (riga 4 di MainClass). I

riferimenti a collezioni dovrebbero essere sempre del tipo di una delle interfacce del framework. Evitare sempre l’uso delle classi concrete come tipi per le variabili.

2) Il metodo printSommeEConcat è polimorfo ha come parametro Collection e può funzionare per tutti i sottotipi di Collection


HashSet, TreeSet: esempioHashSet, TreeSet: esempioNotare:1. Utilizzando le interfacce come

tipi per le variabili posso cambiare l’implementazione da HashSet a TreeSet modificando una sola riga (Utility riga 4)


HashMap, TreeMap: esempioHashMap, TreeMap: esempioL’applicazione Frequenza legge il nome di un file da linea di comando e

fornisce in output la frequenza delle parole nel file. La mappa mantiene le coppie (key,value) dove (key=parola,value=frequenza parola)


HashMap, TreeMap: esempioHashMap, TreeMap: esempio

java.util.StringTokenizerpermette di dividere una stringa nelle parole (token) che la costituiscono.

Il metodo nextToken restituisce il token successivo.


AlgoritmiAlgoritmi

La classe Collections fornisce metodi statici che impementano algoritmi di utilità. I principali sono:

Sorting: ordina gli elementi di una lista • static void sort(List list)

Shuffling: permuta in modo casuale gli elementi di una lista• static void shuffle(List list)

Reverse: inverte gli elementi di una lista • static void reverse(List list)

Fill: inserisce un oggetto in tutti gli elementi di una lista• static void fill(List list, Object obj)

Copy: copia il contenuto di una lista in un altra lista• static void copy(List dest, List src)

Searching: ricerca binaria di una chiave in una lista• static int binarySearch(List list, Object key)

Min e Max: • static Object min(Collection coll)• static Object max(Collection coll)


Relazioni d’ordineRelazioni d’ordineAlcuni metodi (es: sorting, min e max, e searching) si basano sull’ esistenza di una relazione d’ordine tra gli oggetti della lista. In altre parole: dati due oggetti A e B della lista deve essere possibile stabilire quali delle relazioni A>B;A=B;A<B sia vera.L’esistenza di una relazione d’ordine tra gli oggetti di una classe è rappresentata dall’implementazione dell’ interfaccia Comparable

Per molte classi (es:Integer, Double, Date, File, String,...) la relazione d’ordine naturale è nota e l’interfaccia Comparable è già implementata

E’ possibile usare i metodi della classe Collections con qualsiasi classi di oggetti per cui sia stata definita una relazione d’ordine naturale tramite l’implementazione dell’interfaccia Comparable.


Interfaccia Comparable: esempioInterfaccia Comparable: esempio

Programmazione Orientata agli OggettiProgrammazione Orientata agli Oggetti


ElaborazioneElaborazioneConcettiConcetti OO e OO e ModelloModello didi

ProgettoProgetto

Programmazione Orientata agli Oggetti - Andrea Bei 2

Concetti OOConcetti OOClasse

Rappresenta una classe di oggetti aventi le stesse caratteristiche strutturali e comportamentaliEs.: la classe “Automobile” rappresenta la classe degli oggetti che hanno 4 ruote, un motore, una marca, un modello (caratteristiche strutturali) e che possono accelerare, frenare, sterzare, fare retromarcia, fare rifornimento (caratteristiche comportamentali)

OggettoUn entità appartenente ad una classe.Es.: “Alfa 147”, ”Ford ka”, “Fiat Punto”, sono oggetti della classe “Automobile”

Attributi Definiscono le caratteristiche strutturali di una classe.Es: attributi della classe “Automobile” possono essere: motore, ruote, marca e modello

OperazioniDefiniscono le caratteristiche comportamentali di una classe. Es: accelera(), frena(), rifornimento(int litri), retromarcia(), sterza(intgradi)


Classi e oggettiClassi e oggetti

Classe “Libro”

L1,L2,L3: Oggetti o instanze dellaclasse “Libro”

Nome della classe

Attributi della classe (struttura)

Operazioni della classe (comportamento)copieAcquistate:copieDisponibili=copieDisponibili+numeroCopiecopieVendute:copieDisponibili=copieDisponibili-numeroCopiegetCopie restituisce il valore copieDisponibili

Nome oggetto: Classe

Valore degli attributi per il particolare oggetto della classe


Classi: definizione e notazioneClassi: definizione e notazioneDefinizione: è caratterizzata da

Identità: il nome della classeAttributi: sono l’astrazione delle proprietà comuni degli oggetti della classeOperazioni: definiscono il comportamento della classe. Sono i servizi che un oggetto della classe offre agli altri oggetti. Una operazione èdefinita dalla sua segnatura: nome, numero,ordine, tipo degli argomenti e tipo del valore ritornato. Un metodo è l’implementazione di una operazione in un linguaggio di programmazioneInterfaccia: è l’insieme delle operazioni visibili dagli altri oggetti (pubbliche)

Notazione UML

v specifica la visibilità dell’attributo o dell’operazione. Può essere uno dei simboli: + :Public, visibile da tutti gli altri oggetti- :Private, visibile solo dai metodi della classe# :Protected, visibile dai metodi della classe e delle sottoclassi% :Package, visibile dagli oggetti di classi dello stesso package della classe


Oggetto: definizione e notazioneOggetto: definizione e notazioneOggetto

E’caratterizzato da:• Identità: il nome dell’oggetto• Stato: comprende gli attributi e i valori degli attributi• Comportamento: definito dai metodi che usano gli attributi o ne

cambiano il valore

Notazione UMLVarie possibilità di scelta a seconda del livello di dettaglio del diagramma

Oggetto nominatoOggetto

anonimo

Oggetto constato visibile


InterfacceInterfacceDefinizione

una interfaccia è una specifica di comportamento: una classe che implementa una interfaccia fornisce una possibile realizzazione della specifica una interfaccia è definita da un insieme di operazioni astratte.la relazione che lega una interfaccia alla classe che la implementa si chiama “realizzazione”una interfaccia può ereditare operazioni da un’altra interfaccia

Notazione UML RealizzazioneLa classe “Elicottero”implementa l’interfaccia “IVolante” in quanto implementa tutte le sue operazioni (in questo caso “vaiA”)


Interfacce: notazioni UMLInterfacce: notazioni UML

«interface»Timer

getTime()

Clock1

...

getTime()... lollipop notation indicates Clock3 implements

and provides the Timer interface to clients

Timer is a provided interface

Timer

Clock3

...

getTime()...

Window2

Window3

dependency line notation

Window2 has a dependency on the Timer interface when it collaborates with a Clock2 object

socket line notation

Window3 has a dependency on the Timer interface when it collaborates with a Clock3 object

Window1 Timer

socket line notation

Window1 uses the Timer interface

it has a required interface

Clock2

...

getTime()...

Clock1 implements and provides the Timer interface

Timer

Notazione a socketWindow1 usa l’interfaccia TimerE’ una interfaccia richiesta

Clock1implementa l’interfaccia Timer.Timer è una interfaccia fornita da Clock1

La notazione a “lollipop” indica che Clock3 fornisce l’interfaccia Timer.Timer è una interfaccia fornita

Notazione di dipendenzaWindow2 ha una dipendenza con l’interfaccia Timer quando collabora con l’oggetto Clock2

Notazione a socketWindow3 ha una dipendenza con l’interfaccia Timer quando collabora con l’oggetto Clock3


Principi OOPrincipi OOIncapsulamento.

E’ la capacità di una classe di “incapsulare” insieme dati e operazioni sui dati

Information Hidingnascondere attributi e operazioni che rappresentano l’implementazione.mostrare solo le operazioni che devono essere visibili dagli altri oggetti.

EreditarietàE’ la possibilità di derivare una classe da una classe esistente “ereditando”da quest’ultima attributi e operazioni.La classe derivata è detta sottoclasse, la classe esistente superclasse.La sottoclasse può definire nuovi attributi e operazioni e ridefinire attributi e operazioni della superclasse sovrascrivendoli (Overriding)

PolimorfismoDal greco “pluralità di forme”: è la capacità di una cosa di assumere forme diverse a seconda del contesto.Nei linguaggi OO i tipi di polimorfismo sono 4: ad-hoc(coercion,overloading) e universale (per inclusione, parametrico)In Java ci si riferisce principalmente alla possibilità per una variabile di contenere valori di tipi diversi e per una operazione di eseguire implementazioni diverse a seconda del contesto (polimorfismo universale


Progettazione a oggettiProgettazione a oggetti

Approcci alla progettazione OO: Si progetta mentre si codifica

• Si progetta mentre si codifica (uso di IDE con strumenti di refactoring)Prima si progetta in UML e poi si codifica (il più comune)

• Si progetta in UML (a “mano libera” o con uno strumento CASE) e poi si codifica con un IDE

Prima si progetta in UML e poi si genera automaticamente il codice• Strumenti per la generazione automatica di codice da UML

Capacità necessarie per la progettazione OOLa progettazione OO richiede due capacità fondamentali

• Assegnare correttamente responsabilità agli oggetti• Conoscere e applicare i Design Pattern

I diagrammi UML sono solo una rappresentazione delle decisioni di progetto prese grazie alle competenze di cui sopra

Conoscere UML non significa sapere progettare ma saper rappresentare le scelte di progettazione


Progettazione a oggetti con UMLProgettazione a oggetti con UML

Modellazione dinamica: realizzazione di diagrammi dinamici quali interazione (sequenza o comunicazione), automi a stati, di attività

obiettivo: progettare la logica e il comportamento degli oggetti (i metodi)è la più importante perchè si individuano le responsabilità degli oggetti

Modellazione statica: realizzazione dei diagrammi delle classi, dei package e di deployment

obiettivo: progettare nomi delle classi e dei package, degli attributi e delle operazioni


Relazioni dinamiche tra oggetti: messaggiRelazioni dinamiche tra oggetti: messaggi

MessaggiUn messaggio è una relazione dinamica tra oggettiUn oggetto O1 spedisce un messaggio ad un oggetto O2 quando richiede all’oggetto O2 l’esecuzione di una operazioneGli oggetti che costituiscono un programma comunicano tra di loro mediante lo scambio di messaggiI messaggi vengono usati per mostrare questa comunicazione negliinteraction diagramI messaggi sono sincroni (il mittente si pone in attesa del risultato) oppure asincroni (il mittente continua l’esecuzione il risultato può non esserci)

asincrono sincrono


Modellazione dinamica: Diagrammi di interazioneModellazione dinamica: Diagrammi di interazione

Diagrammi di sequenza

Diagrammi di comunicazione

Diagrammi di sequenza e comunicazione sono isomorfi (èpossibile ricavare automaticamente l’uno dall’altro)

i diagrammi di sequenza danno enfasi alla sequenza temporale dei messaggi scambiatii diagrami di comunicazione danno enfasi alla comunicazione tra oggetti

: A myB : B

doTwo

doOne

doThree

Una possibile implementazione della classe A in Java

public class A {

private B myB;

public A(){myB=new B();}

public doOne(){myB.doTwo();myB.doThree();}}

: A

myB : B

1: doTwo

2: doThree

doOne


Esempi di diagrammi di interazioneEsempi di diagrammi di interazione: Register : Sale

makePayment(cashTendered)


: Paymentcreate(cashTendered)

Una possibile implementazione della classe Sale in Java

public class Sale {private Payment payment;

public makePayment(Money cashTendered){payment=new Payment(cashTendered)//...}}

1: makePayment(cashTendered)

1.1: create(cashTendered)

:Register :Sale

:Payment


direction of message

Sequenza

Comunicazione


NotazioneNotazione –– partecipantipartecipanti

sales: ArrayList<Sale>

:Sale s1 : Sale

lifeline box representing an instance of an ArrayList class, parameterized (templatized) to hold Sale objects

lifeline box representing an unnamed instance of class Sale

lifeline box representing a named instance

sales[ i ] : Sale

lifeline box representing one instance of class Sale, selected from the salesArrayList <Sale> collection

x : List

«metaclass»Font

lifeline box representing the class Font, or more precisely, that Font is an instance of class Class – an instance of a metaclass

related example

List is an interface

in UML 1.x we could not use an interface here, but in UML 2, this (or an abstract class) is legal

Istanza anonima della classe Sale

Istanza nominata della classe Sale. (il nome è s1)

Istanza di una metaclasse (Font èuna istanza della classe Class)

Istanza di una classe ArrayListparametrizzata per contenere oggetti di tipo Sale

Istanza di una classe Sale come elemento iesimo della lista sales

Esempio correlato

List è un interfaccia. In UML 2 èpossibile usare interfacce e classi astratte


Notazione Notazione –– linee di vitalinee di vita

: Register : Sale

doA

doB

doX

doC

doD

typical sychronous message shown with a filled-arrow line

a found message whose sender will not be specified

execution specification bar indicates focus of control

Un messaggio trovato: si chiama così un messaggio in cui viene omesso il partecipante da cui è generato

Specifica di esecuzione: rappresenta l’intervallo di tempo in cui il partecipante (in questo caso una istanza di Register) ha il controllo Un messaggio sincrono: E’ un

messaggio mostrato con una freccia piena.


Notazione Notazione –– messaggi self e valori di ritornomessaggi self e valori di ritorno

: Register : Sale

d1 = getDate

getDate

doX

aDate

Valori di ritorno:•si può etichettare il messaggio con var=nomeMessaggio(parametro)• Si può usare una freccia di ritorno tratteggiata etichettata con il valore di ritorno

: Register

doX

clear

Messaggio a this ( a se stesso )•si usa una freccia che parte dalla linea di specifica di esecuzione e rientra in una linea di specifica di esecuzione annidata rispetto alla prima


NotazioneNotazione –– creazionecreazione e e distruzionedistruzione: Register : Sale

makePayment(cashTendered): Paymentcreate(cashTendered)

authorize

note that newly created objects are placed at their creation "height"

: Sale

: Paymentcreate(cashTendered)

...the «destroy» stereotyped message, with the large X and short lifeline indicates explicit object destruction

«destroy» X

L’oggetto creato èmostrato alla stessa altezza del messaggio di creazionev

Una X sulla linea di vita rappresenta un messaggio di distruzione esplicita


Notazione Notazione -- FrameFrame

enterItem(itemID, quantity)

: B

endSale

a UML loop frame, with a boolean guard expression description, total

makeNewSale

[ more items ]loop

: A

Ciclo con un espressione di guardia booleana

calculate

: Bar

yy

xx

[ color = red ]opt

: Foo

Condizione con UML 2.0

[ color = red ] calculate

: Bar

yy

xx

: Foo

Condizione con UML 1.0


Notazione Notazione –– FrameFrameMessaggi condizionali mutuamente esclusivi(if .. then .. else)

: B: A

calculate

doX

: C

calculate

[ x < 10 ]alt

[ else ]

st = getSubtotal

lineItems[i] :SalesLineItem

t = getTotal

[ i < lineItems.size ]loop

: Sale This lifeline box represents one instance from a collection of many SalesLineItem objects.

lineItems[i] is the expression to select one element from the collection of many SalesLineItems; the ‘i” value refers to the same “i” in the guard in the LOOP frame

an action box may contain arbitrary language statements (in this case, incrementing ‘i’)

it is placed over the lifeline to which it applies

i++

Una istanza di SalesLineItem della collezione lineItems. il valore di i coincide con quello della guardia del frame loop

Una casella di azione può permettere di esplicitare una o più operazioni in un qualsiasi linguaggio

Iterazione su una collezione


:Register

authorizedoX

:Payment {abstract}

polymorphic message object in role of abstract superclass

:DebitPayment

doAauthorize

:Foo

stop at this point – don’t show any further details for this message

doB

:CreditPayment

doXauthorize

:Bar

Payment {abstract}

authorize() {abstract}...

CreditPayment

authorize()...

DebitPayment

authorize()...

Payment is an abstract superclass, with concrete subclasses that implement the polymorphic authorize operation

separate diagrams for each polymorphic concrete case

Notazione Notazione –– messaggi polimorfimessaggi polimorfiPayment è una classe astratta con delle sottoclassi che implementano il metodo astratto authorize

Messaggio polimorfo Oggetto nel suo ruolo di classe astratta

Non si prosegue ulteriormente nello scambio di messaggi perchè il seguito dipende dalla classe concreta che implementa authorize

Il seguito della interazione dipende dalla classe concreta sottoclasse di Payment. Si rappresentano tutti i casi possibili (in questo caso 2) DebitPayment e CreditPayment


Diagrammi di comunicazioneDiagrammi di comunicazione

1: makePayment(cashTendered)2: foo

2.1: bar: Register :Sale

link lineLink

1: msg22: msg33: msg4

3.1: msg5: Register :Sale

all messages flow on the same link

msg1

Tutti i messagi scorrono sullo stesso LinkOgni messaggio ha:•un numero•il nome•una freccia che indica la direzione


Notazione Notazione -- CreazioneCreazione

1: create(cashier)

: Register :Sale

create message, with optional initializing parameters. This will normally be interpreted as a constructor call.

«create»1: make(cashier)

: Register :Sale

if an unobvious creation message name is used, the message may be stereotyped for clarity

1: create(cashier)

: Register :Sale {new}

Three ways to show creation in a communication diagram

3 modi per mostrare la creazione di una nuova istanza in un diagramma di comunicazione messaggio di creazione con parametri (opzionali). Viene codificato

con l’invocazione di un costruttore

Se viene usato un messaggio di creazione non “ovvio” per chiarezza è possibile usare uno stereotipo


Notazione Notazione –– Numerazione legaleNumerazione legale: Amsg1 : B1: msg2

: C

1.1: msg3not numbered

legal numbering

: Amsg1 : B1: msg2

: C

1.1: msg3

2.1: msg5

2: msg4

: D

2.2: msg6

first second

fourth

sixth

fifth

third

Schema di numerazione legale.L’annidamento progressivo dei messaggi viene mostrato con la notazione punto

Il primo messaggio in genere non viene numerato per evitare un prefisso comune a tutti gli altri messaggi

Primo Secondo

Terzo

Quarto Quinto

Sesto


NotazioneNotazione –– messaggimessaggi condizionalicondizionali

1 [ color = red ] : calculate: Foo : Bar

message1

conditional message, with test

1a [test1] : msg2

: A : B

: C

1a.1: msg3

msg1

: D

1b [not test1] : msg4

1b.1: msg5

: E

2: msg6

unconditional after either msg2 or msg4 1a and 1b are mutually

exclusive conditional paths

Messaggio condizionale con Test

1a e 1b sono messaggi mutuamente esclusivi

Messaggio inviato comunque dopo 1°o 1b


Notazione: iterazione su collezioniNotazione: iterazione su collezioni

1 * [ i = 1..n ]: num = nextInt: SimulatorrunSimulation : Random

iteration is indicated with a * and an optional iteration clause following the sequence number

L’iterazione è indicata con il carattere * e una clausola di iterazione [i=1..n]


Notazione: messaggi polimorfiNotazione: messaggi polimorfi

:Register authorizedoX :Payment {abstract}

polymorphic message

object in role of abstract superclass

:DebitPayment

authorize

:Foo

stop at this point – don’t show any further details for this message

separate diagrams for each polymorphic concrete case

doAdoB :CreditPayment

authorize

:BardoX

Messaggio polimorfoNon si prosegue ulteriormente nello scambio di messaggi perchè il seguito dipende dalla classe concreta che implementa authorize

Oggetto nel ruolo di classe astratta

Il seguito della interazione dipende dalla classe concreta sottoclasse di Payment. Si rappresentano tutti i casi possibili (in questo caso 2) DebitPayment e CreditPayment


Modellazione statica: DCD (Design Class Modellazione statica: DCD (Design Class DiagramDiagram))

java.awt::Fontor

java.awt.Font

plain : Int = 0 { readOnly }bold : Int = 1 { readO nly }nam e : Stringstyle : Int = 0...

getFont(nam e : String) : FontgetNam e() : S tring...

«interface»Runnable

run()

- ellipsis “ ” m eans there m ay be elem ents, but not shown- a blank com partm ent offic ially m eans “unknown” but as a convention w ill be used to m ean “no m em bers”

SubclassFoo

...

run()...

SuperclassFooor

SuperC lassFoo { abstract }

- classOrStaticAttribute : Int+ publicAttribute : S tring- privateAttributeassum edPrivateAttributeisInitia lizedAttribute : Bool = trueaCollection : VeggieBurger [ * ]attributeM ayLegallyBeNull : S tring [0..1] finalConstantA ttribute : Int = 5 { readO nly }/derivedAttribute

+ classOrStaticM ethod()+ publicM ethod()assum edPublicM ethod()- privateM ethod()# protectedM ethod()~ packageVisibleM ethod()«constructor» SuperclassFoo( Long )m ethodW ithParm s(parm 1 : String, parm 2 : F loat)m ethodReturnsSom ething() : VeggieBurgerm ethodThrowsException () {exception IOException }abstractM ethod()abstractM ethod2() { abstract } // a lternatefinalM ethod() { leaf } // no override in subclasssynchronizedM ethod() { guarded }

3 com m on com partm ents

1. classifier nam e

2. attributes

3. operations

interface im plem entation andsubclassing

Fruit

...

...

PurchaseOrder

...

...

1

association w ith m ultiplicities

dependency

officially in UM L, the top form at is used to distinguish the package nam e from the class nam e

unofficially, the second alternative is com m on

order

an interface shown w ith a keyword

Un interfaccia mostrata con lo stereotipo <<interface>>

3 Sezioni:• Nome della classe• Attributi• Operazioni

Implementazione di interfaccia (linea tratteggiata) e eredita (subclassing) da una superclasse (linea continua)

I puntini mostrano che potrebbe esserci qualcosa ma non vogliamo mostrarlo. Il vuoto significa per ora sconosciuto

Associazione con molteplicità

Dipendenza

E’ possibile specificare il path della classe completo dei package in cui questa è contenuta


Relazioni tra classi nei DCDRelazioni tra classi nei DCD

Associazione

Dipendenza

Generalizzazione

Composizione

Aggregazione

Realizzazione (tra classi e interfacce)


AssociazioneAssociazioneNotazione UML

SemanticaModella una relazione di connessione strutturale tra classi:Un oggetto della classe A ha un riferimento ad uno o più oggetti della classe BL’associazione è la più generale delle relazioni e semanticamentela più debole. Specifica solamente il fatto che esiste una connessione tra le classi ma non esprime il tipo di connessione.Composizione e Aggregazione sono tipi particolari di

associazione. Sono semanticamente più forti in quanto descrivono meglio la realtà specificando il tipo di associazione.Quando il grado di conoscenza della realtà che si sta modellando lo consente è consigliabile usare una relazione semanticamentepiù forte. Si ottiene un modello con più alto potere espressivo


Associazione: notazioniAssociazione: notazioni

Register

...

...

Sale

...

...

1

Register

currentSale : Sale

...

Sale

...

...

using the attribute text notation to indicate Register has a reference to one Sale instance

using the association notation to indicate Register has a reference to one Sale instance

OBSERVE: this style visually emphasizes the connection between these classes currentSale

Register

currentSale : Sale

...

Sale

...

...

1thorough and unambiguous, but some people dislike the possible redundancy currentSale

Si inserisce un attributo di tipo Sale per indicare che Register ha un riferimento ad una istanza di tipo SaleLe classi sono associate ma visualmente separate

Si traccia una linea di associazione tra Register e Sale. Le classi sono visualmente connesse da una associazione. Questo rende immediatamente leggibile l’associazione

La forma più completa prevede insieme entrambe le forme precedentiattributo + linkVantaggio: chiarezzaSvantaggio: ridondanza di informazione

Si usa la notazione associazione per indicare che Register ha una istanza di Sale


Associazione: notazioniAssociazione: notazioni

Register

id: Int

...

Sale

time: DateTime

...

1applying the guideline to show attributes as attribute text versus as association lines

Store

address: Addressphone: PhoneNumber

...

1Register has THREE attributes:1. id2. currentSale3. location

currentSale

location

Linea GuidaMostrare gli attributi di tipi di dato semplici (interi, testo, float, ..) come attributi mentre gli quelli di tipo classe come associazioni

Register ha 3 attributi:1. Id2. currentSale3. location


DipendenzaDipendenzaNotazione UML

SemanticaModella una relazione di dipendenza

• Un cambiamento di comportamento nell’elemento fornitore (classe destinataria B) provoca un cambiamento di comportamento dell’elemento cliente (classe sorgente A)

• Un elemento cliente è a conoscenza di un elemento fornitoreSi ha una dipendenza tra le classi A e B se la classe A usa la classe B. Cioè se la classe B è un argomento di una delle operazioni della classe A oppure viene creata dalla classe A.Il concetto di dipendenza non esiste solo per la classi ma per tutti i modelli UML. Per esprimere il tipo di dipendenza si usano gli stereotipi. La dipendenza tra use case può essere di tipo <<include>> o <<extend>>Si ha una dipendenza tra la classe A e un oggetto che ne rappresenta un instanza. In questo caso si ha una dipendenza di tipo <<instanceOf>>

Classe “cliente” Classe “fornitore”


Associazione e Dipendenza: esempiAssociazione e Dipendenza: esempi

Associazione

Dipendenza


Associazioni: nome, molteplicitAssociazioni: nome, molteplicitàà e ruolie ruoliMolteplicità

Il numero di oggetti che partecipano alla associazione. In questo caso: una “Società”ha almeno una “Persona” nel ruolo di “Impiegato”.

Può essere: 1..*: 1 o più*: 0 o piùX..Y: un intervalloX: un numero esatto

Ruolo• Il ruolo che ha la classe nella associazione. • In questo caso la “Persona”assume il ruolo di “Impiegato”nell’associazione “Lavora Per”

Nome• Esprime il significato della associazione


Generalizzazione (Generalizzazione (EreditarietEreditarietàà))Notazione UML

SemanticaE’ una relazione tassonomica tra un classificatore più generale (superclasse) e un classificatore più specifico (sottoclasse)Ogni istanza della sottoclasse è anche una istanza della superclasseLa sottoclasse possiede indirettamente le caratteristiche strutturali (attributi) e comportamentali (operazioni) della superclasse (inrelazione alle regole di visibilità)Una generalizzazione in un DCD nei linguaggi OO si realizza con l’ereditarietà (B eredita da A)B è di tipo A (is-a, is-a-kind-of) B ha i propri attributi e metodi + gli attributi e operazioni ereditati da A (con visibilità public,protected)

Superclasse

Sottoclasse


Generalizzazione (Generalizzazione (EreditarietEreditarietàà))Esempio


Classi astratte: definizione e notazioneClassi astratte: definizione e notazioneDefinizione

Create per generalizzazione, rappresentano descrizioni "incomplete" diclassi. Il livello di astrazione non consente una implementazione per tutte le operazioni. Le operazioni non implementate sono chiamate astratteSi demanda alle sottoclassi “concrete” la responsabilità di realizzare il comportamento dichiarato dalla classe astratta (implementando leoperazioni astratte)Non è possibile istanziare una classe astratta. Non esistono oggetti di una classe astratta, ma possono esistere oggetti di una delle sottoclassi non astratte.Usate per definire operazioni comuni a più classi

Notazione UMLLe classi astratte sono caratterizzate dallo stereotipo <<abstract>>

La segnatura delle operazioni astratte èrappresentata in italico

Le operazioni astratte sono implementate in sottoclassi “concrete”


Classi astratte: esempioClassi astratte: esempio

La classe astratta “Veicolo Terrestre” definisce le caratteristiche comuni di tutti i veicoli terrestri ma nella realtà non esiste un “generico” veicolo terrestre. In altre parole non può essere creato nessun oggetto della classe “Veicolo Terrestre” (la classe non èistanziabile). Lo stesso vale per le altre classi astratte “Veicolo” e “Veicolo Aereo”Le classi “Automobile”, “Moto”, “Aereo” ed “Elicottero” sono invece classi istanziabili perche si riferiscono ad entità esistenti nel mondo reale di cui è possibile definire una implementazione per tutte le operazioni.


ComposizioneComposizioneNotazione UML

SemanticaModella una relazione di composizione di una o più parti: un oggetto della classe A è composto da uno o più oggetti della classe B. B è parte di A (relazione whole-part)Un oggetto della classe B esiste solo fino a quando esiste un oggetto della classe A di cui è una parteLa responsabilità della creazione di un oggetto della classe B èinteramente devoluta ad un oggetto della classe ALa classe componente (B) può avere una sola relazione di composizione nel ruolo di componente. La classe B non può essere la classe componente di un’altra classe oltre la A

Classe “composta” Classe “parte”


AggregazioneAggregazioneNotazione UML

SemanticaModella una relazione di aggregazione di una o più parti: un oggetto della classe A aggrega uno o più oggetti della classe BL’aggregazione è un vincolo più debole della composizioneOggetti della classe A mantengono riferimenti di oggetti della classe B ma gli oggetti della classe B esistono indipendentemente dagli oggetti della classe A. La vita di un oggetto della classe B è indipendente da quella di un oggetto della classe A

Classe “aggregata” Classe “parte”


Aggregazione e Composizione: esempiAggregazione e Composizione: esempiComposizione

Aggregazione

Class Diagram Object Diagram


Relazioni statiche tra oggetti: Relazioni statiche tra oggetti: linklinkLink

Un link è una relazione statica tra oggettiUn link tra un oggetto della classe A ed un oggetto della classe B indica che l’oggetto della classa A ha un riferimento ad un oggetto della classe BEsiste un link tra un oggetto della classe A ed un oggetto della classe B se esiste una associazione, composizione aggregazione o dipendenza tra classe A e classe B


Note e Stereotipi Note e Stereotipi Note

E’ possibile fornire informazioni su un elemento di un diagramma mediante una Nota. La Nota è a tutti gli effetti un elemento del linguaggio UML.

StereotipiE’ un nuovo elemento visuale derivato da uno esistente ma specifico per la propria realtà di interessePuò essere una icona o un nome tra parentesi angolate (<<nome>>)Es: in Java ci sono delle classi di tipo Exception la cui specificità d’uso ne giustifica la rappresentazione con un simbolo distinto da quello di classe.



Java: Costrutti Object Java: Costrutti Object OrientedOriented


Caratteristiche OO di JavaCaratteristiche OO di Java

Classi

Oggetti

Interfacce

Ereditarietà

Incapsulamento, Information Hiding, Polimorfismo

Packages


Programmare OO in Programmare OO in JavaJava

Programmare in Java “significa”:1. Definire classi e interfacce2. Creare degli oggetti delle classi definite3. Fare interagire tra loro gli oggetti per produrre

risultati

Osservazioni:In Java tutto è un oggetto tranne i tipi di dato predefiniti (int, char, ecc.)Le classi sono raggruppate in packageMolti package sono già disponibili


ClassiClassi

Una classe definisceun tipo di datoun insieme di operazioni sul tipo di datol’implementazione delle operazioni: i metodi

Esempio:class Serbatoio{

…}

class <nome_classe>{<definizioni di attributi><definizioni di metodi>} sintassi minimale


AttributiAttributi

Gli attributi di una classe definiscono la struttura dello stato degli oggetti della classe

Sintassi: ogni attributo è definito usando la stessa sintassi usata per la definizione delle variabili locali

Esempio:

class Serbatoio{

int livello;…

}


MetodiMetodi

<tipoRitornato> <nomeMetodo> ([<parametri>]){<body>

} sintassi minimale

I metodi sono le implementazioni delle operazioni della classe

implementano il comportamento degli oggetti della classe<tipoRitornato>=void per i metodi che non ritornano alcun valore

Esempio:void consumo (int j)

{

livello = livello-j;

}


CostruttoriCostruttori

I costruttori sono metodi particolari che hanno lo stesso nome della classe

I costruttori di una stessa classe si distinguono per numero, posizione o tipo dei parametriNei costruttori non deve essere indicato il tipo ritornato

Se non viene definito nessun costruttore viene usato automaticamente quello di default

Quando viene creato un oggetto di una classe viene invocato uno dei suoi costruttori

Nei costruttori viene inserito il codice di “inizializzazione” dell’oggetto


Esempio: la classe Serbatoio (UML)Esempio: la classe Serbatoio (UML)


Esempio: la classe Serbatoio (Java)Esempio: la classe Serbatoio (Java)


OggettiOggetti

Gli oggetti sono creati attraverso l’operatore new. Sintassi

new <nome classe>(<parametri costruttore>);

Semantica• Viene allocato lo spazio per il nuovo oggetto• Viene creato un oggetto della classe <nome classe> tramite il

costruttore che ha come argomenti: <parametri costruttore>• Viene ritornato un riferimento all’oggetto

Il costruttore di default è invocato tramite l’espressione:

new <nome classe>();

L’operazione di creazione restituisce un “riferimento” (handle o puntatore) all’oggetto tramite il quale viene usato l’oggetto


Creazione di un oggetto: esempioCreazione di un oggetto: esempio

//dichiarazione della variabile s//come riferimento ad un oggetto di //tipo String

String s;

//creazione di un oggetto String //e assegnazione del riferimento //dell’oggetto alla variabile s

s = new String (“Hallo”)

s null

sString(“Hallo”)


Creazione di un oggetto: esempio in BlueJCreazione di un oggetto: esempio in BlueJ

(1)

(2)

In BlueJ tramite l’interfaccia grafica posso creare oggetti (1) ed eseguire metodi sugli oggetti creati (2). Sono funzioni molto utili per testare le classi.


Uso degli oggetti: notazione puntoUso degli oggetti: notazione punto

L’accesso ad attributi e metodi di un oggetto si effettua tramite la notazione punto applicata ad un riferimento dell’oggetto.

Sintassi1. <riferimento>.<nome metodo>(<parametri>)2. <riferimento>.<nome attributo>Semantica1. Invoca il metodo <nome metodo>2. Accede all’attributo <nome attributo>

Esempio...int liv;Serbatoio s = new Serbatoio();liv = s.getLivello();System.out.println(liv);


Oggetti e riferimenti: esempioOggetti e riferimenti: esempio

s1Serbatoio S,S1;

S = new Serbatoio();

S1=S;

S1.rifornimento(10);

S.consumo(5);

S=null;

nulls nulls Serbatoio()

{livello=10} sSerbatoio(){livello=10}

s1Serbatoio(){livello=20}

s

s1s

Serbatoio(){livello=15}

s1

s1null

s1 Serbatoio(){livello=15}s

null


Oggetti e riferimenti: esempioOggetti e riferimenti: esempio

Creazione e uso di un oggetto della classe Serbatoio

Serbatoio S; // dichiarazioneS = new Serbatoio(); /* creazione:l'attributo livello

* vale 10 */S.consumo(5); // ora livello vale 5S.rifornimento(10); // livello vale 15

Riferimenti ad un oggetto della classe Serbatoio

Serbatoio S,S1; // dichiarazione, non creazioneS = new Serbatoio(); // S punta ad un oggetto SerbatoioS1=S; // S1 e S puntano allo stesso oggettoS1=null;S=null; // l’oggetto non più accessibile


Esempio: uso della classe SerbatoioEsempio: uso della classe Serbatoio


Distruzione diDistruzione di oggettioggetti

Java non supporta "distruttori" espliciti: gli oggetti che non hanno più riferimenti vengono eliminati automaticamente e la memoria che questi occupano viene liberata

String s; // dichiaraziones = new String ("abc"); // creazione: s punta a "abc“s = "def"; // "abc" non è più puntata da s

Questo viene fatto da un thread (garbage collector, o GC) che viene eseguito contemporaneamente ai threadutente e di sistema

Il programmatore non si deve preoccupare della deallocazione della memoria


Finalizzatori di oggettiFinalizzatori di oggetti

Per un oggetto potrebbero essere previste delle operazioni da effettuare prima della definitiva eliminazione (per esempio la chiusura di file aperti)

Prima di procedere alla eliminazione di un oggetto il GCinvoca il metodo dell’oggetto chiamato finalize,definibile dall’ utente

… void finalize () { close (); } // chiudi tutti i file aperti

Il metodo finalize esiste sempre: se non è stato ridefinito viene ereditato da Object la classe più generale nella gerarchia delle classi Java


ParametriParametri

Sintassi <parametri>=<tipo> <nomePar>[,<tipo> <nomePar>]Esempio:

int distanza(int x1,int y1,int x2,int y2)

Parametri attuali e formaliFormali: la lista dei parametri nella definizione del metodo (all’interno del metodo si parla di parametri formali)Attuali: la lista dei valori che vengono passati al metodo quando lo invochiamo (all’esterno del metodo si parla di parametri attuali)

…int a=5;Prova obj=new Prova();int b=obj.somma(4,a);…

parametri attuali

class Prova {…int somma(int x,int y) {int res=x+y;return res;} parametri formali


ParametriParametri

I parametri sono passati per valore: quando il metodo viene invocato, al parametro formale è assegnata una copia del valore del corrispondente parametro attuale.Per i parametri il cui tipo sia uno dei tipi semplici

Una modifica del valore del parametro formale non comporta una modifica del valore del parametro attuale.

Per i parametri il cui tipo sia un tipo riferimento (classi, interfacce e array).

Una modifica dell’oggetto puntato dal parametro formale comporta una modifica dell’oggetto puntato dal parametro attuale. Questo perchè il parametro formale e il parametro attuale hanno come valore un riferimento allo stesso oggetto.


Parametri: esempioParametri: esempio

class Robot {…void muoviti(int x,int y} {…x=20;}

…Robot r=new Robot();int asc=5;int ord=5;r.muoviti(asc,ord);System.out.println(asc);//stampa 5. “asc” NON cambia

tipi semplici

class Robot {…void muoviti(Punto p} {…p.x=20;}

…Robot r=new Robot();Punto pnt=new Punto();pnt.x=5;pnt.y=5;r. muoviti(pnt);System.out.println(pnt.x);// stampa 20

classi, interfacce, array


Visibilità dei nomi in una classeVisibilità dei nomi in una classe

I nomi degli attributi e dei metodi sono visibili da tutti i metodi della classeLe variabili locali ad un metodo o i parametri formali possono mascherare gli attributi. Es:

class Serbatoio {int livello; // attributo “livello” …void rifornimento (int livello) {

livello = livello+10; //sto modificando il valore del parametro formale livello //l’attributo “livello” rimane inalterato

}void consumo (int x) {

int livello;livello = livello-x; //sto modificando il valore della variabile locale //livello. L’attributo “livello” rimane inalterato

}…

}


Visibilità dei nomi in un bloccoVisibilità dei nomi in un bloccoLe variabili dichiarate in un blocco sono visibili solo all’interno del blocco. Es:

…{int x=0;System.out.println(x); //stampa 0}System.out.println(x); //errore: x non è visibile da qui

Le variabili dichiarate all’interno di un blocco possono mascherare gli attributi della classe. Es:

public class Esempio {private int x;public Esempio(){

x=5;}public void metodo(){{int x=0;System.out.println(x); //stampa 0}

System.out.println(x); //stampa 5 }}


Il riferimento Il riferimento thisthis

Il riferimento this è implicitamente presentein ogni oggetto e punta all’oggetto stesso

Permette di usare lo stesso nome per attributi e parametri. Es:

class Serbatoio {int livello; // attributoSerbatoio (int livello){ // parametrothis.livello = livello; //disambiguazione}}


OverloadingOverloading

All’interno di una classe ci possono essere più metodi con lo stesso nome, purchè si possano distinguere per numero, posizione o tipo dei parametri (il solo tipo di ritorno non basta)

Es:class Esempio {

...public int somma(int a, int b){ ... }; //OKpublic double somma(double a, double b){ ... }; //OKpublic int somma(double a, double b) { ... }; //errore

...}


Metodi e attributi staticiMetodi e attributi statici

Un attributo statico è una variabile associata alla classe (attributo di classe). Il valore dell’attributo è presente in copia unica ed è accessibile da tutti gli oggetti della classeUn metodo statico (di classe) è un metodo associato alla classe

può accedere ai soli attributi e metodi staticii metodi non statici possono accedere anche a metodi e attributi statici

SintassiDefinizione:

static <definizione attributo o metodo>

Accesso/Invocazione: (non è necessario creare un oggetto)<nomeClasse>.<nomeAttributo><nomeClasse>.<nomeMetodo>(<par.attuali>)


Metodi e attributi statici: esempioMetodi e attributi statici: esempio

Ogni volta che viene invocato il costruttore viene incrementata la variabile statica di 1.getNumeroDocumenti() è un metodo statico ed è invocato direttamente sul nome della classe (riga 10)


Quando si usano metodi e attributi staticiQuando si usano metodi e attributi staticiUn metodo che non dipende dallo stato dell’oggetto (non accede agli attributi non statici dell’ oggetto) è un buon candidato a diventare static

In genere nelle librerie di funzioni i metodi sono tutti statici (es: i metodi della classe Math)

Gli attributi il cui valore deve essere condiviso da tutti gli oggetti di una classe devono essere dichiarati static

In genere le costanti vengono dichiarate static


Attributi costantiAttributi costanti

Sintassifinal <definizioneAttributo> = <valore>

Esempio:class Colori {public static final int GIALLO = 0, ROSSO = 1,

…}



Java: Ereditarietà, classi Java: Ereditarietà, classi astratte e interfacceastratte e interfacce


Ereditarietà: la parola chiave Ereditarietà: la parola chiave extendsextends

Superclasse class B extends A

{

//definizione attributi

//definizione metodi

}

Sottoclasse

B eredita gli attributi ed i metodi della classe A (solo quelli consentiti dagli specificatori di visibilità)B può definire propri attributi e metodi B può ridefinire i metodi di A (Overriding).Java supporta solo l’ereditarietà singola.


Overriding dei metodiOverriding dei metodi

Una sottoclasse può aggiungere nuovi attributi e metodi ma anche ridefinire (override) i metodi dellesue superclassi

La classe “Pianoforte” eredita il metodo play e lo ridefinisce. Il metodo invocato sull’oggetto puntato da p è quello ridefinito daPianoforte.


Metodi finalMetodi final

Sintassi

Semantica i metodi final non possono essere ridefiniti dalle sottoclassi. Per tali metodi è vietato l’overriding

Esempio:class Colori {public static final int getColoreSfondo(...)}

final <tipoRitornato><nomeMetodo> ([<parametri>]){<body>

}


Classi finalClassi final

Sintassi

Semantica Le classi final non possono essere ereditate. Non possono avere sottoclassi

Esempio:final class Colori {

...}

final class NomeClasse [extends NomeSuperClasse]

{CorpoClasse}


Il riferimento Il riferimento supersuper

Il riferimento super viene usato per riferirsi alla superclasse

Per riferirsi a variabili, metodi o costruttori della superclasse (anche quelli sovrascritti dalla sottoclasse)Spesso si invoca il costruttore della superclasse dal costruttore della sottoclasse.

Sintassi:Invocazione di un metodo della superclassesuper.<nomeMetodo>(<listaParamAttuali>);

Accesso ad un attributo della superclassesuper. <nomeAttributo>;


Ereditarietà e costruttoriEreditarietà e costruttori

I costruttori non vengono ereditati

All’interno di un costruttore è possibile richiamare il costruttore della superclasse tramite l’istruzione super(<listaParametriAttuali>)posta come prima istruzione del costruttore

Se il programmatore non chiama esplicitamente un costruttore della superclasse, il compilatore inserisce automaticamente il codice che invoca il costruttore di default della superclasse


La classe La classe ObjectObject

Tutte le classi discendono dalla classe Object

Se una classe non eredita esplicitamente da una superclasse allora eredita implicitamente dalla classe Object

La classe Object fornisce i seguenti metodi:boolean equals(Object);: true se due riferimenti sono aliasString toString();: restituisce una stringa di caratteri contenente il nome della classe e un valore che identifica l’oggetto univocamente


Ereditarietà: un esempioEreditarietà: un esempio


Classi AstratteClassi Astratte

Una classe astratta definisce un tipo di datoun insieme di operazioni sul tipo di dato

• alcune operazioni sono implementate: metodi• alcune operazioni non sono implementate: metodi astratti

(abstract)

Una classe astratta non può essere istanziata ma è possibile derivarne sottoclassiUna classe che ha un metodo abstract deve essere definita abstract

abstract class <nome_classe {


//definizione costruttori e metodi

//definizione metodi astratti

}


Classi AstratteClassi Astratte


Interfacce: definizioneInterfacce: definizione

interface Int {

//definizione operazioni

}

Una interfaccia definisce un tipo di datoun insieme di operazioni sul tipo di dato

Le interfacce possono ereditare da altre interfacce (extends)Esempio:

public interface Iconizable {void iconize (); // iconizza

}public interface Resizable {

void resize (int width,int height); // ridimensiona}


Interfacce: implementazioneInterfacce: implementazione

class A implements Int1,Int2,…, IntN

{


//implementazione metodi di Int1,Int2, … IntN

//implementazione altri metodi di A

}

Una classe che dichiara di implementare un insieme di interfacce ha l’obbligo di implementare tutti metodi delle interfacce (altrimenti … errore di compilazione)Esempio:class Window implements Iconizable,Resizable {void iconize (){ <body> }void resize (int width,int height) { <body> }}


Interfacce: usoInterfacce: uso

Le interfacce consentono la separazione tra operazioni (specifiche di comportamento) e metodi (implementazione)

La classe “B” non usa direttamente la classe “A” (“B” non dipende da “A”) ma usa “Int”: una interfaccia implementata da A. Posso sostituire in “MainProgram” la classe “A” con un altra classe che implementa “Int” senza dovere modificare la classe “B”



Java: Incapsulamento, Java: Incapsulamento, Information Hiding, Information Hiding,

PolimorfismoPolimorfismo


Incapsulamento e Information HidingIncapsulamento e Information Hiding

IncapsulamentoTenere insieme (incapsulare) dati e operazioni sui datiI linguaggi OO supportano l’incapsulamento con il

costrutto di classe (Dati= attributi, Operazioni sui dati=metodi)

Information HidingNascondere i dettagli implementativi agli utenti della classe. Evitare che gli utenti abbiano la necessità di conoscere come una classe è implementata al fine di poterla usare.

Spesso sono usati come sinonimi. In realtà:L’ incapsulamento facilita ma non garantisce l’information hidingIn Java ci può essere incapsulamento ma non information hiding


Information Hiding: modificatori di visibilitàInformation Hiding: modificatori di visibilità<modificatore>[static][final]<tipoRitornato><nomeMetodo> ([<parametri>])

{ <body> }Metodi: sintassi completa

<modificatore>[static][final]<tipo><identificatore>[=<valore>][,<identificatore>[=<valore>]…]

Variabili: sintassi completaDescrizione<modificatore>

accessibile ai metodi della classe in cui è usatoprivate

accessibile ai metodi della classe in cui è usatoaccessibile ai metodi di classi dello stesso package della classe in

cui è usato

accessibile ai metodi della classe in cui è usatoaccessibile ai metodi delle sottoclassi della classe in cui è usatoaccessibile ai metodi di classi dello stesso package della classe in

cui è usato

protected

accessibile ai metodi della classe in cui è usatoaccessibile ai metodi di altre classi

public


Incapsulamento e Information Hiding: Incapsulamento e Information Hiding: regoleregole

IncapsulamentoInserire nella stessa classe i dati e le operazioni sui datiProgettare in base alle responsabilità

• Lasciarsi guidare dalle operazioni: chiedersi quali sono le azioni di cui dovrebbe essere responsabile un oggetto della classe

Information HidingNon esporre i dati

• Dichiarare “privati” tutti gli attributi e usare metodi “getter” e “setter”

Non esporre la differenza tra attributi e dati derivati• Se velocità è un dato calcolato da altri attributi chiamare

comunque il metodo getVelocità() piuttosto che calcolaVelocità()

Non esporre la struttura interna della classe• Evitare metodi come getDataArray()


No incapsulamento: i dati (x e y) e le operazioni sui dati (distanza(..)) non sono nella stessa classe

Incapsulamento e Information Hiding: Incapsulamento e Information Hiding: esempioesempio

No information hiding: i dati (x e y) non sono nascosti agli utenti della classe



Incapsulamento: i dati (x e y) e le operazioni sui dati (distanza(..)) ora sono nella stessa classe Punto.

No Information HidingUno dei limiti è l’impossibilità di “controllare” che il valore assegnato a x e y sia compreso in un certo intervallo.Es: supponiamo di voler gestire uno spazio bidimensionale “circolare” in cui x sia in [0,100] e y sia in [0,100] e x=105 venga trasformato in x=5

N.B.La funzione distanza ora ha un solo argomento. L’altro argomento è l’oggetto stesso su cui è invocato il metodo.



Incapsulamento e Information Hiding soddisfattiOperazioni e dati sono in un’unica classe e i dati sono nascosti (“private”) e accessibili solo tramite i metodi getter e setter. In questo modo “isolo” le classi utente (“MainClass”) anche dai futuri cambiamenti nei dati della classe Punto. Per esempio cambiare la dimensione dello spazio da 100 a 50 non influenza MainClass

Information Hiding


Tipi, sottotipi e supertipiTipi, sottotipi e supertipiClassi e interfacce definiscono dei tipi di dato

I supertipi di una classe sono:Tutte le interfacce implementate direttamente e indirettamente dalla classeTutte le superclassi della classeEs: (fig.1) C,B,Int2,Int3,Int4 sono supertipi di A

I supertipi di una interfaccia sono:Tutte le interfacce da cui eredita l’interfacciaEs: (fig.1) Int4 è un supertipo di Int3

I sottotipi di una classe sono:Tutte le sottoclassiEs: (fig.1) B e A sono sottotipi di C

I sottotipi di una interfaccia sono:Tutte le interfacce che ereditano dall’interfacciaTutte le classi che implementano direttamente o indirettamente l’interfaccia stessa o una delle interfacce che eredita dall’interfacciaEs: (fig.2) B,D,Int3,E,C e A sono sottotipi di Int4

Fig.1

Fig.2


Polimorfismo per inclusione: Polimorfismo per inclusione: variabili polimorfevariabili polimorfe

Possibilità di usare variabili polimorfe, cioè che possono riferirsi ad oggetti di tipi diversi ("inclusi" in una certa gerarchia). In pratica ad una variabile di tipo T è possibile assegnare il riferimento ad un qualsiasi sottotipo di T. Esempio:


Polimorfismo per inclusione:Polimorfismo per inclusione:variabili polimorfe (esempio)variabili polimorfe (esempio)

Ad un riferimento di un classe (tipo) può essere assegnato un riferimento ad una sottoclasse (sottotipo )


Polimorfismo per inclusione: Polimorfismo per inclusione: mascheramento dei metodimascheramento dei metodi

Sulla variabile di tipo T è possibile invocare solo metodi e attributi definiti in T anche se la variabile si riferisce ad unsottotipo con più metodi e attributi.

A rif=new A(); B rif =new A();

Classe C

Classe B

Classe A

Oggetto A

Variabilerif


Polimorfismo per inclusione: Polimorfismo per inclusione: mascheramento dei metodimascheramento dei metodi

ERRORE

Da un riferimento di un tipo non può essere invocato un metodo di un sottotipoNon posso invocare “retromarcia” su un riferimento di tipo “VeicoloAMotore”


Polimorfismo per inclusione: castingPolimorfismo per inclusione: castingSe la variabile che contiene il riferimento all’oggetto è di un supertipo del tipo dell’oggetto è possibile con l’operazione di “Casting” ottenere un riferimento al tipo dell’oggetto.Sintassi:

<rifSottotipo>=(<rifSottotipo>) <rifSupertipo>Esempio:

“fordKa” è di tipo “VeicoloAMotore” ma è assegnata ad un oggetto di tipo “Automobile”. Per ottenere un riferimento di tipo “Automobile” si effettua il casting (riga 16). Sul riferimento ottenuto dal casting posso invocare il metodo “retromarcia”.


Polimorfismo per inclusione: Polimorfismo per inclusione: metodi polimorfi e binding dinamico 1/2metodi polimorfi e binding dinamico 1/2

Possibilità di usare metodi polimorfi: cioè di indicare con lo stesso nome dei metodi che appartengono a classi diverse (“incluse” nella stessa gerarchia) e che hanno quindi generalmente diverse implementazioni ("polimorfo" = "avente più forme").Scenario:

Una variabile “var” di tipo T è assegnata ad un oggetto di un sottotipo di T S(T)T e S(T) definiscono entrambi il metodo “metodo1()”.L’istruzione “var.metodo1()” ’esegue il metodo definito in S(T).

la decisione su quale debba essere il metodo da richiamare viene presa a tempo di esecuzione a seconda della classe effettiva (più stretta) di appartenenza dell'oggetto rispetto a cui viene fatta la chiamata. Questa tecnica è chiamata binding dinamico


Polimorfismo per inclusione: Polimorfismo per inclusione: metodi polimorfi e binding dinamico 2/2metodi polimorfi e binding dinamico 2/2

Attenzione !Il Binding Dinamico vale solo per i metodi e NON per gli attributi


Polimorfismo per inclusione: Polimorfismo per inclusione: parametri polimorfiparametri polimorfi

Il metodo “ripara” ha un parametro polimorfo di tipo “VeicoloAMotore”. Il parametro assume i sottotipi “Scooter” e “Automobile”.


Polimorfismo per inclusione:instanceofPolimorfismo per inclusione:instanceofE’ possibile identificare a run-time il tipo effettivo dell’oggetto a cui si riferisce una variabile (RTTI:Run-Time Type Identification) Sintassi:

true/false=<variabile> instanceof <nomeClasse>Esempio:

Se il parametro m di tipo VeicoloAMotore punta ad un oggetto di tipo “Automobile” (test a riga 9) posso effettuare il casting per ottenere un riferimento di tipo Automobile (riga 10) e poter invocare il metodo retromarcia (riga 11)


Come usare il polimorfismoCome usare il polimorfismo

Per creare strutture dati polimorfeSono strutture dati che gestiscono oggetti generici (oggetti della classe Object). Grazie al polimorfismo possono gestire ogni sottotipo di Object e quindi qualsiasi tipo di oggettoAlta riusabilità

Con classi astratte e interfacce per conferire estendibilità manutenibilità e riusabilità al codice

Definendo tipi astratti (classi astratte e interfacce) • per i concetti che hanno probabilità di essere estesi in futuro• per le classi che sono maggiormente usate da altre classi (parametri di

metodi di altre classi)

Usando ogni volta che è possibile parametri astratti (interfacce o classi astratte) per i metodi. Questo significa:

• massimizzare il numero dei tipi su cui è possibile invocare il metodo (es: strutture dati polimorfe)

• renderlo “resistente” a future estensioni che aggiungano dei sottotipi al tipo dei parametri.


Strutture dati polimorfe: matrice di oggettiStrutture dati polimorfe: matrice di oggetti

La classe Matrix è una matrice polimorfa. La struttura dati è un array bidimensionale di elementi di tipo Object ed i metod get e set trattano parametri di tipo Object. Per il polimorfismo è possibile popolare Matrix con qualsiasi oggetto che sia sottotipo di Object e quindi con oggetti di qualsiasi classe.Le classi Integer e Float sono dette “Wrapper” perchè “avvolgono” i tipi atomici int e float rendendoli oggetti.


Polimorfismo, interfacce e classi astratte: Polimorfismo, interfacce e classi astratte: alternative per il progetto di un mediaalternative per il progetto di un media--playerplayer

1° alternativa:• Il media-player ha un metodo per ogni formato con l’implementazione

del relativo CODEC• Per ogni formato esiste una classe con lo stream dei dati e con le

caratteristiche specifiche per il formato

Caratteristiche1. Bassa estendibilità: Se aggiungo un altro

formato (es:MIDI) devo modificare la classe MediaPlayer per inserire il metodo “play” del nuovo formato (es:playMIDI).

2. Bassa riusabilità (interna e esterna)1. Non uso ereditarietà: Alcuni attributi e metodi

sono identici nei formati audio (es: titolo,durata,stream). Se in futuro dovrò aggiungere un formato dovrò riscrivere da zero anche i metodi e gli attributi comuni

2. Non uso l’incapsulamento: Ho i dati (“stream”) e le operazioni sui dati (“play”) in classi diverse. Non posso riusare MP3 in un altra applicazione mi mancherebbero le operazioni



2° alternativa:• Ogni classe “formato” ha un proprio metodo play con l’implementazione

del CODEC per il proprio formato• Si introduce una classe astratta AudioMedia che fattorizza le poprietà e i

metodi comuni alle classi “formato” (ereditarietà)• La classe mediaplayer ha un solo metodo play che ha come parametro

AudioMedia (polimorfismo)Caratteristiche

1. Media estendibilità: Se aggiungo un altro formato audio (es:MIDI) non devo modificare la classe MediaPlayer. Mi basta aggiungere una classe MIDI che eredita dalla classe AudioMedia e implementa il metodo play e tutto funziona correttamente. Ma se voglio aggiungere un formato Video ? Il problema è che uso la classe astratta per due funzioni contemporaneamente: riuso (ereditarietà) e estendibilità (polimorfismo)

2. Alta riusabilità (interna e esterna)1. Esterna: Ogni classe “formato” è riusabile

perche completa (dati e operazioni)2. Interna: Riuso attributi e operazioni comuni

(ereditarietà)



3° alternativa:• Rispetto alla seconda alternativa si introduce l’interfaccia Media con la quale

si ottiene l’estendibilità a livello più astratto possibile• La classe astratta AudioMedia implementa l’interfaccia Media• La classe MediaPlayer ha un solo metodo play che ha come parametro

l’interfaccia Media (polimorfismo)Caratteristiche

Alta estendibilità: Ora posso aggiungere anche un formato Video (es: AVI) semplicemente aggiungendo la classe AVI e implementando l’interfaccia “Media”. Uso la classe astratta per il riuso interno (con l’ereditarietà) e l’interfaccia per l’ estendibilità (con il polimorfismo)

Best PracticesCercare di utilizzare principalmente le interfacce come strumento per l’estendibilità (tramite il polimorfismo) eventualmente associate alle classi astratte come strumento di riusabilità interna (tramite l’ereditarietà)



Java: PackageJava: Package


Contenitori di classi e interfacce organizzati in modo gerarchicoAd ogni package corrisponde una directory nel file systemSintassi del percorso completo di una classe o interfaccia:

<package 1>.<package 2>…<package N>.<Classe/Interf.>

Package: definizionePackage: definizione

Percorso completo della classe OracleAlertsDAO:it.cnr.helpdesk.AlertsManagement.dao.OracleAlertsDAO

UML Nel file system


Per usare una classe di un package (2 alternative):specificare ogni volta il percorso completo

• Altamente sconsigliata (dispendiosa, bassa manutenibilità)importare la classe e usare il nome della classe

• sintassi (per una classe):import <package 1>.<package 2> … <nomeClasse>;

• sintassi (per tutte le classi di un package ) :import <package 1>.<package 2> … <package N>.*;

• Le istruzioni import vanno prima della dichiarazione della classe

I package predefiniti nel JSDK sono del tipo:java.*, javax.*, org.* (es: java.math.*)java.lang.* contiene le classi fondamentali ed è importato implicitamente

Package: usoPackage: uso


Package: uso (esempio)Package: uso (esempio)La classe Random è responsabile della generazione di numeri casuali ed è presente nel package java.util.*;


Il package a cui una classe appartiene è specificato nella prima istruzione del file sorgente in cui è definita la classe

Sintassi:package pkg1[.pkg2]…[.pkgN];

L’istruzione package va inserita prima delle istruzioni import

Esempio:

Package: dichiarazionePackage: dichiarazione


Package: dichiarazione (esempio in Package: dichiarazione (esempio in BlueJBlueJ))

BlueJ aggiunge automaticamente l’istruzione package in base al package da cui si crea la classe


Da un programma sono visibili solo i packagela cui directory base è specificata nel classpath•SET CLASSPATH=…;c:\MyPackages;…

la cui directory base è aggiunta come “libreria” (IDE)

In BlueJ è possibile aggiungere le directory base dei packages come “librerie” :

Package: visibilitPackage: visibilitàà


ClassiClassi: : sintassisintassi completacompleta

[Commento][Modificatore] class NomeClasse

[extends NomeSuperClasse]

[implements NomeInterfaccia [, NomeInterfaccia ]]

{CorpoClasse}

Modificatoreabstract: tra i vari metodi, deve contenerne almeno unoastratto, ma non può contenere metodi privati o statici; devedare origine a sottoclassi; non può essere istanziatafinal: termina una catena di classi-sottoclassi, non può dare origine a ulteriori sottoclassipublic: può essere usata da altre classi nel package che necontiene la dichiarazione senza formalità; disponibile anche in altri package, purchè vi venga importatasynchronizable: tutti i metodi interni sono "sincronizzati”


Interfacce: sintassi completaInterfacce: sintassi completa

Modificatorepublic: visibile dalle classi di tutti i packagenessun qualificatore: visibile solo nel package in cui èdefinita

InterfaceBodydichiarazione dei metodi (sono implicitamente abstract )dichiarazione delle costanti (sono implicitamente final, static e public)

[Commento][Modificatore] interface NomeInterfaccia

[extends NomeSuperInterfaccia[, NomeSuperInterfaccia]]

{CorpoInterfaccia}



StringheStringhe


Utilizzo delle stringhe in JavaUtilizzo delle stringhe in Java

In Java si possono utilizzare e gestire le stringhe tramite le due classi:

String• Un oggetto di tipo String è una stringa costante

StringBuffer• Un oggetto di tipo StringBuffer è una stringa variabile

nel contenuto e nella dimensione.

• Meno “economico” di String.


La classe La classe StringString: costruttori: costruttori

La creazione di una oggetto String può essere:

Esplicita: Attraverso il costruttore polimorfo String()Es. String S= new String(“parola”);

String S= new String();

Implicita: Quando il compilatore incontra una serie di caratteri delimitati da virgolette crea un oggetto di tipo String a cui assegna la stringa individuata.Es. String S = “parola”; //equivale a

String S = new String(“parola”);


La classe La classe StringString: i metodi principali: i metodi principali

In riferimento a: String s = “parola”length(): ritorna la lunghezza della stringa Es: int len = s.length(); // len == 6

charAt(int i): ritorna il carattere in posizione i-esima Es: char c=s.charAt(0) // c ==‘p’

indexOf(char c): ritorna l’indice della prima occorrenza del carattere indicatoEs: int i=s.indexOf(‘o’) // i == 3

lastIndexOf(char c): come sopra ma per l’ultima occorrenza di charsubstring(int da, int a): ritorna una sottostringa Es: String sub = s.substring(2,4) // sub==“ro”


La classe La classe StringString: concatenazione: concatenazione

E’ possibile concatenare stringhe tramite l’operatore +

Esempio: String s =“Prova ”+“di”+” concatenazione”;System.out.println(s);

Output:

Prova di concatenazione


La classe La classe StringBufferStringBuffer: costruttori: costruttori

I costruttori della classe StringBuffer sono:

StringBuffer()Restituisce uno StringBuffer di capacità 16StringBuffer(int c)Restituisce uno StringBuffer di capacità cStringBuffer(String s)Restituisce uno StringBuffer contenente s e di capacità s.legth() + 16

Es:StringBuffer s = new StringBuffer(“parola”);


La classe La classe StringBufferStringBuffer: i metodi: i metodi

Oltre ai metodi definiti nella classe String e all’operatore di concatenazione (+) definisce iseguenti metodi per la manipolazione di stringhe:

append(char c): aggiunge in coda il carattere cEs: s.append(‘a’);insert(int offset, char c): inserisce in posizioneoffset+1 il carattere csetCharAt(int pos, char c): sovrascrive il carattere inposizione pos con ccapacity(): restituisce la quantità di spazio allocatosetLength(int length): imposta la dimensione della stringa a length


Esempio: inversione di una stringaEsempio: inversione di una stringa

Corso JavaCorso Java


WrapperWrapper


Le classi wrapperLe classi wrapper

Le classi wrapper sono classi “involucro” per i tipi atomiciservono per poter trattare come oggetti i tipi atomici. Sono necessarie per poter usare strutture dati per Object con interi,booleani,float

num

numObj

Esempio...Matrix m=new Matrix(3,3);int num=10;Integer numObj=new Integer(num);...m.set(2,2, numObj);...int i=((Integer) m.get(2,2)).intValue();


La gerarchia dei wrapperLa gerarchia dei wrapper

boolean char

doublebyte

short float

longint


La classe Integer: costruttoriLa classe Integer: costruttori

public Integer(int num)Esempio:

Integer num = new Integer(10);

public Integer(String s)Esempio:

Integer num = new Integer(“10”);


La classe Integer: metodi principaliLa classe Integer: metodi principalipublic int intValue()

descrizione: ritorna il valore rappresentato dall’oggetto in formato intesempio:int num = (new Integer(10)).intValue(); //num=10

public String toString()descrizione: ritorna il valore rappresentato dall’oggetto in formato Stringesempio:String s = (new Integer(10)).toString(); //s=“10”

public static Integer valueOf(String s)descrizione: ritorna un Integer rappresentato dall’intero in sesempio:Integer num = Integer.valueOf(“10”); //num.intValue=10

public static int parseInt(String s)descrizione: ritorna un int del valore dell’intero in sesempio:int num = Integer.parseInt(“10”); //num=10

Programmazione Orientata agli OggettiProgrammazione Orientata agli Oggetti


ModelloModello didiimplementazioneimplementazione


Modello di implementazioneModello di implementazione

Un Modello di Implementazione è costituito dall’insieme dei sorgenti che implementano un Modello di ProgettoLinee guida per passare dal modello di progetto al modello di implementazione

Progettare la visibilitàCreare classi e interfacce dai DCDCreare metodi dai diagrammi di interazioneUsare collezioni per implementare relazioni uno a molti tra classiSeguire un ordine di implementazione guidato sull’accoppiamento


Progettare la visibilitProgettare la visibilitàà

Un oggetto A può inviare un messaggio ad un oggetto B solo se questo è visibile ad A4 tipi di visibilità da A verso B

Per attributo • B è un attributo di A

Per parametro • B è un parametro di un metodo di A

Locale • B è un oggetto locale di un metodo di A

Globale • B è visibile globalmente


VisibilitVisibilitàà per attributoper attributo

: RegisterenterItem

(itemID, quantity)

: ProductCatalog

desc = getProductDesc( itemID )

public void enterItem( itemID, qty ){ ... desc = catalog.getProductDesc(itemID) ...}

class Register{ ... private ProductCatalog catalog; ...}


VisibilitVisibilitàà per parametroper parametro

2: makeLineItem(desc, qty)enterItem(id, qty)

1: desc = getProductDesc(id)2.1: create(desc, qty)

:Register :Sale

:ProductCatalog

sl : SalesLineItemmakeLineItem(ProductDescription desc, int qty){ ... sl = new SalesLineItem(desc, qty); ...}


VisibilitVisibilitàà per parametro per parametro --> attributo> attributo


2: desc = getProductDesc(id)2.1: create(desc, qty)

:Register :Sale

:ProductCatalog

sl : SalesLineItem// initializing method (e.g., a Java constructor)SalesLineItem(ProductDescription desc, int qty){ ...description = desc; // parameter to attribute visibility...}

E’ comune trasformare la visibilità per parametro in visibilità per attributo soprattutto nel caso di parametri passati ai costruttori


VisibilitVisibilitàà localelocale

: RegisterenterItem

(itemID, quantity)

: ProductCatalog

desc = getProductDesc( itemID )

enterItem(id, qty){ ...// local visibility via assignment of returning objectProductDescription desc = catalog.getProductDes(id);...}


Creare classi e interfacce dai DCDCreare classi e interfacce dai DCDI DCD descrivono

nomi delle classi e delle interfaccele firme delle operazionigli attributi delle classi

A partire dai DCD è possibile descrivere la definizione di base di classi e metodi

alcuni strumenti UML producono automaticamente la definizione di base

public class SalesLineItem{private int quantity;

private ProductDescription description;

public SalesLineItem(ProductDescription desc, int qty) { ... }

public Money getSubtotal() { ... }

}

SalesLineItem

quantity : Integer

getSubtotal() : Money

ProductDescription

description : Textprice : MoneyitemID : ItemID

...

1

description


Creare metodi dai diagrammi di interazioneCreare metodi dai diagrammi di interazione

Ogni messaggio all’interno di un metodo ètrasformato in una istruzione


1: desc = getProductDesc(id) 2.1: create(desc, qty)

1.1: desc = get(id)

:Register :Sale

:ProductCatalog

sl: SalesLineItem

lineItems : List<SalesLineItem>: Map<ProductDescription>

2.2: add(sl)

class Register {...private ProductCatalog catalog;public void enterItem(ItemID id,int qty) {

ProductDescription desc=catalog.getProdutDesc(id);currentSale.makeLineItem(desc,qty);

}...


Collezioni per relazioni uno a molti Collezioni per relazioni uno a molti

Implementare le relazioni uno a molti tra classi con le collezioni

in Java: List, Set, Map

SalesLineItem

quantity : Integer

getSubtotal()1..*

Sale

isComplete : Booleantime : DateTime

becomeComplete()makeLineItem()makePayment()getTtotal()

public class Sale{...

private List lineItems = new ArrayList();}

A collection class is necessary to maintain attribute visibility to all the SalesLineItems.

lineItems

Le classi collezione sono necessarie per mantenere la visibilità per attributo di tutte le SalesLineItem


Seguire un ordine di implementazioneSeguire un ordine di implementazione

Implementare le classi dalla meno accoppiata alla più accoppiata

SalesLineItem

quantity : Integer

getSubtotal()

ProductCatalog

...

getProductDesc(...)

ProductDescription

description : Textprice : MoneyitemID : ItemID

...

Store

address : Addressname : Text

addSale(...)

Payment

amount : Money

...

1..*

1..*

Register

...

endSale()enterItem(...)makeNewSale()makePayment(...)

Sale

isComplete : Booleantime : DateTime

becomeComplete()makeLineItem(...)makePayment(...)getTotal()...

1

1

1

1

1

1

* 1

23

4

56

7Acc=0

Acc=0

Acc=1

Acc=1

Acc=2Acc=2

Acc=3


Caso di studio POS:modello di implementazioneCaso di studio POS:modello di implementazione

1: Payment

2: ProductSpecification (è ProductDescription)


Caso di studio POS:modello di implementazioneCaso di studio POS:modello di implementazione3: ProductCatalog

4: SalesLineItem


Caso di studio POS:modello di implementazioneCaso di studio POS:modello di implementazione5: Sale


Caso di studio POS:modello di implementazioneCaso di studio POS:modello di implementazione6: Register

6: Store



Gestione delle eccezioniGestione delle eccezioni


EccezioniEccezioni

Un’eccezione è un evento imprevisto anomalo e indesiderato che non consente la normale prosecuzione del programma.

Es: apertura di un file inesistente, divisione per 0, indice di un’array al di fuori dell’intervallo consentito

Affinchè un programma sia robusto è necessario prevedere le possibili eccezioni e come queste dovranno essere gestite

La mancata gestione delle eccezioni può comportare:

terminazione improvvisa del programmacomportamenti e risultati scorretti e imprevedibili


Gestione tradizionale delle eccezioniGestione tradizionale delle eccezioni

Nei linguaggi tradizionali non esistono costrutti ad-hoc per la gestione delle eccezioni. Queste sono gestite:

Terminando l’esecuzione del programma • spesso non è necessaria una scelta così drastica

Usando valori di ritorno particolari (es: -1) per segnalare il tipo di eccezione alla funzione/metodo chiamante

• confusione tra dati ed eccezioni se il tipo è lo stesso• informazioni limitate sulle eccezioni

Usando una apposita funzione/metodo che gestisce le eccezioni• diminuisce la manutenibilità del programma. Il codice in cui viene gestito

l’eccezione è “lontano” dal codice che lo può generare• diminuisce la leggibilità

I linguaggi di ultima generazione superano questi limiti con appositi costrutti per la gestione delle eccezioni


Eccezioni in JavaEccezioni in Java

Una eccezione in Java è rappresentata da un oggetto della gerarchia di classi che ha come base la classe ThrowableLe sottoclassi di Throwable rappresentano specifiche eccezioni che si dividono in

ErroriEccezioni CheckedEccezioni Unchecked


Eccezioni in JavaEccezioni in JavaErrori

le sottoclassi di Error rappresentano errori gravi non gestibili dalla programma e di solito non provocati dal programma ma dalla JVM• es: VirtualMachineError

Eccezioni checkedTutte le sottoclassi della classe Exception

• es: IOException, FileNotFoundExceptionLa gestione delle eccezioni checked è obbligatoria

Eccezioni uncheckedTutte le sottoclassi della classe RuntimeException• es: NullPointerException (obj=null; obj.m1(); )• es: IndexOutOfBoundsException (int a[]=new a[3]; a[5]=0;)

La gestione delle eccezioni unchecked è opzionale

Le eccezioni unchecked possono essere generate ovunque (chiamate di metodi, array,...). Renderne obbligatoria la gestione significa diminuire notevolmente la leggibilità del codice


La classe La classe ThrowableThrowable

Definizione:Un oggetto di tipo Throwable è una eccezione (checked o unchecked) o un errore;

Costruttori: Throwable()Throwable(String message)

Metodi principali:getMessage()restituisce il messaggio associato all’eccezioneprintStackTrace(Stream s)restituisce una “fotografia” dello stack di esecuzione sull’oggetto stream (PrintWriter o PrintStream)printStackTrace()restituisce una “fotografia” dello stack di esecuzione su stderr


Gestione delle eccezioniGestione delle eccezioni

Una eccezione può essere:catturata e gestita all’interno di un metodo

tramite il costrutto try/catch

propagata verso il metodo chiamante che può catturare e gestire l’eccezione o continuare la propagazione

tramite la dichiarazione di propagazione nella definizione del metodo

throws <classe Throwable>

generata da un metodo tramite il costrutto

throw <oggetto Throwable>


Cattura e gestione delle eccezioni: Cattura e gestione delle eccezioni: try/catchtry/catch

Cattura e gestione: sintassi del costrutto try/catchil costrutto try / catch è costituito da un blocco try e da uno o più blocchi catchIl blocco try contiene il codice che può generare una o più tipi di eccezioneIl blocco catch i-esimo cattura e gestisce le eccezioni della classe <classe eccezione i>) o sottoclassi di questa (Exception Handler)All’interno del blocco catch ci si può riferire alla eccezione mediante il riferimento ei

try{// codice che può generare l’eccezione

}catch (<classe eccezione 1> e1) {// codice che gestisce l’eccezione e1

}

}catch (<classe eccezione 2> e2) {// codice che gestisce l’eccezione e2

}


Cattura e gestione delle eccezioniCattura e gestione delle eccezioniCattura e gestione: semantica del costrutto try/catch

interruzione dell’esecuzione del blocco try che ha generato l’eccezione (1) e verifica del blocco catch che può catturare l’eccezione (nell’ordine in cui sono scritti)cattura dell’eccezione da parte del primo blocco catch che ha l’eccezione generata come classe dichiarata o come una delle sottoclassi di questa (2) gestione dell’eccezione con l’esecuzione del blocco catch (3)

1

2

3

try{// codice che può generare l’eccezione

}catch (<classe eccezione> ei) {// parte di codice che gestisce l’eccezione ei

}

...

...


Cattura e gestione di eccezioni: esempioCattura e gestione di eccezioni: esempio

1. int[] v=new int[10];

2. try{3. s=s+v[k]/m;

4. ...

5. }catch (ArrayIndexOutOfBoundsException e) {

6. System.out.println(“Errore! indice al di fuori

7. dell’intervallo consentito:”+e.getMessage() );

8. }catch (ArithmeticException e2) {9. System.out.println(“Errore! divisione

10. per 0:”+e2.getMessage() );

11. }catch (Exception e3) { 12. System.out.println(“Eccezione generica !”) }

Se k>=10 l’istruzione 3 genera l’eccezione che viene gestita da questo blocco catch

Se m=0 l’istruzione 3 genera l’eccezione che viene gestita da questo blocco catch

Tutte le altre eccezioni sono gestite da questo blocco catch

Se ci sono blocchi catch per eccezioni che sono l’una una sottoclasse dell’altra (es: ArithmeticException ed Exception) ènecessario che il blocco catch relativo alla superclasse sia successivo al blocco catch relativo alla sottoclasse

In caso contrario il primo blocco catch “maschera” il secondo che non verrà mai raggiunto


Propagagazione delle eccezioniPropagagazione delle eccezioniPropagazione: sintassi del costrutto throws

Un metodo deve dichiarare tutte le eccezioni (checked) che propaga (cioè che sono generate dal metodo ma e non gestite localmente)La lista delle eccezioni propagate deve essere inserita nella dichiarazione del metodo dopo la parola chiave throwsL’elemento della lista <classe eccez. i> propaga la classe dichiarata e tutte le sottoclassi

La lista delle eccezioni che un metodo propaga deve essere documentata (javadoc) per consentire una gestione corretta delleeccezioni da parte degli utenti del metodoChi userà il metodo sarà obbligato ad invocarlo in un blocco try/catch oppure a dichiarare a sua volta la propagazione delle stesse eccezioni

public void m() throws <classe eccez. 1>, <classe eccez. 2>,... {

// metodo che può generare l’eccezione

}


Propagagazione delle eccezioniPropagagazione delle eccezioniPropagazione: semantica del costrutto throws

interruzione dell’esecuzione del metodo che ha generato l’eccezione (1)propagazione verso il metodo chiamante (2) che a sua volta può catturare e gestire l’eccezione (interrompendo la propagazione) o propagarla al chiamante se l’eccezione viene propagata da tutti i metodi della catena e non viene catturata neanche dall’ultimo metodo (il metodo main), la JVM interrompe l’esecuzione del programma con un messaggio di errore (3)

public void m2() throws <classe eccezione> {// metodo che può generare l’eccezione

...

}

1

2

m2()m1()main()

3


Esempio di gestione delle eccezioniEsempio di gestione delle eccezioni

tempo

E3E3E3E3

E1E1

E2

m1()m2()

m3()

MainClass Obj1:Class1 Obj2:Class2 Obj3:Class3

genera E0,E1,E2,E3cattura E0propagale altre

propaga tutti i tipi di eccezione

cattura E2propaga le altre

cattura E1propaga le altre

main

E0

Errore !


Generazione di eccezioni: esempioGenerazione di eccezioni: esempioFileInputStream genera una

eccezione di tipo “checked” che deve essere obbligatoriamente....

1. catturata e gestita (try/catch)

2. oppure propagata (throws)

3. Altrimenti errore di compilazione


Gestione di eccezioni: esempioGestione di eccezioni: esempio

FileNotFoundException è generata da m3 (8) e catturata localmente (caso E0)


Gestione di eccezioni: esempioGestione di eccezioni: esempio

FileNotFoundException è generata da m3 (8), propagata da m3 (4) ed m2 (4) e catturata da m1 (11) (caso E1)


Generazione di eccezioniGenerazione di eccezioni

Generazione: sintassi del costrutto throwthrow <oggetto_di_tipo_Throwable>;

Generazione: semantica del costrutto throwSe l’eccezione non è catturata localmente viene interrotta l’esecuzione del metodo (1) e l’eccezione viene propagata al metodo chiamante (2)

public int somma(int a,int b) throws Exception {

int somma=a+b;

if (somma>10) throw new Exception("Somma:"+somma+">10 !!");

return(somma);

}

1

2


EsempioEsempio


Definizione di eccezioni proprieDefinizione di eccezioni proprie

E’ possibile definire delle proprie eccezioni ereditando da una delle classi delle eccezioni esistenti

per le eccezioni checked ereditare da Exceptionper le eccezioni unchecked ereditare da RuntimeException

class RangeException extends Exception {public RangeException(String s){

super(s);}

}


Uso di eccezioni proprieUso di eccezioni proprieLe eccezioni proprie sono gestite come le eccezioni predefinite. In altre parole possono essere:

generateif (x>MAX_VALUE )

throw new RangeException(“x=“+x)

try {

....

}catch(RangeException exc){System.out.println( “Errore di intervallo: “

+ exc.getMessage());}

catturate e gestite

public boolean numeroPrimo(...) throws RangeExceptionpropagate


Eccezioni proprie: esempioEccezioni proprie: esempio

Il metodo isNumeroPrimo restituisce true se n è un numero primo e false nel caso contrario. Genera una RangeException se il numero è negativo.

L’eccezione RangeException eredita da Exception



E’ obbligatorio gestire l’eccezione RangeException generata dal metodo isNumeroPrimo


La clausola La clausola finallyfinallyLa clausola finally inserito dopo il blocco try/catch delimita una sezione di codice che deve essere eseguita comunque a prescindere da ciò che avviene nel blocco try/catch

Java Manual

Documents

Transcript of Java Manual