1

IL PARADIGMAAD OGGETTI

2

OGGETTI: CHE SONO MAI? Versione informatica degli oggetti "reali" Dotati di una loro propria "individualità" Capaci di interagire per scambio di messaggi Caratterizzati da:

attributi: ne descrivono lo “stato” metodi: ne descrivono il “comportamento”

Un msg modifica stato e attiva comportamenti

Un oggetto è una coppia [stato,comportamenti]

3

ESEMPIO: UN’AUTOMOBILE

Comportamenti Dati:- Avviati - Targa- Fermati - Colore- Accelera - Velocità- … - Livello benzina

- ...

4

CLASSI• una classe ha un nome, e contiene due tipi di membri: campi

(dati-attributi) e metodi

attributi

metodo metodo

metodo metodo

Una classe con dati incapsulati e metodi di inferfaccia

Rappresentazione UML

5

OGGETTI Un oggetto è una istanza (“esemplare”) di una classe,

che viene creato (“instanziato”) dinamicamente

Due esemplari della stessa classe sono distinguibili soltanto per il loro stato (il valore dei loro campi), mentre il comportamento è sempre identico

:CC 402 TY

:BH 102 AT

:MI 342314R

6

CLASSI: ESEMPIO (JAVA)class Automobile {

private String targa; private int velocità; private Color colore;…public void avviati () {…..}public void fermati () {}

}

attributi

metodi

nome classe

7

OGGETTI: ESEMPIO (JAVA)class Automobile {….}….Automobile a, b, c;a = new Automobile();b = new Automobile();c = new Automobile();….a.avviati();

….

dichiara, non crea

crea

8

INCAPSULAMENTO Alcuni attributi (dati e metodi) sono pubblici

(cioè visibili "all'esterno") Altri attributi sono privati dell'oggetto, e

quindi “nascosti” all’esterno (“information hiding”)

parti private sono modificabili senza effetti per gli interlocutori dell'oggetto

Propagazione delle modifiche assai contenuta Stimolo al riutilizzo di oggetti ("black-box")

9

CostruttoriI costruttori sono metodi particolari che hanno lo stesso nome della classe e che in genere servono per inizializzare la classe stessa. Se non viene definito alcun costruttore si ha comunque un costruttore di default senza parametri.class Automobile {

private String targa; …

public Automobile(String targa){ this.targa=targa;}

}In seguito il costruttore verrà utilizzato così:Automobile a=new Automobile(“CG 453 ER”);Aver definito un costruttore comporterà la scomparsa del costruttore di default quindi:Automobile a=new Automobile();Darebbe errore di compilazione, a meno di non definire esplicitamente un costruttore siffatto.

Uso di thisI costruttori possono essere sovraccaricati (overloading)

