(E-Book Ita) Java _ Introduzione Alla Programmazione Orientata Ad Oggetti in Java

Introduzione Introduzione alla Programmazione Programmazione Orientata agli Oggetti in Java Versione 1.1

Eugenio Polìto Stefania Iaffaldano Ultimo aggiornamento: 1 Novembre 2003

Trusted by over 1 million members

Try Scribd FREE for 30 days to access over 125 million titles without ads or interruptions! Start Free Trial Cancel Anytime.

























Copyright c 2003 Eugenio Polìto, Stefania Iaffaldano. All rights reserved. This document is free; you can redistribute it and/or modify it under the terms of the GNU General General Public License as published by the Free Software Software Foundation; either version 2 of the License, or (at your option) any later version. This document is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY MERCHANTABILITY or FITNESS FOR A PARTICU ARTICULAR LAR PURPOS PURPOSE. E. See the GNU Genera Generall Publ Public ic Licens Licensee for more detail details. s. You should have received a copy of the GNU General Public License along with this document; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

Sosteniamo la Cultura Libera: sosteniamo il Free Software Per la segnalazione di errori e suggerimenti, potete contattarci ai seguenti indirizzi: Web: E-Mail:

http://www.eugeniopolito.it [email protected]

Typeset with LATEX.



























Ringraziamenti Un grazie speciale ad OldDrake, Andy83 e Francesco Costa per il prezioso aiuto che hanno offerto!



























Indice 1 Introduzione

8

I Teoria eoria della della OOP

9

2 Le idee fondamentali 2.1 2.1 Una Una bre breve stor storia ia dell dellaa prog progra ramm mmaz azio ione ne . . . . . . . . . . . . . . 2.2 I princìpi della OOP . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 ADT: creare nuovi tipi . . . . . . . . . . . . . . . . . . . . . . . 2.4 La classe: classe: imp implem lementa entare re gli ADT tramit tramitee l’incaps l’incapsulam ulamento ento . . . . 2.5 L’oggetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6 Le relazioni fra le classi . . . . . . . . . . . . . . . . . . . . . . . 2.6.1 Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6.2 Aggregazione . . . . . . . . . . . . . . . . . . . . . . . . 2.6.3 Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . 2.6.4 Classi astratte . . . . . . . . . . . . . . . . . . . . . . . . 2.6.5 Ereditarietà multipla . . . . . . . . . . . . . . . . . . . . 2.7 Bindi nding dinami amico e Polim imoorfis rfismo . . . . . . . . . . . . . . . . .

9 9 12 13 15 16 17 17 18 18 22 23 27

II La OOP in Java

29

3 Classi e oggetti 3.1 Definire una classe . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Garantire Garantire l’incapsulamen l’incapsulamento: to: metodi pubblici e attributi privati . . 3.3 Meto etodi ed attrib ributi stat tatici . . . . . . . . . . . . . . . . . . . . . . 3.4 Costruire un oggetto . . . . . . . . . . . . . . . . . . . . . . . . 3.5 La classe Persona e l’oggetto eugenio . . . . . . . . . . . . . . 3.6 3.6 Reali alizzar zare le relazi azioni fra classi ssi . . . . . . . . . . . . . . . . . . 3.6.1 Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6. 3.6.22 Meto Metodi di static: un esempio . . . . . . . . . . . . . . . . 3.6.3 Aggregazione . . . . . . . . . . . . . . . . . . . . . . . . 3.6.4 Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . 3.7 Classi astratte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.8 Interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

29 29 29 31 32 34 37 37 39 41 44 52 56



























4 Le operazioni sugli oggetti 4.1 Copia e clonazione . . 4.2 Confronto . . . . . . . 4.3 Binding dinamico . . . 4.4 Serializzazione . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

67 67 73 76 79

III APPENDICI

83

5 Una panoramica sul linguaggio 5.1 Tipi primitivi . . . . . . . . . . . . . . 5.2 Variabili . . . . . . . . . . . . . . . . . 5.3 Operatori . . . . . . . . . . . . . . . . 5.3.1 Operatori Aritmetici . . . . . . 5.3.2 Operatori relazionali . . . . . . 5.3.3 Operatori booleani . . . . . . . 5.3.4 Operatori su bit . . . . . . . . . 5.4 Blocchi . . . . . . . . . . . . . . . . . 5.5 Controllo del flusso . . . . . . . . . . . 5.6 Operazioni (Metodi) . . . . . . . . . . 5.6.1 Il main . . . . . . . . . . . . . 5.6.2 I package . . . . . . . . . . . . 5.6.3 Gli stream . . . . . . . . . . . . 5.6.4 L’I/O I/O a linea di comando . . . . 5.6.5 Le eccezioni . . . . . . . . . . 5.6.6 5.6.6 Install Installazio azione ne del JDK . . . . . .

83 83 84 84 84 85 85 85 86 86 87 89 89 90 91 91 93

