Il documento descrive il paradigma della programmazione ad oggetti, evidenziando i concetti di oggetti, classi, incapsulamento, costruttori, e ereditarietà. Viene discusso anche il polimorfismo, le interfacce, e la visibilità dei membri all'interno delle classi, oltre a esempi pratici in Java per chiarire queste idee. Infine, viene sottolineata la differenza tra classi astratte e interfacce, e come queste ultime permettano di definire metodi senza specificarne l'implementazione.

1. 1
IL PARADIGMA
AD OGGETTI

2. 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. 3
ESEMPIO: UN’AUTOMOBILE
Comportamenti Dati:
- Avviati - Targa
- Fermati - Colore
- Accelera - Velocità
- … - Livello benzina
- ...

4. 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. 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. 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. 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. 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. 9
Costruttori
I 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.

10. Uso di this
I 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
}
}

11. 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 registri
private double totale=0; //totale di questo registro
private ArrayList elenco;
public void registraFattura(Fattura fat)
{
elenco.add(fat);
totaleFatture+=fat.getImporto();
totale+=fat.getImporto();
}
}
Uso di static

12. Area statica: Può accadere che gli attributi statici siano strutture dati complesse o che
l’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

13. Metodi statici: sono metodi di utility che non operano direttamente su un particolare
oggetto della classe, ma che forniscono una funzione valida anche
senza 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

14. 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’uso
dell’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. 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. 16
RELAZIONI TRA CLASSI
Aggregazione (lista di studenti in Corso)
Composizione (lista di Carte in Mazzo)
Associazione (L’impiegato ha un Ruolo)

17. class Persona
{
private String nome;
private String cognome;
private Indirizzo indirizzo;
....
....
}
/////////////////////////////////
class Indirizzo
{
private String via;
private String numero;
private String CAP;
....
}
Associazione

18. Persona
Indirizzo
1 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.

19. 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)

20. Aggregazione
Persona
Ruolo
2:5 0:N

21. class RegistroEntrate
{
private ArrayList elenco; //Lista di oggetti
....
....
}
class Entrate
{
private Persona p;
private Date data;
....
}
Associazione 1..n
(Aggregazione)

22. Relazioni tra classi
Persona Ruolo
1 N
RegistroEntrate Entrata
11
1 N

23. class MazzoDiCarte
{
private Carta[]=new Carta[52];
....
....
}
/////////////////////////////////
class Carta
{
private int valore;
private int seme;
....
}
Associazione 1..n
(Composizione)

24. Composizione
MazzoDiCarte
Carta
1 N

25. 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

26. 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. 27
ESEMPIO
VeicoloVeicolo
VeicoloSenza
Motore
VeicoloSenza
Motore
Veicolo
A Motore
Veicolo
A Motore
Motocicletta
Motocicletta
Automobile
Automobile
Taxi
Taxi
ObiectObiect

28. 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()
{
…….
}

29. private: idendifica attributi e metodi visibili solo all’interno della classe
in UML viene indicata con un meno (-)
public: idendifica attributi e metodi visibili anche esternamente alla classe usando
l’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 statico
in 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à

30. 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

31. 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. 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?

33. 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 di
FiguraGeometrica.
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. 34
VISIBILITÀ DEI NOMI
oggetto b oggetto a
b.nome
nome
Il msg inviato all’oggetto
risale nella gerarchia fino
a trovare una definizione
gerarchia di classi

35. 35
PROGRAMMAZIONE A
OGGETTI E TASSONOMIA
Nel 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. 36
ESEMPI ALTERNATIVI
Automobile
Spider Berlina
Segmento A Segmento CSegmento B
Automobile
Benzina Diesel

37. 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. 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 Mezzo
Pubblico

39. 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

40. 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

41. Uso delle interfacce
Le 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.

42. Uso delle interfacce
Le 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(..);

43. Uso delle interfacce
Il 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.

44. Interfacce usate spesso
java.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 Object
java.lang.Runnable: permette di reliazzare classi contenenti un metodo run() che può
essere eseguito come thread. L’uso di Runnable è importante
se 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 sono
quelli 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.

45. 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 libreria
rt.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.