class Persona{ private String nome; //Attributi private String cognome; public Persona(String nome,String cognome) { this.nome=nome; //this distingue gli attributi this.cognome=cognome; //dalle variabili locali }

public Persona() { this(“Anonymous”,”Guest”); //Richiama il costruttore precedente }

}

static: utilizzabile nella dichiarazione degli attributi e dei metodi.

Attributi statici: sono attributi di classe e non di istanza. Cioè appartengono alla classe nel suo insieme e non ad un

particolare oggetto di quella classe.class RegistroFatture{

private static double totaleFatture=0; //totale di tutti i registriprivate double totale=0; //totale di questo registroprivate ArrayList elenco;

public void registraFattura(Fattura fat){

elenco.add(fat);totaleFatture+=fat.getImporto();totale+=fat.getImporto();

}}

Uso di static

Area statica: Può accadere che gli attributi statici siano strutture dati complesse o chel’assegnazione del loro valore iniziale richieda una certa elaborazione.In questo caso non è possibile eseguire un semplice assegnamento, ma sarà necessario scrivere una porzione di codice;

public class MiaClasse{

private static int tabella[]=new int[200];static{

for(int i=1;i<200;i++){ tabella[i]=tabella[i-1]+2;}

}

}

L’area statica viene eseguita senza che venga creata un’istanza della classe.

Quindi in generale è la prima porzione di codice che viene eseguita quando

utilizziamo in qualche modo la classe in questione.

Uso di static

Metodi statici: sono metodi di utility che non operano direttamente su un particolare

oggetto della classe, ma che forniscono una funzione valida anchesenza creare alcuna istanza della classe.

public class Complex{ private double re; private double im;

public Complex(double re, double im) {this.re=re; this.im=im; }

public double modulo() {return Complex.modulo(this.re,this.im);}

public static double modulo(double x, double y) {return Math.sqrt(x*x+y*y); }}…………………….Complex z=new Complex(3,4);double m=z.modulo(); //ho trovato il modulo dell’oggetto z

double m1=Complex.modulo(3,4); //trovo il modulo senza avere nessun oggetto

Uso di static

Attributi final: sono attributi non modificabili, cioè costanti. Solitamente le costanti

sono anche pubbliche e statiche, per ovvie ragioni.public static final int FIORI=3;per riferirsi a queste costanti è sempre necessario ricorrere all’usodell’operatore punto Carta.FIORI, Math.PI…….a meno che non ci troviamo all’interno della classe stessa.

Metodi final: sono metodi che non possono essere ridefiniti nelle sottoclassi, cioèviene impedito l’overriding.

Classi final: sono classi che non possono essere estese.

Uso di final

15

INTERAZIONI TRA OGGETTI E TRA CLASSI

Gli oggetti possono comunicare e interagire dinamicamente (a run-time) mediante scambio di messaggi attraverso l’interfaccia pubblica. (Per mezzo di un messaggio un oggetto può chiedere un'informazione a un altro oggetto, causarne un cambiamento di stato)

Inoltre le classi possono essere staticamente collegate le une alle altre con legami di:

Associazione Aggregazione Composizione

16

RELAZIONI TRA CLASSIAggregazione (lista di studenti in Corso)

Composizione (lista di Carte in Mazzo)

Associazione (L’impiegato ha un Ruolo)

class Persona { private String nome; private String cognome; private Indirizzo indirizzo;

.... .... }

///////////////////////////////// class Indirizzo { private String via; private String numero; private String CAP; .... }

Associazione

Persona Indirizzo1 1

Associazione

La freccia indicata nel disegno indica la ‘navigabilità’ da Persona a Indirizzo e non viceversa: nella classe Persona c’è un riferimento all’indirizzo.

class Persona { private String nome; private String cognome; private Indirizzo indirizzo; private Ruolo[] ruoli=new Ruolo[10]; //Array di Ruoli

.... .... }

///////////////////////////////// class Ruolo { private String nome; .... }

Associazione 1..n (Aggregazione)

Aggregazione

Persona Ruolo2:5 0:N

class RegistroEntrate { private ArrayList elenco; //Lista di oggetti .... .... }

class Entrate { private Persona p; private Date data; .... }

Associazione 1..n (Aggregazione)

Relazioni tra classi

Persona Ruolo

1 NRegistroEntrate Entrata

11

1 N

class MazzoDiCarte { private Carta[]=new Carta[52]; .... .... }

///////////////////////////////// class Carta { private int valore; private int seme; .... }

Associazione 1..n (Composizione)

Composizione

MazzoDiCarte Carta1 N

25

EREDITARIETÀ È il meccanismo che consente di derivare una sottoclasse

da una classe data Una sottoclasse si ottiene per aggiunta o per ridefinizione

di uno o più membri rispetto alla classe di partenza (che diventa una superclasse della nuova classe)

Il Taxi è un automobile, ma ha in più una tariffa e un metodo startTassametro. Un taxi quindi è più specializzato rispetto a un automobile

EreditarietàSuperclasse

Sottoclasse

Generaliazzazione

Specializzazione

La sottoclasse eredita tutti gli attributi e tutti i metodi della superclasse, inoltre all’interno della sottoclasse sarà possibile utilizzare tutta la parte pubblica della superclasse.

27

ESEMPIO

Veicolo

VeicoloSenzaMotore

VeicoloA Motore

Motocicletta Automobile

Taxi

Obiect

Overriding di toString()Tutte le classi hanno un antenato in comune Object, questo implica che tutte le classi hanno già dei metodi perché li ereditano da Object.In particolare tutte le classi dispongono del metodo toString() che però di defualt stampa qualcosa di poco leggibile nomeclasse@hashcode. Esempio: Persona p=new Persona(); System.out.println(p); //è sottinteso p.toString()Stampa: Persona@123d21f

Sarebbe più utile ottenere una stampa più significativa.Per questo devo ridefinire il metodo toString(). Ridefinire un metodo ereditato si dice Overriding. Ciò implica scrivere un metodo con la signature esattamente uguale a quella usata nella superclasse. Nel caso in esame: public String toString(){ …….}

private: idendifica attributi e metodi visibili solo all’interno della classein UML viene indicata con un meno (-)

public: idendifica attributi e metodi visibili anche esternamente alla classe usandol’operatore punto:

Math.sin(x) //si tratta di un metodo pubblico e statico MazzoDiCarte m=new MazzoDiCarte();

m.mischia() //si tratta di un metodo pubblico e non staticoin UML viene indicata con un più (+)

protected: idendifica attributi e metodi visibili solo all’interno della classe stessa e all’interno delle sue sottoclassi (anche appartenenti a package diversi) in UML viene indicata con un meno (#).

(default): Si ottiene senza alcuna parola chiave davanti alla dichiarazione e a volte viene detta visibilità friendly. In questo caso si hanno attributi e metodi visibili all’interno del package corrente.in UML viene indicata con un tilde (~).

Modificatori di visibilità

class Persona { private String nome; private String cognome; public Persona(String nome,String cognome) { this.nome=nome; this.cognome=cognome; } }

///////////////////////////////// class Impiegato extends Persona //è possibile estendere una sola classe { private double stipendio; public Impiegato(String nome,String cognome,double stipendio) { super(nome,cognome); //dev’essere sempre la prima istruzione this.stipendio=stipendio; } }

Esempio

L’uso della visibilità protected, benché a volte sia comoda a livello di quantità di codice da scrivere è sempre possibile evitarla grazie alla scrittura di opportuni metodi di accesso ai dati:

class Persona{ private String nome; private String cognome;

public Persona(String nome,String cognome) { this.nome=nome; this.cognome=cognome; } ////////////////////////////////////////////////////////////////////// public String getNome(){return nome;} //i metodi di accesso ai dati public void setNome(String s}{nome=s;} //iniziano con

//get…. OUTPUT public String getCognome(){return cognome;} //set….. INPUT public void setCognome(String s}{cognome=s;} //is… per OUTPUT boolean}

Metodi di accesso ai dati

32

POLIMORFISMO“Ciò che vale per una classe, vale anche per le sue sottoclassi. Se una proprietà viene ridefinita, quando la uso viene selezionata la versione corretta”Quando uso un metodo di un oggetto, non so: a quali livelli è definito quale tra i metodi omonimi nella gerarchia verrà usato in pratica si ha un binding dinamico effettuato a run-time, quindi verrà usato sempre il metodo adatto alla circostanza, cioè quello dell’oggetto effettivamente instanziato.

Persona p=new Impiegato();Persona d=new Dirigente();d.calcolaStipendio();

Secondo voi quale metodo calcolaStipendio() verrà usato?

Grazie al meccanismo di overriding è possibile che un metodo con la stessa signature si comporti diversamente a seconda dell’oggetto (istanza della classe) per cui viene utilizzato.

Ad esempio.

FiguraGeometrica f1=new Cerchio(4); FiguraGeometrica f2=new Quadrato(4); Questi assegnamenti sono possibili se Cerchio e Quadrato sono entrambe sottoclassi diFiguraGeometrica.

double a1=f1.calcolaArea(); //si tratta dell’area di un cerchio double a1=f2.calcolaArea(); //si tratta dell’area di un quadrato

(l’impiego del metodo corretto avvive grazie al binding dinamico in fase di run-time, cioè prima di eseguirlo l’interprete verifica f1 ed f2 per capire di che oggetto si tratta)

Attenzione però f1 e f2 sono dichiarati di tipo FiguraGeometrica, quindi in fase di compilazione, si verificherebbe un errore se la classe FiguraGeometrica non avesse un suo metodo calcolaArea() che per altro sarà del tutto indefinito: potremmo dire del tutto astratto.

Polimorfismo

34

VISIBILITÀ DEI NOMI

oggetto b oggetto a

b.nome

nome

Il msg inviato all’oggettorisale nella gerarchia fino a trovare una definizione

gerarchia di classi

35

PROGRAMMAZIONE A OGGETTI E TASSONOMIANel paradigma a oggetti, l’attenzione del programmatore è spostata dalla creazione di processi di computazione alla creazione di tassonomie (classificazioni) del sistema in esame

Osservazioni: Per descrivere un sistema sono possibili

tassonomie diverse, a seconda degli obbiettivi

La tassonomia è un’arte difficile

36

ESEMPI ALTERNATIVI Automobile

Spider Berlina

Segmento A Segmento CSegmento B

Automobile

Benzina Diesel

Una classe come FiguraGeometrica, che ha un metodo come calcolaArea() che non può essere definito, non avendo ancora dati sufficienti, è a tutti gli effetti una classe astratta.

Per la precisione il metodo calcolaArea() sarà astratto, cioè indefinibile, senza corpo. Ma un classe che ha almeno un metodo astratto diventa astratta:

public abstract class FiguraGeometrica{ private String nome; public FiguraGeometrica(String nome) {this.nome=nome;}

public abstract double calcolaArea(); // senza alcun corpo, si tratta // solo di una firma

}

Una classe astratta non può essere istanziata: non possono esistere FigureGeometriche, se non tramite le sottoclassi non astratte della stessa.Le sottoclassi non astratte sono obbligate a ridefinire (overriding) il metodo calcolaArea.

Classi Astratte

38

EREDITARIETÀ MULTIPLA Meccanismo che consente di derivare sottoclassi da

due o più classi

Il problema degli omonimi Java non implementa ereditarietà multipla

Taxi

Automobile MezzoPubblico

39

INTERFACCE Java implementa qualcosa di simile all’ereditarietà

multipla con le Interfacce

Le interfacce però non sono classi: sono completamente astratte e contengono solo metodi (non dati)

Moto

Mezzi di trasporto

Comparabile

Estremizzando il concetto di classi astratte potremmo pensare a classi completamente astratte, cioè con tutti metodi astratti e senza construttore. In questo caso è possibile utilizzare anziché abstract, il concetto di interface che implica le caratteristiche descritte.public interface Comparable{ public int compareTo(Object obj);}

(si noti che abstract è sottinteso)

Le interfacce non vengono estese (extends), ma vengono bensì implementate (implements)public class Impiegato extends Persona implements Comparable, Serializable{

}Implementare un’interfaccia significa essere obbligati a scrivere , rendere reale, i metodi lasciati senza definizione all’interno dell’interfaccia.L’interfaccia è quindi da considerare un contratto che ci obbliga a definire dei metodi con una firma (signature) data.

Interfacce

Uso delle interfacceLe interfacce hanno diversi utilizzi, in particolare comunque permettono di dichiarare dei metodi prima di conoscere la modalità di implementazione. Questo permette di creare metodi di utilizzo molto più generico.

Ad esempio si consideri l’interfaccia java.applet.AudioClip. Questa ha un metodo play che permette di riprodurre l’audioclip, indipendentemente dal tipo di file.

Per creare un oggetto di tipo AudioClip non sarà possibile usare un costruttore perché AudioClip è un intefaccia, quindi astratta, ma si utilizzerà un metodo di un’altra classe che mi ritornerà un oggetto appartenente alla classificazione AudioClip.

Ad esempio trovando all’interno di un’Applet:

AudioClip ac=this.getAudioClip(“file.avi”);

ac.play();

Esempi analoghi li troveremo spesso nell’uso delle interfacce che servono per accedere ai database.

Uso delle interfacceLe interfacce vengono usate come ulteriore elemento di classificazione delle classi.Cioè due classe appartenenti a gerarchie di ereditarietà diverse, possono implementare la stessa interfaccia e divenire così “cugine”.classe Dirigente extends Impiegato implemants Comparable{…… public int compareTo(Object obj) //obbligatorio {… }}Ma anche:class Triangolo extends FiguraGeometrica implements Comparable{ …………… public int compareTo(Object obj) //obbligatorio { }}Questo permette:Compareble c1=new Dirigente(…);Comparable c2=new Triangolo(..);

Uso delle interfacceIl vantaggio di questa definizione:Comparable c1=new Dirigente(…);Comparable c2=new Triangolo(..);E’ quello di poter definire dei metodi come Arrays.sort(Object obj[]) che consento di opera su qualsiasi array di oggetti purché siano oggetti comparabili. Analogamente ad esempio Collection.sort(Collection c)

Quindi la grossa potenzialità delle interfacce è quella di permettere la scrittura di metodi generici che funzionano per classi anche molto diverse, ma che hanno in comune l’implementazione di un’interfaccia.

Tutte queste considerazioni comportano il fatto che l’uso delle interfacce permette di superare, almeno in parte, l’assenza della ereditarietà multipla in Java. Anzi le interfacce, rispetto alla possibilità di ereditare da più di una classe, hanno il vantaggio di non ambiguità, poiché i metodi definiti nell’interfaccia sono astratti.

Interfacce usate spessojava.lang.Comparable: obbliga le classi implementanti a definire il metodo compareTo

che torna un intero rappresentante la differenza tra due oggetti.java.lang.Cloneable: permette di classificare come clonabili le classi implementanti,

quindi per queste sarà legale usare il metodo clone() di Objectjava.lang.Runnable: permette di reliazzare classi contenenti un metodo run() che può

essere eseguito come thread. L’uso di Runnable è importantese per qualche motivo non è possibile estendere Thread.

java.io.Serializable: permette di classificare come serializzabili gli oggetti creati a partire dalle classi implementanti. Gli oggetti serializzabili sonoquelli che possono essere inviati su uno stream di dati, cioèscritti su file, o spediti attraverso una rete….

Altre interfacce di uso comune sono i numerosi Listener che permettono di intercettare gli eventi nelle applicazioni GUI. Ad esempio java.awt.event.ActionListener ha una metodo actionPerformed(ActionEvent e) che permette di intercettare il click del mouse.

Segnalo anche le interfacce presenti nel package java.util (Collection, List, Map, SortedList…..) che fungono essenzialmente da classificatori consentendo di avere metodi con la stessa signature ad esempio per tutti i tipi di lista. Vedremo anche nel package java.sql la presenza di numerose interfacce.

Cosa sono i package?I package sono insiemi di classi che hanno tra loro, dal punto di vista logico, una funzionalità comune o appartenente allo stesso conteso.Fisicamente non si tratta di altro che di una directory, ad esempio aprendo la libreriart.jar, si nota che al suo interno si trova una struttura di directory corrispondente ai package che normalmente noi usiamo (java.lang, java.util, java.sql, java.net…):

All’interno di queste directory troviamo le classi:java.lang.String, si tratta del file String.class contenuto nella direcory java e nella sottodirecory lang

Detto questo, nessuno ci vieta di creare nostri package, di archiviarli in file jar e di riutilizzarli all’occorrenza pur di modificare la variabile CLASSPATH in modo che contenga anche il nostro file jar.

Per creare un package e per fare in modo che una classe vi appartenga basta usare la sintassi:package com.miosito.utility; All’inizio del file contenente la classe.