6 La licenza GNU GPL

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . .. .. . . . . . . ..

. . . . . . . . . . . . . . . .

94



























Elenco delle figure 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Una classe in UML. . . . . . . . . . . . . . . . . . . . . . . . . . La classe Persona in UML. . . . . . . . . . . . . . . . . . . . . La relazione d’uso in UML. . . . . . . . . . . . . . . . . . . . . . La relazione di aggregazione in UML. . . . . . . . . . . . . . . . La relazione di ereditarietà in UML. . . . . . . . . . . . . . . . . La classe delle persone come sottoclasse della classe degli degli animali. animali. Una piccola gerarchia di Animali. . . . . . . . . . . . . . . . . . Una piccola gerarchia di Animali in UML. . . . . . . . . . . . . . Matr atrimonio fra fra classe concreta e astratta . . . . . . . . . . . . . Lavoratore . . . . . . . . . Comp Composi osizio zione ne:: la classe Studente Lavoratore Studente Studente Lavoratore Lavoratore come aggregazione e specializzazione . . Studente Studente Lavoratore Lavoratore come aggregazione . . . . . . . . . . . . L’ex Studente ed ex Lavoratore ora Disoccupato . . . . . . . La classe Studente come sottoclasse di Persona . . . . . . . . . L’oggetto primo appena creato . . . . . . . . . . . . . . . . . . . L’oggetto primo non ancora creato . . . . . . . . . . . . . . . . . L’oggetto eugenio dopo la costruzione . . . . . . . . . . . . . . Esecuzio Esecuzione ne del program programma ma Applicazione.java . . . . . . . . . Esecuzio Esecuzione ne del program programma ma Applicazione.java . . . . . . . . . Diag Diagra ramm mmaa UML per interface . . . . . . . . . . . . . . . . . Diag Diagra ramm mmaa UML per implements . . . . . . . . . . . . . . . . . Diag Diagra ramm mmaa UML per il matrimonio fra classe concreta ed inter faccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Una Pila di numeri interi . . . . . . . . . . . . . . . . . . . . . . 24 Esec Esecuz uzio ione ne di ProvaPila . . . . . . . . . . . . . . . . . . . . . . 25 Gli oggetti primo e secondo dopo opo la creaz eazione one . . . . . . . . . . secondo = 26 Gli oggetti primo e secondo dopo l’assegnamento l’assegnamento secondo primo; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Gli oggetti primo e secondo dopo la clonazione . . . . . . . . . . 28 Gli oggetti primo e secondo dopo l’istruzione secondo.set(16); 29 Un oggetto ha sempre un riferimento implicito ad Object . . . . . 30 L’oggetto bill istanza di Cane . . . . . . . . . . . . . . . . . . . base = deri derivat vata; a; . . . . . . . . . . . . . . . . . . . . . . . . . 31 base 32 Passa assagg ggio io dei dei para parame metr trii ad una una funz funzio ione ne . . . . . . . . . . . . . .

15 16 17 18 19 20 21 21 23 23 24 25 25 27 33 33 35 51 55 56 59 60 60 64 69 69 71 72 74 75 78 88





























Elenco delle tabelle 1 2

Pro Pro e cont contro ro dell dell’u ’uso so di ereditarietà e aggregazione . . . . . . . . 20 Tipi ipi prim primit itiv ivii di Java . . . . . . . . . . . . . . . . . . . . . . . . 83





























1

INTR INTRODUZIO ODUZIONE NE

8

1 Intr Introd oduz uzio ione ne Questa trattazione sulla Programmazione Programmazione Orientata agli Oggetti o Object Oriseguito) to) in Java nasce nasce dall’oss dall’osserv ervazi azione one che, mol molto to ented Programm Programming ing (OOP in segui spesso, i manuali sono degli ottimi reference (cfr. [3]) del linguaggio ma non approfondiscono profondiscono i pochi ma essenziali concetti della OOP; d’altra parte nei corsi universitari si presta fin troppa attenzione alla teoria senza approfondire gli aspetti implementativi. Quindi si cercherà di trattare sia la teoria che la pratica della OOP perché entrambi gli aspetti sono fondamentali fondamentali per poter scrivere scrivere un buon codice orientato agli oggetti. Purtroppo Java viene considerato considerato (in modo errato!) un linguaggio per scrivere scrivere soltanto applet o addirittura viene confuso con il linguaggio di script JavaScript : con Java si possono scrivere delle applicazioni standalone che non hanno molto da invidiare (a livello di prestazioni) ai programmi scritti con altri linguaggi OOP più efficienti come C++. Infatti, Infatti, attualmente, attualmente, la Java Virtual Machine (cioé lo strato software che si occupa di trasformare il codice intermedio o bytecode in chiamate alle funzioni del Sistema Operativo - syscall) consente di avere delle ottime prestazioni. In [1] potete trovare la versione 1.4 del JDK . È importante sottolineare sottolineare che questo non è un manuale sul linguaggio, ma è una trattazione sull’impostazione Object Oriented del linguaggio: linguaggio: comunque, comunque, se non si conosce la sintassi di Java, è consigliabile dare uno sguardo alla sezione 5 dove è disponibile un veloce riassunto sulla struttura del linguaggio.





























9

Parte I

Teoria della OOP In questa parte verranno introdotte e discusse le idee fondamentali della OOP. Se si conoscono già i princìpi ed i meccanismi della OOP si può passare alla parte successiva, dove si discute come tali concetti sono realizzati in Java.

2 Le id idee ee fonda ondame ment ntal alii 2.1 Una breve breve storia della programmaz programmazione ione La programmazione programmazione dei computer esiste ormai da circa 60 anni. Ovviamente Ovviamente in un tempo così lungo, ha subìto notevoli cambiamenti: agli albori l’arte di programmare consisteva nella programmazione di ogni singolo bit di informazione tramite degli interruttori che venivano accesi e spenti. Quindi Quind i il programma era in realtà una sequenza di accensioni e spegnimenti di interruttori che producevano il risultato che si voleva, anzi che si sperava di ottenere: pensate cosa poteva comportare lo scambio di una accensione con uno spegnimento o viceversa! Solo intorno al 1960 venne scritto il primo Assembler : questo linguaggio linguaggio era (ed è) troppo legato alla struttura del microprocessore e soprattutto era (ed è) difficile scrivere un programma con un linguaggio troppo vicino alla macchina e poco amichevole per l’uomo. Tra il 1969 ed il 1971, Dennis Ritchie scrisse il primo linguaggio di programmazione ad alto livello: il C . Seppure è ad un gradino superiore all’assembler e soprattutto il codice sorgente di un programma può essere ricompilato su qualsiasi piattaforma (con qualche modifica!), questo linguaggio risulta ancora troppo





























2

LE IDEE IDEE FOND FONDAMENT AMENTALI ALI

10

hardware, pertanto è sufficiente qualche modifica al codice sorgente ed una ricompilazione;

contro la gestione della memoria, per esempio, è completamente a carico del programmatore e, come si sa, la gestione dei puntatori è una fabbrica di errori. È inoltre possibile mixare sia codice C che codice C++, ottenendo così un codice non molto pulito dal punto di vista della OOP: supponiamo di volere confrontare due variabili a e b. Il codice corretto è il seguente: if (a == b) {... {...} }

Ma basta omettere un ’=’ per ottenere un assegnamento: if (a = b) {...}

se l’assegnamento va a buon fine, viene eseguito il blocco di istruzioni. Un errore del genere può essere frequente: se non usato bene, il C++ rischia di essere un “boomerang” per il programmatore. Nei primi mesi del 1996 venne presentata la prima versione del linguaggio Java che introduceva non poche novità:

macchina virtuale anche anche se non era un conce concett ttoo nuovo nuovo nell nell’in ’infor forma mati tica ca (già (già IBM IBM aveva fatto fatto delle sperimentazioni sulle Virtual Machine in un Sistema Operativo proprietario), l’idea di sfruttare una Macchina Virtuale o Java Virtual Machine - JVM che si interpone fra il linguaggio intermedio bytecode ed il linguaggio macchina della architettura sottostante sottostan te era una novità assoluta. Tale idea è stata ultimamente ripresa da una nota Software House con un





























2


11

utilizzato viene automaticamente automaticamente distrutto. Collector: un oggetto non più utilizzato Inoltre in Java esiste solo il concetto di riferimento ad un oggetto che comporta una gestione semplice della notazione (si pensi alla notazione . o -> di C++ a seconda che un metodo sia richiamato richia mato su una variabile oggetto / reference reference o su un puntatore). L’assenza della gestione diretta dei puntatori consente di produrre un codice sicuro. Per un confronto fra Java e C++ cfr. [4].































2


12

2.2 I prin princìp cìpii della della OOP OOP La OOP è una evoluzione naturale dei linguaggi di programmazione: essa nasce con lo scopo preciso di simulare e modellare la realtà. I princìpi su cui si basa la OOP sono semplici ma molto potenti: Definire nuovi tipi di dati. Incapsulare i valori e le operazioni. Riusare il codice esistente (ereditarietà). Fornire il polimorfismo. Come vedremo, nella OOP non si fa differenza fra valori ed operazioni: semplicemente si parla di Tipo di dato che ingloba le due entità in un’unica struttura. Quindi è necessario definire un nuovo Tipo di dato. È altrettanto necessario accedere accedere ad un valore di un tipo di dato: come vedremo questo è fattibile tramite il meccanismo di incapsulamento. Un altro cardine della OOP è il riuso del codice: cioé utilizzare del codice esistente per poterlo specializzare.































2


13

2.3 ADT: ADT: creare creare nuovi nuovi tipi tipi Un Tipo di Dato Astratto o Abstract Data Type - ADT è, per definizione, un nuovo tipo di dato che estende i tipi nativi forniti dal linguaggio di programmazione. Un ADT è caratterizzato da un insieme di: dati; operazioni che agiscono sui dati, leggengoli/scrivendoli;

Fin qui niente di nuovo: anche i linguaggi procedurali, come per esempio C , consentono di definire un ADT . Ma, mentre per tali linguaggi chiunque può avere accesso ai dati e modificarli, i linguaggi Object Oriented ne garantiscono la loro riservatezza. Supponiamo infatti di voler definire in C (non preoccuparsi della sintassi) un ADT Persona cioé una struttura dati che mantenga le informazioni informazioni (dati) di una Persona, come, per esempio, il nome, il cognome e la data di nascita e che consenta di creare e stampare le informazioni di una persona (operazioni): /* Strut Struttur tura a dati dati per manten mantenere ere la data data di nascit nascita a */ struc struct t Data Data {































2


/* Stam Stampa pa le info info. . dell della a pers person ona a */ void stampaDati(stru stampaDati(struct ct Persona *persona) { prin printf tf(" ("Mi Mi chia chiamo mo %s %s e sono sono nato nato il %i-% %i-%ii-%i %i \n", \n", persona->nome, persona->cognome, persona->data_di_nascita->giorno, persona->data_di_nascita->mese, persona->data_di_nascita->anno); } /* crea crea un puntat puntator ore e alla alla stru struttu ttura ra e lo iniz inizial ializz izza; a; quind quindi i stamp stampa a le info. info. */ int main() main() { struct struct Persona Persona *io; creaPersona(io); stampaDati(io); return return 0;

14































2


15

2.4 La classe: classe: imple implemen mentar taree gli ADT tramite tramite l’inca l’incapsu psulam lament entoo La classe consente di implementare gli ADT attraverso il meccanismo di incapsulamento: i dati devono rimanere privati insieme all’implementazione e solo l’interfaccia delle operazioni è resa pubblica all’esterno della classe. Questo approccio è fondamentale per garantire che nessuno possa accedere alle informazioni della classe e quindi, dal punto di vista del programmatore, è una garanzia per non fare errori nella stesura del codice: basti pensare all’esempio dell’ ADT Persona visto visto prima. prima. Se i dati fossero stati privati non avrei potuto liberamente modificare la data di nascita nel main. Quindi, Quindi, ricapito ricapitoland lando, o, una classe implementa un ADT (un sinonimo di classe è proprio tipo) attraverso il meccanismo di incapsulamento. La descrizione di una classe deve elencare:

i dati (o attributi): contengono le informazioni di un oggetto; le operazioni (o metodi): consentono consentono di leggere/scriv leggere/scrivere ere gli attributi di un oggetto; Quando si scrive una applicazione è buona norma iniziare con la progettazione dell’applicazione stessa; Grady Booch identifica identifica i seguenti obiettivi in questa fase:































2


16

Quindi la classe Persona in UML è così rappresentata:

Figura 2: 2: La classe Persona in UML.

2.5 L’ogge ’oggetto tto Che cos’è quindi un oggetto? Per definizione, diciamo che un oggetto è una istanza di una classe . Quindi un oggetto deve essere conforme alla descrizione di una classe. Un oggetto pertanto è contraddistinto da: 1. attributi;

































2


17

2.6 Le relazio relazioni ni fra le classi classi importante della OOP è la possibilità di definire delle relazioni fra le Un aspetto importante classi per riuscire a simulare e modellare il mondo che ci circonda :

uso: una classe può usare oggetti di un’altra classe; aggregazione: una classe può avere oggetti di un’altra classe; ereditarietà: una classe può estendere un’altra classe. Vediamole in dettaglio singolarmente. singolarmente .































2


18

2.6.2 2.6.2 Aggreg Aggregazi azione one Per definizione definizione si dice che una classe A aggrega (contiene) oggetti di una classe B quando la classe A contiene oggetti della classe B. Pertanto tale relazione è un caso speciale della relazione di uso. Sugli oggetti aggregati sarà possibile chiamare tutti i metodi, ma ovviamente non sarà possibile accedere agli attributi (l’incapsulamento continua a “regnare”!). N.B.: la relazione di aggregazione viene anche chiamata relazione has-a o ha-un. Ritorniamo al nostro esempio della classe Persona: come si è detto una persona nascita. Risulta pertanto pertanto immediato immediato e spontaneo spontaneo aggregare un ha una data di nascita. oggetto della classe Data nella classe Persona!































2

19


1. riflessiva: A

A

2. antisimmetrica: A 3. transitiva: C B B

B

B A

A C

A

B

A

Ma riflettendo sul concetto di ereditarietà, affinché affinché si verifich verifichii la 1. dovrebb dovrebbee succedere succedere che una classe erediti da se stessa, cioé la classe dovrebbe essere una classe derivata da se stessa: impossibile! Analogamente la proprietà 2. dice che una classe è una classe base ed una classe derivata allo stesso tempo: anche questo è impossibile! Quindi vale solo la 3. eredita da , in UML, si disegna così:































2

20


controllato agli attributi della classe base da una classe derivata. È importante notare che l’ereditarietà può essere simulata con l’aggregazione

(cioé is-a diventa has-a)! Ovviamente ci sono dei pro e dei contro, che possiamo riassumere così: Ereditarietà

Aggregazione Aggregazione

Pro polimorfismo polimorfismo e binding dinamico dinamico Contro lega legame me stre strett ttoo fra fra clas classe se base e derivata

Pro chiusura chiusura dei moduli Contro risc riscri ritt ttur uraa dei dei meto metodi di nella classe derivata































2

21


Inoltre possiamo pensare a cosa possa fare in più una Persona rispetto ad un Animale: può parlare, costruire, studiare, fare le guerre, inquinare... etc. Quindi nella classe derivata si possono aggiungere nuove operazioni! Si è detto precedentemente che la relazione di ereditarietà è transitiva: verifichiamo quanto detto con un esempio. Pensiamo ancora alle classe Animale: come ci insegna Quark (...e la Scuola Eleme Element ntar are. e. . . ) il mon mondo do Animale è composto da sottoclassi come la classe dei Mammiferi, degli Anfìbi, degli Insetti, etc. La classe dei Mammiferi è a sua volta composta dalla classe degli Esseri Umani, dei Cani, delle Balene, etc.: An ma

































2


2.6.4 2.6.4 Classi Classi astrat astratte te

22































2


2.6.5 2.6.5 Ereditari Ereditarietà età multipla multipla

23































2


24

La classe Persona ha degli attributi, come nome, cognome, data data di nanascita etc., e dei metodi, come, per esempio mangia(...). Sia la classe































2


25

tinua ad essere uno Studente, secondo la gerarchia di Figura 11! Risulta immediato cambiare nuovamente l’ereditarietà con l’aggregazione :































2


26

Ma se un oggetto di classe Studente Lavoratore Lavoratore termina di studiare e perde il lavoro (cioé eliminiamo gli attributi, oggetti di tipo Studente e













































































































































































































































































































































































































































































































































































































































































































































































































































































3

CLAS CLASSI SI E OGGE OGGETT TTI I

62

top++; } else System.out.prin System.out.println("Pil tln("Pila a Piena!"); Piena!"); } // prele preleva va l’ele l’elemen mento to in cima cima alla alla Pila Pila public public Object Object pop() pop() { if (!isEmpty()) (!isEmpty()) return super.remove(-super.remove(--top); top); else else { System.out.prin System.out.println("Pil tln("Pila a Vuota!"); Vuota!"); return return null; null; } } // resti restitu tuisc isce e ’true ’true’ ’ se la Pila Pila è vuota vuota, , ’fal ’false’ se’ altri altrime menti nti public public boolean boolean isFull( isFull() ) { return return (top == maxEleme maxElements) nts); ; } /* riscr riscriv ive e il metod metodo o omon omonimo imo della della super supercla class sse e : resti restitu tuisc isce e ’true ’true’ ’ se la Pila Pila è vuota vuota, , ’fal ’false’ se’ altrime altrimenti nti */ public public boolean boolean isEmpty isEmpty() () { retu return rn (top (top == 0); 0); } // punta puntato tore re alla alla cima cima della della Pila Pila priv private ate int int top; top; // conta contato tore re del del nume numero ro degli degli eleme element nti i della della Pila Pila private private int maxEleme maxElements; nts; }

Poiché Pila è un Vector, supporta tutti i metodi di tale classe, inoltre poiché im-



























3


63

ta). I metodi isFull() ed isEmpty() restituiscono true se, rispettivamente la pila è piena (quindi top è uguale al massimo valore di elementi che la pila può supportare) e se la pila è vuota (top è uguale a 0). Il metodo push(...) inserisce un elemento passatogli come argomento in cima alla pila: se la pila è piena viene segnalato segnalato un errore. Notiamo che che in realtà l’inserimento avviene tramite la chiamata al metodo addElement(...) della classe base Vector che si preoccupa di inserire l’elemento nel vettore fisico. pop è l’operazione complementare a push(...). Una applicazione d’esempio potrebbe essere la seguente: public public class class ProvaPil ProvaPila a { public public static static void main(Str main(String ing args[]) args[]) { if (args. (args.le lengt ngth h != 0) { Pila pila pila = new Pila((n Pila((new ew Integer( Integer(arg args[0] s[0])).i )).intVa ntValue( lue()); )); // inse inseri risc sci i elem elem. . finc finché hé la pila pila non non è pien piena a int i = 1; while (!pila.isFull() (!pila.isFull()) ) { pila.push(new pila.push(new Integer(i++)); Integer(i++)); } // prel prelev eva a elem elem. . finc finché hé la pila pila non non è vuot vuota a while (!pila.isEmpty( (!pila.isEmpty()) )) { System.out.prin System.out.println("el tln("elemento emento prelevato: prelevato: " +pila.pop()); } } else System.out.prin System.out.println("uso tln("uso: : java ProvaPila ProvaPila num_elem"); num_elem"); } }



























3


64

Una possibile esecuzione è la seguente:

Figura 24: Esecuzione di ProvaPila Osserviamo adesso un fatto importante: riprendiamo l’iterfaccia Stack; consideriamo i due metodi public public void void push(Ob push(Object ject element element); ); public public Object Object pop(); pop();

Come si può vedere, push(...) prende come argomento un elemento il cui tipo è Object, mentre la funzione pop() restituisce un Object. Cosa vuol dire questo? Semplicemente che tali funzioni operano su oggetti di tipo Object: ma come si è detto nella sottosezione 3.6.4, ogni classe deriva da Object, quindi questi metodi funzionano su qualunque tipo! implementa l’interfaccia l’interfaccia Stack, sarà una pila che Pertanto la nostra Pila, che implementa potrà contenere elementi di qualsiasi tipo: allora potrà contenere numeri interi, numeri reali, oggetti Persona, etc. etc. Utilizzando Utilizzando il tipo cosmico Object (come parametro di funzione e/o tipo di ritorno di un metodo), si può simulare il polimorfismo parametrico (cfr. sezione 2.7); tuttavia, mentre in C++ (cfr. [2]) è possibile istanziare oggetti dello stesso tipo (cioé con un template di C++ si possono avere solo collezioni omogenee),



























3


65

public public class class ProvaPil ProvaPila a { public public static static void main(Str main(String ing args[]) args[]) { if (args. (args.le lengt ngth h != 0) { Pila pila pila = new Pila((n Pila((new ew Integer( Integer(arg args[0] s[0])).i )).intVa ntValue( lue()); )); // inse inseri risc sci i elem elem. . finc finché hé la pila pila non non è pien piena a int i = 1; while (!pila.isFull() (!pila.isFull()) ) { // inser inseris isce ce un inter intero o pila.push(new pila.push(new Integer(i)); Integer(i)); // inser inseris isce ce un reale reale pila.push(new pila.push(new Float(i*Math.PI) Float(i*Math.PI)); ); // inseris inserisce ce una stringa stringa pila.pu pila.push(n sh(new ew String(" String("Sono Sono il numero: numero: "+i)); "+i)); i++; } // prel prelev eva a elem elem. . finc finché hé la pila pila non non è vuot vuota a while (!pila.isEmpty( (!pila.isEmpty()) )) { System.out.prin System.out.println("el tln("elemento emento prelevato: prelevato: " +pila.pop()); } } else System.out.prin System.out.println("uso tln("uso: : java ProvaPila ProvaPila num_elem"); num_elem"); } }

Stavolta nella pila vengono inseriti rispettivamente: un numero intero, un numero reale ed una stringa: abbiamo così ottenuto una pila “universale” di oggetti. Occorre osservare osservare che una classe può implementare più interfacce: ad esempio, se vogliamo che la nostra Pila salvi il contenuto della pila su un file, possiamo scrivere Pila così:



























3


66

dove Vector e Stack sono le stesse viste sopre, mentre FileStack è una inter faccia che definisce i metodi per l’accesso ai file fisici. Pertanto una classe può estendere una sola classe base ma può implementare più interfacce. La seconda forma di ereditarietà multipla è il duplice sottotipo: cioé una classe implementa due interfacce filtrate. Se abbiamo abbiamo una interfaccia A ed una interfaccia B, è possibile fare questo: public public interfa interface ce A {...}; {...}; publi public c inter interfa face ce B exten extends ds A {...} {...}; ;

Una interfaccia può estendere un’altra un’altra interfaccia: interfaccia: di più può estendere un numero illimitato di interfacce, cioé si può avere una cosa del genere: public public interfa interface ce X extends extends A1 , A2 ,..., An {...}

n, sono interfacce! dove ogni Ai i 1 2 Una classe concreta Y implementerà X: publi public c class class Y imple implemen ments ts X {...} {...}

ereditarietà à multipla sottoforma di composizione di oggetti non è supportaL’ereditariet ta (cfr. sezione 2.6.5) per questioni di sicurezza del codice e per non rendere complessa la JVM .





























4

LE OPERAZ OPERAZIO IONI NI SUGLI SUGLI OGGETT OGGETTI I

67

4 Le operaz operazion ionii sugli sugli oggetti oggetti 4.1 Copi Copiaa e clon clonazi azion onee Supponiamo di avere la seguente classe: publi public c class class A { // costr costrut uttor tore e di defau default lt: : rich richiam iama a il costru costrutt ttore ore A(int A(int num) num) public public A() { this(0); } /* costr costrut uttor tore: e: setta setta l’at l’attri tribut buto o num al valor valore e passa passato to come come argomen argomento to */ public public A(int A(int num) { this. this.num num = num; num; } // asse assegn gna a un nuov nuovo o valo valore re a num num publ public ic void void set(in set(int t num) num) { this. this.num num = num; num; } // stamp stampa a num num public public void print() print()





























4


68

secondo.print(); secon secondo do = primo primo; ; secondo.set(16); primo.print(); secondo.print(); } }

Se eseguiamo tale programma, otteniamo il seguente output: 1453 0 16 16

Esaminiamo il main: viene creato l’oggetto primo che inizializza il membro num a 1453; quando si richiama il metodo print() sull’oggetto primo, si ottiene a video 1453. costruttore di default Viene poi creato l’oggetto secondo che viene costruito col costruttore (quindi il membro num è 0) e ed è richiamato su questo oggetto print() che stampa 0. secondo do = primo primo. Si esegue poi l’assegnamento secon Si richiama poi il metodo set(...) sull’oggetto secondo, passando come argomento l’intero 16. Quando si esegue l’istruzione secondo.print();, viene stampato a video il numero 16. Invocando print su primo, invece di ottenere il numero 1453, otteniamo 16. Che cosa è successo? variabile oggetto oggetto è un riferimento all’oggetto, Come Come si è dett dettoo nell nellaa sezi sezion onee 3.4, 3.4, la variabile





























4

69


Quando gli oggetti primo e secondo sono stati costruiti, nello heap si ha una situazione del genere: primo

A

num = 1453

secondo

A

num = 0

Figura 25: Gli oggetti primo e secondo dopo la creazione secondo do e dopo l’assegnamento secon

= primo primo; ; si ha:

primo

A

num = 1453

secondo

A

num = 0

Fi Figu gura ra 26: 26: Gli Gli oggetti

primo

e

secondo

dopo l’assegnamento

secondo secondo =





























4


70

public public class class A implemen implements ts Cloneab Cloneable le { // costr costrut uttor tore e di defau default lt: : rich richiam iama a il costru costrutt ttore ore A(int A(int num) num) public public A() { this(0); } /* costr costrut uttor tore: e: setta setta l’at l’attri tribut buto o num al valor valore e passa passato to come come argomen argomento to */ public public A(int A(int num) { this. this.num num = num; num; } /* impleme implementa nta il metodo metodo dell’int dell’interfa erfaccia ccia Cloneabl Cloneable: e: richi richiam ama a il metod metodo o clon clone() e() di Objec Object t */ public public Object Object clone() clone() { try { return super.clone(); super.clone(); } catch catch (CloneNo (CloneNotSup tSupport portedEx edExcep ception tion e) { return return null; null; } } // asse assegn gna a un nuov nuovo o valo valore re a num num publ public ic void void set(in set(int t num) num)





























4

71


// main main public public static static void main(Str main(String ing args[]) args[]) { A prim primo o = new new A(14 A(1453 53); ); A seco second ndo o = new new A(); A(); secondo secondo = (A)primo (A)primo.clo .clone() ne(); ; secondo.set(16); primo.print(); secondo.print(); } }

Se eseguiamo tale codice, otteniamo il seguente output: 1453 16

La situazione nello heap dopo la clonazione, cioé dopo l’istruzione secondo secondo = (A)primo (A)primo.cl .clone( one(); );

è la seguente: primo

A

num = 1453

secondo

A































4

72


Dopo l’istruzione: secondo.set(16);

La situazione è la seguente: primo

A

num = 1453

secondo

A

num = 16

Figura 28: Gli oggetti primo e secondo dopo l’istruzione secondo.set(16); Occorre notare che se una classe aggrega un’altra classe, è necessario definire il metodo clone() anche nella classe aggregata, altrimenti quest’ultima non ver-































4


73

4.2 4.2 Conf Confrronto onto Un’altra operazione importante, che può ricorrere spesso in una applicazione vera, è il confronto di oggetti della stessa classe. Java mette a disposizione il metodo equals(...) nella classe Object che confronta due oggetti e restituisce true se i due oggetti sono

identici (cioé sono lo stesso riferimento),

false altrimenti

Tale metodo non è molto utile se, per esempio, vogliamo confrontare due persone: in questo caso è necessario confrontare tutti gli attributi e restituire true se sono uguali, false altrimenti. Risulta allora conveniente riscrivere tale metodo: public public class class Persona Persona { //Costruttore: //Costruttore: inizializza gli attributi attributi public public Persona( Persona(Stri String ng nome,St nome,String ring cognome, cognome,int int anni) anni) { this































4


74

// main main public public static static void main(Str main(String ing args[]) args[]) { Persona Persona pippo pippo = new Persona( Persona("Pip "Pippo", po","Ca "Caio", io",2); 2); Persona Persona pluto pluto = new Persona( Persona("Pip "Pippo", po","Ca "Caio", io",2); 2); if (pippo.equals(pl (pippo.equals(pluto)) uto)) System.out.prin System.out.println("Son tln("Sono o la stessa persona"); persona"); else System.out.prin System.out.println("Son tln("Sono o persone diverse"); diverse"); } } public boolean boolean equals(O equals(Objec bject t object) object) riscrive il metodo omonIl metodo public imo di Object: come si può notare, tale metodo inizia con un confronto e precisamente: if (object (object instance instanceof of Persona Persona) )

questo questo controllo controllo è mol molto to important importante. e. Infatti Infatti,, quando quando nel main viene eseguita l’istruzione pippo.equals(pluto), al metodo equals(...) si sta passando l’ che è una istanza di : possiamo im-































4

75


Se avessimo una classe Cane (con un unico attributo bill, istanza di tale classe, avremmo allora: bill

nome)

ed un oggetto

Cane

nome = "bill"

Object

Figura 30: L’oggetto bill istanza di Cane Riguardiamo adesso il metodo equals(...) e notiamo che accetta come argomento un Object: nessuno ci vieta allora di scrivere nel main l’istruzione: pluto.equals(bill);

Ma ha senso confrontare un oggetto di tipo Persona con un oggetto di tipo Cane? Ovviamente no!































4


76

(Nome_della_classe_derivata)nome_dell’_oggetto

Questo tipo di conversione è pericolosa: usarl usarlaa solo quando necessario e soprattutto, prima di eseguire il cast verificare il tipo dinamico dell’oggetto con instanceof. Come vedremo, questa conversione può essere spesso evitata se si ricorre al polimorfismo!

4.3 Bind Bindin ingg dina dinami mico co Consideriamo due classi, per esempio Base da cui deriva Derivata: public public class class Base { // richiam richiama a stampa() stampa() publ public ic void void f() { stampa(); } // stamp stampa a un messa messagg ggio io

































4


public public class class Prova Prova { public public static static void main(Str main(String ing args[]) args[]) { Base Base base base = new new Base Base() (); ; Derivata Derivata derivat derivata a = new Derivat Derivata(); a(); base.f(); derivata.f(); derivata.g(); } }

77































4


78

derivata.f(); } }

Stavolta vengono creati i due oggetti base e derivata, e viene eseguito l’assegnamento: base base = deriv derivat ata; a;

cioé viene creato un secondo reference a derivata: base

Base































4


79

4.4 Seria Serializ lizzaz zazion ionee Una operazione interessante ed importante che può essere fatta su un oggetto è la serializzazione: cioé la possibilità di salvare lo stato (cioé l’insieme dei valori degli attributi in un certo istante di tempo) di un oggetto su un file. Successivamente il contenuto dell’oggetto può essere ripristinato. Per realizzare questo meccanismo su una classe, quest’ultima deve implementare l’interfaccia Serializable del package java.io: tale tale interfaccia contiene i metodi void writeObject(jav writeObject(java.io.Obj a.io.ObjectOutpu ectOutputStream tStream out) throws IOException































4


per per la stam stampa pa dell della a data data di nasc nascit ita a */ public public void stampaDa stampaDati() ti() { System.out.prin System.out.println("Nom tln("Nome: e: "+nome); "+nome); System.out.prin System.out.println("Cog tln("Cognome: nome: "+cognome); "+cognome); System.out.prin System.out.print("Nato t("Nato il: "); dataDiNascita.stampaData(); } // attribu attributi ti protect protected ed String String nome; nome;

80































4


81

A questo punto possiamo definire i due metodi che realizzano il salvataggio ed il ripristino degli oggetti: import java.io.*; java.io.*; publi public c class class Seria Serial l { // Scrive Scrive l’ogget l’oggetto to sul file "persona "persona.dat .dat" " public public void writeFil writeFile() e() { Persona Persona pippo pippo = new Persona( Persona("Tiz "Tizio", io","Ca "Caio", io",1,1, 1,1,2003 2003); ); try{

































4


82

Il metodo writeFile() crea un oggetto pippo di tipo Persona, e prova ad aprire il file persona.dat: se la classe Persona, così come Data, non avessero imple-































83

Parte III

APPENDICI































5

UNA PANORAMI ANORAMICA CA SUL LINGUA LINGUAGGIO GGIO

backslash. Gli

si dichiarano con la seguente sintassi:

84































5


5.3.2 5.3.2 Operatori Operatori relaziona relazionali li I valori delle variabili possono essere confrontati con gli operatori:

85































5


86

5.4 5.4 Blocc locchi hi I blocchi di istruzioni sono delimitati da

{

e

}

Ogni variabile variabile dichiarata dichiarata in un































































































































































































































































































































































































































































(E-Book Ita) Java _ Introduzione Alla Programmazione Orientata Ad Oggetti in Java

Recommend Documents