(e-book ita) java introduzione alla programmazione orientata ad oggetti in java

Intr oduzionealla ProgrammazioneOrientata agli Oggetti in Java

Versione1.1

EugenioPolìtoStefaniaIaffaldano

Ultimo aggiornamento:1 Novembre2003

Copyright c�

2003EugenioPolìto,StefaniaIaffaldano.All rightsreserved.

This documentis free; you can redistribute it and/ormodify it underthe termsofthe GNU GeneralPublic Licenseaspublishedby the FreeSoftwareFoundation;eitherversion2 of theLicense,or (at youroption)any laterversion.

This documentis distributedin thehopethat it will beuseful,but WITHOUT ANYWARRANTY; withouteventheimpliedwarrantyof MERCHANTABILITY or FITNESSFORA PARTICULAR PURPOSE.SeetheGNU GeneralPublicLicensefor moredetails.

You shouldhave receiveda copy of theGNU GeneralPublicLicensealongwith thisdocument;if not,write to theFreeSoftwareFoundation,Inc.,59TemplePlace,Suite330,Boston,MA 02111-1307USA.

Sosteniamola Cultura Libera:

sosteniamoil FreeSoftware

Per la segnalazionedi errori e suggerimenti,potetecontattarciai seguentiindirizzi:

Web: http://www.eugeniopolito.it

E-Mail: [email protected]

Typesetwith LATEX.

Ringraziamenti

Un graziespecialead OldDrake, Andy83e FrancescoCostaper ilpreziosoaiutochehannoofferto!

Indice

1 Intr oduzione 8

I Teoria della OOP 9

2 Le ideefondamentali 92.1 Unabrevestoriadellaprogrammazione . . . . . . . . . . . . . . 92.2 I princìpi dellaOOP. . . . . . . . . . . . . . . . . . . . . . . . . 122.3 ADT: crearenuovi tipi . . . . . . . . . . . . . . . . . . . . . . . 132.4 La classe:implementaregli ADT tramitel’incapsulamento. . . . 152.5 L’oggetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.6 Le relazionifra le classi. . . . . . . . . . . . . . . . . . . . . . . 17

2.6.1 Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.6.2 Aggregazione. . . . . . . . . . . . . . . . . . . . . . . . 182.6.3 Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . 182.6.4 Classiastratte. . . . . . . . . . . . . . . . . . . . . . . . 222.6.5 Ereditarietàmultipla . . . . . . . . . . . . . . . . . . . . 23

2.7 BindingdinamicoePolimorfismo . . . . . . . . . . . . . . . . . 27

II La OOP in Java 29

3 Classieoggetti 293.1 Definireunaclasse . . . . . . . . . . . . . . . . . . . . . . . . . 293.2 Garantirel’incapsulamento:metodipubblicie attributi privati . . 293.3 Metodi edattributi statici . . . . . . . . . . . . . . . . . . . . . . 313.4 Costruireunoggetto . . . . . . . . . . . . . . . . . . . . . . . . 323.5 La classePersona e l’oggettoeugenio . . . . . . . . . . . . . . 343.6 Realizzarele relazionifra classi . . . . . . . . . . . . . . . . . . 37

3.6.1 Uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.6.2 Metodi static : unesempio . . . . . . . . . . . . . . . . 393.6.3 Aggregazione. . . . . . . . . . . . . . . . . . . . . . . . 413.6.4 Ereditarietà . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.7 Classiastratte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523.8 Interfacce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.9 Ereditarietàmultipla . . . . . . . . . . . . . . . . . . . . . . . . 60

4 Le operazioni sugli oggetti 674.1 Copiaeclonazione . . . . . . . . . . . . . . . . . . . . . . . . . 674.2 Confronto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734.3 Bindingdinamico . . . . . . . . . . . . . . . . . . . . . . . . . . 764.4 Serializzazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

III APPENDICI 83

5 Una panoramicasul linguaggio 835.1 Tipi primitivi . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835.2 Variabili . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 845.3 Operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

5.3.1 OperatoriAritmetici . . . . . . . . . . . . . . . . . . . . 845.3.2 Operatorirelazionali . . . . . . . . . . . . . . . . . . . . 855.3.3 Operatoribooleani . . . . . . . . . . . . . . . . . . . . . 855.3.4 Operatorisubit . . . . . . . . . . . . . . . . . . . . . . . 85

5.4 Blocchi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865.5 Controllodel flusso . . . . . . . . . . . . . . . . . . . . . . . . . 865.6 Operazioni(Metodi) . . . . . . . . . . . . . . . . . . . . . . . . 87

5.6.1 Il main . . . . . . . . . . . . . . . . . . . . . . . . . . . 895.6.2 I package . . . . . . . . . . . . . . . . . . . . . . . . . . 895.6.3 Gli stream. . . . . . . . . . . . . . . . . . . . . . . . . . 905.6.4 L’I/O a lineadi comando. . . . . . . . . . . . . . . . . . 915.6.5 Le eccezioni . . . . . . . . . . . . . . . . . . . . . . . . 915.6.6 InstallazionedelJDK . . . . . . . . . . . . . . . . . . . . 93

6 La licenzaGNU GPL 94

Elencodellefigure

1 Unaclassein UML. . . . . . . . . . . . . . . . . . . . . . . . . . 152 La classePersona in UML. . . . . . . . . . . . . . . . . . . . . 163 La relazioned’uso in UML. . . . . . . . . . . . . . . . . . . . . . 174 La relazionedi aggregazionein UML. . . . . . . . . . . . . . . . 185 La relazionedi ereditarietàin UML. . . . . . . . . . . . . . . . . 196 La classedellepersonecomesottoclassedellaclassedegli animali. 207 Unapiccolagerarchia di Animali. . . . . . . . . . . . . . . . . . 218 Unapiccolagerarchia di Animali in UML. . . . . . . . . . . . . . 219 Matrimoniofra classeconcretaeastratta . . . . . . . . . . . . . 2310 Composizione:la classeStudente Lavoratore . . . . . . . . . 2311 Studente Lavoratore comeaggregazioneespecializzazione. . 2412 Studente Lavoratore comeaggregazione . . . . . . . . . . . . 2513 L’ex Studente edex Lavoratore oraDisoccupato . . . . . . . 2514 La classeStudente comesottoclassedi Persona . . . . . . . . . 2715 L’oggettoprimo appenacreato . . . . . . . . . . . . . . . . . . . 3316 L’oggettoprimo nonancoracreato . . . . . . . . . . . . . . . . . 3317 L’oggettoeugenio dopola costruzione . . . . . . . . . . . . . . 3518 EsecuzionedelprogrammaApplicazione.java . . . . . . . . . 5119 EsecuzionedelprogrammaApplicazione.java . . . . . . . . . 5520 DiagrammaUML per interface . . . . . . . . . . . . . . . . . 5621 DiagrammaUML per implements . . . . . . . . . . . . . . . . . 5922 DiagrammaUML per il matrimoniofra classeconcretaed inter-

faccia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6023 UnaPila di numeriinteri . . . . . . . . . . . . . . . . . . . . . . 6024 Esecuzionedi ProvaPila . . . . . . . . . . . . . . . . . . . . . . 6425 Gli oggetti primo e secondo dopola creazione . . . . . . . . . . 6926 Gli oggetti primo e secondo dopo l’assegnamentosecondo =

primo; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6927 Gli oggetti primo e secondo dopola clonazione. . . . . . . . . . 7128 Gli oggetti primo e secondo dopol’istruzionesecondo.set(16); 7229 Un oggettohasempreun riferimentoimplicito adObject . . . . . 7430 L’oggettobill istanzadi Cane . . . . . . . . . . . . . . . . . . . 7531 base = derivata; . . . . . . . . . . . . . . . . . . . . . . . . . 7832 Passaggiodei parametriadunafunzione . . . . . . . . . . . . . . 88

Elencodelle tabelle

1 Proecontrodell’usodi ereditarietàeaggregazione . . . . . . . . 202 Tipi primitivi di Java . . . . . . . . . . . . . . . . . . . . . . . . 83

1 INTRODUZIONE 8

1 Intr oduzione

QuestatrattazionesullaProgrammazioneOrientata agli Oggetti o Object Ori-entedProgramming (OOP in seguito)in Javanascedall’osservazioneche,moltospesso,i manualisonodegli ottimi reference(cfr. [3]) del linguaggiomanonap-profondisconoi pochi ma essenzialiconcettidella OOP; d’altra partenei corsiuniversitarisi prestafin troppaattenzionealla teoriasenzaapprofondiregli aspettiimplementativi.Quindi si cercheràdi trattaresiala teoriachela praticadellaOOPperchéentram-bi gli aspettisonofondamentaliperpoterscrivereun buoncodiceorientatoaglioggetti.PurtroppoJava vieneconsiderato(in modoerrato!) un linguaggioper scriveresoltantoappleto addiritturavieneconfusoconil linguaggiodi scriptJavaScript:conJavasi possonoscriveredelleapplicazionistandalonechenonhannomoltodainvidiare(a livello di prestazioni)ai programmiscritti conaltri linguaggiOOPpiù efficienti comeC++ . Infatti, attualmente,la Java Virtual Machine (cioé lostratosoftwarechesi occupadi trasformareil codiceintermedioo bytecodeinchiamatealle funzioni del SistemaOperativo - syscall) consentedi avere delleottimeprestazioni.In [1] potetetrovarela versione1.4del JDK.È importantesottolinearechequestononè un manualesul linguaggio,maè unatrattazionesull’impostazioneObjectOrienteddel linguaggio:comunque,senonsi conoscela sintassidi Java, èconsigliabiledareunosguardoallasezione5 doveè disponibileun veloceriassuntosullastrutturadel linguaggio.

9

Parte I

Teoria della OOPIn questaparteverrannointrodotteediscussele ideefondamentalidellaOOP. Sesi conosconogià i princìpi ed i meccanismidella OOP si puòpassarealla partesuccessiva,dovesi discutecometali concettisonorealizzatiin Java.

2 Le ideefondamentali

2.1 Una brevestoria della programmazione

La programmazionedei computeresisteormai da circa60 anni. Ovviamenteinun tempocosì lungo, ha subìtonotevoli cambiamenti:agli albori l’arte di pro-grammare consisteva nella programmazionedi ogni singolobit di informazionetramitedegli interruttorichevenivanoaccesiespenti.Quindi il programmaerainrealtàunasequenzadi accensioniespegnimentidi interruttoricheproducevanoilrisultatochesi voleva,anzichesi speravadi ottenere:pensatecosapoteva com-portarelo scambiodi unaaccensioneconunospegnimentoo viceversa!Solo intornoal 1960vennescritto il primo Assembler: questolinguaggioera(edè) troppo legatoalla strutturadel microprocessore e soprattuttoera(ed è) diffi-cile scrivereunprogrammaconun linguaggiotroppovicino allamacchinaepocoamichevoleperl’uomo.Tra il 1969 ed il 1971, DennisRitchie scrisseil primo linguaggiodi program-mazioneadalto livello: il C. Seppureè adun gradinosuperioreall’assembleresoprattuttoil codicesorgentedi un programmapuòesserericompilatosuqualsi-asi piattaforma(con qualchemodifica!),questolinguaggiorisulta ancoratroppovicino alla macchina(bastipensarechei SistemiOperativi sonoscritti in C e As-sembler).Nel1983BijarneStroustrup(programmatorepressolacompagniatelefonicaamer-icanaBell Laboratories) ebbela necessitàdi doversimulareunsistematelefonico:i linguaggiallora disponibili si prestavanopocoa programmareun sistemacosìcomplesso,cosìebbel’idea di partiredal C perscrivereun nuovo linguaggiochesupportassele classi.Nacquecosìil C conoggetti. L’idea di classeeragià notaedutilizzatain altri linguaggicomeSmalltalk.Tuttavia il C con oggetti (in seguito rinominatoC++ ) è unaestensionedel C equindi hadei pregi edeidifetti:

pro fra i pregi possiamosicuramenteannoverarel’ efficienza(propriadi C) e laportabilità del codicesorgente(con qualchemodifica) da una archittet-tura ad un’altra: i compilatoriC++ esistonoper ogni tipo di piattaforma

2 LE IDEE FONDAMENTALI 10

hardware,pertantoèsufficientequalchemodificaal codicesorgenteedunaricompilazione;

contro la gestionedella memoria,per esempio,è completamentea carico delprogrammatoree, comesi sa,la gestionedei puntatori è una fabbrica dierrori.È inoltre possibilemixaresiacodiceC checodiceC++ , ottenendocosìuncodicenonmoltopulito dalpuntodi vistadellaOOP: supponiamodi volereconfrontareduevariabili a e b. Il codicecorrettoè il seguente:

if (a == b) {...}

Ma bastaomettereun ’=’ perottenereunassegnamento:

if (a = b) {...}

sel’assegnamentovaa buonfine,vieneeseguito il bloccodi istruzioni. Unerroredelgenerepuòesserefrequente:senonusatobene,il C++ rischiadiessereun “boomerang” peril programmatore.

Nei primi mesidel 1996vennepresentatala primaversionedel linguaggioJavacheintroducevanonpochenovità:

macchinavirtuale anchesenoneraunconcettonuovonell’informatica(giàIBMavevafattodellesperimentazionisulleVirtual Machinein unSistemaOper-ativo proprietario),l’idea di sfruttareunaMacchinaVirtuale o Java VirtualMachine - JVM chesi interponefra il linguaggiointermediobytecodeedil linguaggiomacchinadellaarchitetturasottostanteeraunanovità assoluta.Tale ideaè stataultimamenteripresada unanota Software Housecon unprogettodenominato.NET . . .

portabilità grazieal concettodi Virtual Machineè sufficientecompilareunaso-la volta il programmaper poi eseguire il programma.classin formatodibytecodesuqualsiasialtrapiattaforma;perC++ valesolounaportabilitàdicodicesorgenteenondi programmaeseguibile;

esecuzionedi programmi nei browser (applet) si puòscrivereunaunicaappli-cazionechevengaeseguitasiain modonativo cheall’internodi unbrowserweb;

gestioneautomaticadella memoria questoè sicuramenteuno degli aspettipiùimportantidi Java. Ci preoccupiamosolodellacostruzionedi un oggetto,perchèla distruzioneècompletamentegestitadallaJVM tramiteil Garbage


Collector: un oggettonon più utilizzato vieneautomaticamentedistrutto.Inoltre in Java esistesolo il concettodi riferimento ad un oggetto checomportaunagestionesemplicedellanotazione(si pensialla notazione. o-> di C++ asecondacheunmetodosiarichiamatosuunavariabileoggetto/ referenceo suunpuntatore). L’assenzadellagestionedirettadeipuntatoriconsentedi produrreun codicesicuro.

Perun confrontofra JavaeC++ cfr. [4].


2.2 I princìpi della OOP

La OOPè unaevoluzionenaturale dei linguaggidi programmazione:essanasceconlo scopoprecisodi simulareemodellarela realtà. I princìpi sucui si basalaOOPsonosemplicimamolto potenti:

� Definirenuovi tipi di dati.

� Incapsularei valori e le operazioni.

� Riusareil codiceesistente(ereditarietà).

� Fornireil polimorfismo.

Comevedremo,nella OOP non si fa differenzafra valori ed operazioni: sem-plicementesi parladi Tipo di dato cheinglobale dueentitàin un’unicastruttura.Quindi ènecessariodefinire unnuovo Tipo di dato.È altrettantonecessarioaccedereadun valore di un tipo di dato: comevedremoquestoè fattibile tramiteil meccanismodi incapsulamento.Un altro cardinedella OOP è il riuso del codice: cioé utilizzaredel codicees-istenteperpoterlospecializzare.Il polimorfismo si rendenecessario,comevedremo,in unagerarchia di eredita-rietà.


2.3 ADT: crearenuovi tipi

Un Tipo di Dato Astratto o Abstract Data Type - ADT è, per definizione,unnuovo tipo di dato che estendei tipi nativi forniti dal linguaggiodi program-mazione.Un ADT ècaratterizzatodaun insiemedi:� dati;

� operazionicheagisconosuidati, leggengoli/scrivendoli;

Fin qui nientedi nuovo: anchei linguaggiprocedurali,comeperesempioC, con-sentonodi definireun ADT. Ma, mentreper tali linguaggichiunque può avereaccessoai dati emodificarli , i linguaggiObjectOrientednegarantisconola lororiservatezza.Supponiamoinfatti di volerdefinirein C (nonpreoccuparsidellasintassi)unADTPersona cioéunastruttura dati chemantengale informazioni(dati) di unaPer-sona, come,peresempio,il nome,il cognomee la datadi nascitae checonsentadi creareestamparele informazionidi unapersona(operazioni):

/* Struttura dati per mantenere la data di nascita */struct Data {

int giorno;int mese;int anno;

};

/* Struttura dati per mantenere le info. della persona */struct Persona {

struct Data *data_di_nascita;char *nome;char *cognome;

};

/* Setta le info. della persona */void creaPersona(struct Persona *persona){

persona->data_di_nascita->giorno = 31;persona->data_di_nascita->mese = 12;persona->data_di_nascita->anno = 1976;persona->nome = "Eugenio";persona->cognome = "Polito";

}


/* Stampa le info. della persona */void stampaDati(struct Persona *persona){

printf("Mi chiamo %s %s e sono nato il %i-%i-%i \n",persona->nome,persona->cognome,persona->data_di_nascita->giorno,persona->data_di_nascita->mese,persona->data_di_nascita->anno);

}

/* crea un puntatore alla struttura e lo inizializza;quindi stampa le info. */

int main(){

struct Persona *io;creaPersona(io);stampaDati(io);return 0;

}

Seeseguiamoquestoprogramma,otteniamoil seguenteoutput:

Mi chiamo Eugenio Polito e sono nato il 31-12-1976

Proviamoadessoamodificareil main nel seguentemodo:

int main(){

struct Persona *io;creaPersona(io);io->data_di_nascita->mese = 2;stampaDati(io);return 0;

}

Questavolta l’output è:

Mi chiamo Eugenio Polito e sono nato il 31-2-1976

Cioèle mie informazionipri vatesonostatemodificate conl’assegnamento:

io->data_di_nascita->mese = 2


2.4 La classe:implementaregli ADT tramite l’incapsulamento

La classeconsentedi implementaregli ADT attraversoil meccanismodi incap-sulamento: i dati devono rimanerepri vati insiemeall’implementazionee solol’interfaccia delleoperazioniè resapubblica all’esternodellaclasse.Questoapproccioè fondamentaleper garantirechenessunopossaaccederealleinformazionidella classee quindi, dal puntodi vista del programmatore,è unagaranziaper non fareerrori nella stesuradel codice: basti pensareall’esempiodell’ADT Persona visto prima. Sei dati fosserostati pri vati non avrei potutoliberamentemodificarela datadi nascitanel main . Quindi, ricapitolando,unaclasseimplementaun ADT (un sinonimodi classeè proprio tipo) attraversoilmeccanismodi incapsulamento.La descrizionedi unaclassedeveelencare:

i dati (o attributi): contengonole informazionidi unoggetto;

le operazioni (o metodi): consentonodi leggere/scriveregli attributi di unogget-to;

Quandosi scrive unaapplicazioneè buonanormainiziarecon la progettazionedell’applicazionestessa;GradyBooch identificai seguentiobiettivi in questafase:

� identificarele classi;

� identificarele funzionalitàdi questeclassi;

� trovarele relazionifra le classi;

Questoprocessononpuòcheessereiterativo.Nella fase di progettazionesi usaun formalismografico per rappresentareleclassie le relazionifra di esse:l’UML - Unified Modeling Language.In UML unaclassesi rappresentacosì:

Qui vanno messigli attributi

Qui vanno messi

Qui va il nomedella classe

i metodi

Figura1: Unaclassein UML.


Quindi la classePersona in UML ècosìrappresentata:

Figura2: La classePersona in UML.

2.5 L’oggetto

Checos’èquindiun oggetto?Perdefinizione,diciamocheun oggettoè una istanzadi una classe. Quindi unoggettodeveessereconformealla descrizionedi unaclasse.Un oggettopertantoècontraddistintoda:

1. attributi;

2. metodi;

3. identità;

Allora seabbiamounaclassePersona , possiamocrearel’oggettoeugenio cheèunaistanzadi Persona . Taleoggettoavràdegli attributi come,peresempio,nome,cognome edata di nascita ; avràdeimetodicomecreaPersona(...) , stam-paDati(...) , etc. Inoltre avrà una identitàchelo contraddistinguedaun even-tualefratellogemello,diciamopippo (anchelui ovviamenteistanzadi Persona ).Peril meccanismodi incapsulamentoun oggettonon deve mai manipolare di-rettamentei dati di un altr o oggetto: la comunicazionedeve avveniretramitemessaggi(cioé chiamatea metodi). I client devono inviare messaggiai server!Quindi nell’esempiodi prima: se il fratello gemellopippo , in un momentodiamnesia,vuolesaperequandoè natoeugenio deve inviargli un messaggio, cioédeverichiamareun metodoottieniDataDiNascita(...) .Quindi, ricapitolando,possiamodire che:

� la classeè unaentitàstaticacioéa tempodi compilazione;

� l’ oggettoèunaentitàdinamicacioéa tempodi esecuzione(run time);

Nella sezione4 vedremocomegli oggettivengonogestiti in Java.


2.6 Le relazioni fra le classi

Un aspettoimportantedellaOOPè la possibilitàdi definiredelle relazionifra leclassiperriuscirea simularee modellare il mondocheci circonda:

uso: unaclassepuòusareoggetti di un’altraclasse;

aggregazione: unaclassepuòavereoggetti di un’altraclasse;

ereditarietà: unaclassepuòestendere un’altraclasse.

Vediamolein dettagliosingolarmente.

2.6.1 Uso

L’usoo associazioneè la relazionepiù semplicecheintercorrefra dueclassi.PerdefinizionediciamocheunaclasseA usaunaclasseB se:

- un metododellaclasseA invia messaggi agli oggetti dellaclasseB, oppure

- un metododellaclasseA crea, restituisce, riceveoggetti dellaclasseB.

Peresempiol’ oggetto eugenio (istanzadi Persona ) usa l’ oggetto phobos (is-tanzadi Computer ) per programmare: quindi l’ oggetto eugenio ha un meto-do (diciamoprogramma(...) ) cheusaphobos (tale oggetto avrà per esempioun metodoscrivi(...) ). Osserviamoancòrachein questomodo l’incapsula-mento è garantito: infatti eugenio nonpuòaccederedirettamenteagli attributiprivati di phobos , comeram o bus (è il Sistema Operativo chegestiscetalirisorse). Questodiscorsopuò valereper Linux che nascondebene le risorse,manonpuòvalereperaltri SistemiOperativi cheavvertonol’avvenutoaccessoaparti di memoriariservateal kerneledinvitanoa resettare il computer. . .In UML questarelazionesi rappresentacosì:

Figura3: La relazioned’uso in UML.

Perla realizzazionedi questarelazionein Javavederela sezione3.6.1.


2.6.2 Aggregazione

Perdefinizionesi dicecheunaclasseA aggrega(contiene) oggetti di unaclasseB quandola classeA contieneoggetti dellaclasseB. Pertantotale relazioneè uncasospecialedella relazionedi uso. Sugli oggetti aggregati saràpossibilechia-maretutti i metodi, maovviamentenonsaràpossibileaccedereagli attributi (l’in-capsulamentocontinuaa “regnare”!).N.B.: la relazionedi aggregazionevieneanchechiamatarelazionehas-ao ha-un.Ritorniamoal nostroesempiodellaclassePersona : comesi è dettounapersonaha una datadi nascita. Risulta pertantoimmediatoe spontaneoaggregare unoggettodellaclasseData nellaclassePersona !In UML la relazioneA aggregaB si disegnacosì:

Figura4: La relazionedi aggregazionein UML.

Notarecheil romboèattaccatoalla classechecontienel’altra.Un oggettoaggregatoèsemplicementeun attrib uto!Vi rimandoalla sezione3.6.3perla realizzazionein Javadi talerelazione.

2.6.3 Ereditarietà

Questarelazione(anchedettainheritanceo specializzazione) èsicuramentela piùimportanteperchérendepossibileil riuso del codice.Si dice cheunaclasseD (dettala classederivata o sottoclasse) eredita da unaclasseB (dettala classebaseo superclasse) segli oggetti di D formanoun sot-toinsiemedegli oggetti dellaclassebaseB. Tale relazioneè anchedettarelazioneis-a o è-un. Inoltre si dicecheD èun sottotipo di B.Da questadefinizionepossiamoosservare che la relazionedi ereditarietà è larelazionebinaria di sottoinsieme� , cioé:

D � A

Sappiamoche � èunarelazionechegodedellaproprietàtransitiva:

C � B � A � C � A

Pertantola relazionedi ereditarietàè transiti va!Nascespontaneodomandarsiperchévale � e nonvale � .Il motivoèprestodetto:la relazione� èunarelazioned’ordinefra insiemi, quindigodedi treproprietà:


1. riflessiva: A � A

2. antisimmetrica: A � B � B � A � A � B

3. transiti va: C � B � B � A � C � A

Ma riflettendosul concettodi ereditarietà, affinché si verifichi la 1. dovrebbesuccederecheunaclasseerediti dasestessa,cioé la classedovrebbeessereunaclassederivatadasestessa:impossibile!Analogamentela proprietà2. dicecheunaclasseèunaclassebaseedunaclassederivataallo stessotempo:anchequestoè impossibile! Quindi valesolola 3.D eredita daB, in UML, si disegnacosì:

Figura5: La relazionedi ereditarietàin UML.

Vediamoadessoperchécon l’ereditarietàsi ottieneil riusodel codice.ConsideriamounaclassebaseB chehaunmetodof(...) edunaclassederivataD cheereditadaB. La classeD puòusareil metodof(...) in tremodi:

lo eredita: quindi f(...) puòessereusatocomesefosseun metododi D;

lo riscri ve (override): cioé si da un nuovo significatoal metodoriscrivendolasuaimplementazionenellaclassederivata, in modochetalemetodoeseguaunaazionediversa;

lo estende: cioé richiamail metodof(...) dellaclassebaseedaggiunge altreoperazioni.

È immediato,pertanto,osservarechela classederivatapuòrisultarepiù grandedellaclassebaserelativamentealleoperazioniedagli attributi. La classederivatanonpotràaccedereagli attributi dellaclassebase, ancheseli eredita,propriopergarantirel’incapsulamento. Tuttavia, comevedremo,èpossibileavereunaccesso


controllato agli attributi dellaclassebasedaunaclassederivata.È importantenotareche l’ereditarietà può esseresimulata con l’aggregazione(cioé is-a diventahas-a)!Ovviamenteci sonodei pro e deicontro, chepossiamoriassumerecosì:

Ereditarietà AggregazionePro Propolimorfismoebindingdinamico chiusuradei moduliContro Controlegamestrettofra classe riscritturadei metodibaseederivata nellaclassederivata

Tabella1: Proecontrodell’usodi ereditarietàeaggregazione

Javanonsupportal’inheritancemultiplo quindi è necessarioricorrereall’ag-gregazione(vederela sottosezionesuccessiva2.6.5).

Riprendiamola classePersona : pensandocibenetale classederiva da unaclassemoltopiù grande,cioéla classedegli Animali:

��

��

��

��

Animali

Persone

Cani

Figura6: La classedellepersonecomesottoclassedellaclassedegli animali.

Quindiogni Persona èunAnimale ; unoggettodi tipo Persona , comeeuge-nio , è ancheun Animale . Cosìcomeil mio canebill è un oggettodi tipo Caneedanchelui fapartedellaclasseAnimale .Riflettiamoadessosulleoperazioni(metodi)chepuòfareunAnimale : unanimalepuòmangiare, dormire, cacciare, correre, etc.UnaPersona è un Animale : di conseguenzaeredita tutte le operazionichepuòfareun Animale . Lo stessovaleperla classeCane. Ma sorgea questopuntounadomanda:unaPersona mangiacomeun Cane? La rispostaè ovviamenteNo!Infatti unaPersona perpotermangiareusale propriemani,adifferenzadelCanechefatuttoconla boccaele zampe:quindi l’operazionedelmangiaredeveessereridefinitanellaclassePersona !


Inoltre possiamopensarea cosapossafare in più una Persona rispettoad unAnimale : puòparlare, costruire, studiare, fare le guerre, inquinare... etc.Quindi nellaclassederivatasi possonoaggiungerenuoveoperazioni!Si è dettoprecedentementechela relazionedi ereditarietàè transitiva: verifichi-amoquantodettoconunesempio.Pensiamoancoraalle classeAnimale : comeci insegnaQuark (. . .e la ScuolaElementare.. . ) il mondoAnimale è compostodasottoclassicomela classedeiMammiferi , degli Anfìbi , degli Insetti , etc. La classedei Mammiferi è a suavolta compostadallaclassedegli EsseriUmani, dei Cani, delleBalene, etc.:

��

��

��

��

Animali

Mammiferi

CaniUmaniEsseri

Insetti

Alati

Non Alati

Figura7: Unapiccolagerarchia di Animali.

Ripensiamoadessoal Cane: taleclasseèunasottoclassedi Mammifero cheasuavoltaèunasottoclassedi Animale , in UML:

Figura8: Unapiccolagerarchia di Animali in UML.

Pertantoogni Cane èunMammifero e,poichéogniMammifero èun Animale ,concludiamocheun Cane è un Animale ! Pertantoogni Cane potràfareogni op-erazionedefinitanellaclasseAnimale .Conquestoesempioabbiamoancheintrodottoil concettodi gerarchia di classi,che,perdefinzione,èun insiemedi classicheestendonounaclassebasecomune.


2.6.4 Classiastratte

Riprendiamol’esempiodi Figura 8 ed esaminiamoi metodi della classebaseAnimale : consideriamo,per esempio,l’operazionecomunica(...) . Se pen-siamoad un Cane tale operazionevieneeseguita attraversole espressionidellafaccia,del corpo,dellacoda.Un Essere Umanopuòespletaretaleoperazionr inmododiverso: attraversoi gesti, le espressionifacciali, la parola. Un Delfino ,invece,comunicaattraversole ondesonore.Allora checosasignificatuttoquesto?Semplicementestiamodicendochel’oper-azionecomunica(...) non sappiamocomepuò essere realizzatanella classebase! Un discorsoanalogopuòesserefattoper l’operazionemangia(...) .In sostanzasappiamochequestimetodiesistonoper tutte le classichederivanoda Animale echesonopropriotali classiasaperecomerealizzare(implementare)questimetodi.I metodicomecomunica(...) , mangia(...) etc.,si diconometodi astratti ometodi differiti : cioési dichiaranonellaclassebase, manonvengonoimplemen-tati; sarannole classiderivateasaperecomeimplementare tali operazioni.Unaclassechehaalmenounmetodoastrattosi diceclasseastratta edeveesseredichiarata tale. Unaclasseastratta puòancheconteneredei metodinonastratti(concreti)!Nella sezione3.7vedremocomedichiararleeusarlein Java.Attraversodelleconsiderazionisiamoarrivati a definirela classeAnimale comeclasseastratta.Riflettiamoun momentosul significatodi questadefinizione:creareoggetti dellaclasseAnimale serveabenpoco,proprioperchétaleclasseèfin troppogenericaper essereistanziata. Piuttostopuò essereusatacomeun contenitore di com-portamenti(operazioni)comunicheogni classederivatasacomeimplementare!Questoèunaltro puntofondamentaledellaOOP:

È beneindividuare le operazioni comuni per poterle posizionareal livellopiù alto nella gerarchia di ereditarietà.

La classeCane, Delfino etc.,implementerannoogni operazioneastratta, proprioperchéognunadi questeclassisacomefarepersvolgerele operazioniereditatedallaclassebase.


2.6.5 Ereditarietà multipla

Nella sottosezione2.6.3si è parlatodella relazionedi ereditarietàfra dueclassi.Questarelazionepuòessereestesaa più classi.Esistonotre formedi ereditarietàmultipla:

matrimonio fra una classeconcretaed una astratta: peresempio:

Figura9: Matrimoniofra classeconcretae astratta

Quindi Stack è la classeastratta chedefiniscele operazioni push(...) ,pop(...) , etc.La classearray serveperla manipolazionedegli array.Pertantola Pila implementale operazionidello Stack e le richiamasuunarray .

duplice sottotipo: unaclasseimplementadueinterfaccefiltrate.

composizione: unaclasseestendedueo più classi concrete. È proprio questocasochegeneraalcuniproblemi.Consideriamoil classicoesempio(cfr. [2]) della classeStudente Lavo-ratore : questaclasseestendela classeStudente e Lavoratore (en-trambeestendonola classePersona ):

Figura10: Composizione:la classeStudente Lavoratore


La classePersona hadegli attributi, comenome, cognome , data di na-scita etc.,e dei metodi, come,per esempio,mangia(...) . Sia la classeStudente chela classeLavoratore estendonola classePersona , quin-di erediterannosia attributi che metodi. Supponiamodi crearel’oggettoeugenio comeistanzadi Studente Lavoratore e richiamiamosudi es-so il metodomangia(...) . Purtroppotale metodoesistesia nella classeStudente chenellaclasseLavoratore : qualemetodosaràusato?Nessunodei dueperché il compilatore riporterà un errore in fasedi compilazione!Analogamentei membrisarannoduplicati perchésarannoereditati da en-trambele classi(Studente e Lavoratore ): eugenio si ritroveràconduenomi,duecognomieduedatedi nascita.I progettistidi Java, proprio per evitare simili problemi,hannodecisodinonsupportarela composionecomeformadi ereditarietàmultipla.Però,comesi èdettonellasezione2.6.3,l’ereditarietàpuòesseresimulatacon l’aggregazione, pertantoil diagrammaUML di Figura10 può esserecosìridisegnato:

Figura11: Studente Lavoratore comeaggregazioneespecializzazione

Adessolo Studente Lavoratore eredita un solo metodomangia(...) ,dorme(...) , etc.,cosìcomeavràun solonome,cognome,etc.Seeugenio deve lavorare(.. . ) richiameràil metodoomonimosull’oggettoaggregato istanzadi Lavoratore .Questoesempioportaadun’altrariflessioneimportante:maeugenio saràsempreuno Studente ? Si speradi no.. . Prima o poi finirà di studiare!Comesi è dettoin Tabella1, l’ereditarietàha lo svantaggiodi stabilireunlegametr oppo forte tra classebasee derivata. Ciò significachel’ oggettoeugenio (chemagaricontinuaaviverenellasocietàin qualitàdi Lavorato-re ), anchequandonon saràpiù uno Studente , potrà invocareil metodofaiLaFilaInSegreteria(...) o ricopiaAppunti(...) , perchécon-


tinua ad essereuno Studente , secondola gerarchiadi Figura11!Risultaimmediatocambiarenuovamentel’ ereditarietàconl’ aggregazione:

Figura12: Studente Lavoratore comeaggregazione

In questomodo, ad esempio,il metodofaiLaFilaInSegreteria(...)vienerichiamatosull’oggettoaggregato istanzadi Studente . Quandoeu-genio non saràpiù Studente , l’ oggetto aggregato istanzadi Studenteverràeliminato(tantoèun sempliceattributo!).Sepoi malauguratamenteeugenio perdeil propriolavoro,nonaggregapiùla classeLavoratore : può comunqueaggregare unanuova classe, comeperesempioDisoccupato :

Figura13: L’ex Studente edex Lavoratore oraDisoccupato

Perchéabbiamoaggregatounanuovaclasse(Disoccupato )? Seguardiamola Figura11 si ha(perla transitivitàdella relazionedi ereditarietà):Studente Lavoratore � Studente � Persona �Studente Lavoratore � Persona .Quindi ogni Studente Lavoratore puòinvocareil metodomangia(...)dellaclassePersona (lo eredita).Analogamente,in Figura11, vediamochesia Studente cheLavoratoreereditanodaPersona . QuindiunoStudente Lavoratore puòinvocareilmetodomangia(...) siasull’oggettoaggregato istanzadi Studente chesull’oggettoaggregato istanzadi Lavoratore .


Ma seun oggetto di classeStudente Lavoratore terminadi studiareeperdeil lavoro (cioé eliminiamo gli attributi, oggetti di tipo Studente eLavoratore ) potrà continuarea mangiare? Risposta: No! Ecco spie-gato il motivo per cui è stataaggregata una nuova classein StudenteLavoratore .

Ricapitolando:

� L’ereditarietà multipla sottoformadi composizionepuò esseremodellatacon l’aggregazionee con l’ereditarietàsingola. È beneusarequestacom-binazionepernonincorrerein problemiseridurantela stesuradel codice.

� Usarel’ereditarietà solo quandoil legamefra la classebasee la classederivata è per sempre, cioé dura per tutta la vita degli oggetti, istanzedella classederivata. Setale legamenon è duraturoè meglio usarel’ag-gregazioneal postodellaspecializzazione.


2.7 Binding dinamico ePolimorfismo

La parolapolimorfismo deriva dal grecoe significa letteralmentemolte forme.Nella OOP tale terminesi riferisceai metodi: per definizione,il polimorfismoèla capacitàdi un oggetto, la cui classefa partedi unagerarchia, di chiamare laversionecorrettadi un metodo.Quindi il polimorfismoènecessarioquandosi haunagerarchia di classi.Consideriamoil seguenteesempio:

Figura14: La classeStudente comesottoclassedi Persona

Nella classebasePersona è definito il metodocalcolaSomma(...) , che,peresempio,eseguela sommasuinaturali2+2erestituisce5 (in 3 vedremocomepassareargomentiadun metodoe restituirevalori); la classederivataStudenteinveceriscri ve il metodocalcolaSomma(...) edeseguela sommasui naturali2+2 in modocorretto,restituendo4.N.B. Il metododeve avere lo stessonome,parametrie tipo di ritorno in ogniclasse, altrimentinonhasensoparlaredi polimorfismo.Creiamoadessol’ oggettoeugenio comeistanzadi Studente edapplichiamoilmetodocalcolaSomma(...) . L’oggettoeugenio è istanzadi Studente , quindiverràrichiamatoil metododi taleclasseedil risulatosarà4.Supponiamoadessodi modificareil tipo di eugenio in Persona (non ci preoc-cupiamodel dettagliodel linguaggio,vedremoin 4.3 comeè possibilefarlo inJava): cambiareil tipo di un oggetto, istanzadi unaclassederivata, in tipo del-la classebaseè possibileed è proprio per questomotivo che è necessarioilpolimorfismo; tuttavia questaconversioneo castcomportaunaperditadi propri-etàdell’oggettoperchéunaclassebasehamenoinformazioni(metodiedattributi)dellaclassederivata.A questopuntorichiamiamoil metodocalcolaSomma(...) sull’oggettoeugenio .Stavoltaverràrichiamatoil metododellaclassebase: il tipodi eugenio èPersonae quindi il risultatoè5!Ma comeè possibileinvocareun metodosullo stessooggetto in baseal suotipo?Ovviamentequestonon può esserefatto durantela compilazionedel program-ma, perchéil metododa invocaredeve dipenderedal tipo dell’oggetto durante


l’esecuzionedel programma! Perrenderepossibilequestoil compilatoredevefornire il binding dinamico, cioé il compilatorenon genera il codiceper chia-mareun metododurantela compilazione(binding statico), ma generail codicepercalcolare qualemetodochiamaresuun oggetto in basealle informazionisultipo dell’oggettostessodurantel’esecuzione(run-time) del programma.Questomeccanismorendepossibileil polimorfismo puro (o per sottotipo): il messag-gio cheè statoinviato all’oggetto eugenio era lo stesso, peròciò checambiavaerala selezionedel metodocorrettoda invocarechedipendeva quindi dal tipo arun-time dell’oggetto.Ecco comeviene invocatocorrettamenteun metodoin una gerarchia di ered-itarietà (supponiamoche il metodovengarichiamatosu una sottoclasse, p.e.Studente ):

� la sottoclassecontrolla seha un tale metodo; in casoaffermativo lo usa,altrimenti:

� la classepadre si assumela responsabilitàe cercail metodo. Se lo trovalo usa,altrimenti saràla suaclassepadrea predenderela responsabilitàdigestirlo.

Questacatenasi interrompeseil metodovienetrovato,e saràtale classead in-vocarlo,altrimenti,senonvienetrovato,il compilatoresegnalal’errore in fasedicompilazione. Pertantolo stessometodopuòesisteresupiù livelli dellagerarchiadi ereditarietà.Il polimofismopuro nonè l’unica formadi polimorfismo:

polimorfismo ad hoc (overloading) unmetodopuòaverelo stessonomemapa-rametri diversi: il compilatoresceglie la versionecorrettadel metodoinbaseal numeroed al tipo dei parametri.Il tipo di ritorno nonvieneusatoper la risoluzione, cioésesi haunmetodocongli stessiargomentiediversotipo di ritorno, il compilatoresegnalaun erroredurantela compilazione.Talemeccanismoèquindi risoltoa tempodi compilazione.N.B. Il polimorfismopuro invecesi applicaa metodicon lo stessonome,numero e tipo di parametrie tipo di ritorno evienerisolto a run-time .

polimorfismo parametrico èla capacitàdi eseguiredelleoperazionisuunqual-siasi tipo: questatipologia non esistein Java (ma può esseresimulatocfr. 3.9), perchénecessitadel supportodi classi parametriche. Per larealizzazionedi questomeccanismoin C++ cfr. [2].

29

Parte II

La OOP in JavaIn questapartevedremocomevengonorealizzatii concettidellaOOP in Java.

3 Classie oggetti

3.1 Definire una classe

La definizionedi unaclassein Javaavvienetramitela parolachiaveclass seguitadal nomedella classe. Affinchéunaclassesia visibile ad altre classi e quindiistanziabileènecessariodefinirlapublic :

public class Prima{}

N.B. In Javaogni classederivadallaclassebasecosmicaObject: quindianchesenonlo scriviamoesplicitamente,il compilatoresi occupadi stabilirela relazionedi ereditarietàfra la nostra classee la classeObject ! Le parentesi{ e } individ-uanol’inzio e la finedellaclasseed,in generale,unbloccodi istruzioni.È beneusarela letteramaiuscolainiziale peril nomedellaclasse; inoltre il nomedella classedeve esserelo stessodel nomedel file fisico, cioé in questocasoavremmoPrima.java(vederela sezione5). Affinchéunaclasserealizziun ADT(cfr. sezione2.3)ènecessariodefinirei dati e le operazioni.

3.2 Garantir e l’incapsulamento: metodipubblici eattributi pri-vati

Comesi è detto(cfr. sezione2.4),unodei princìpi dellaOOPè l’incapsulamen-to: quindiènecessariodefiniredati (membrinella terminologia Java) pri vati e leoperazioni(detti anchemetodiin Java) pubbliche.Definiamol’ ADT Persona dellasezione2.3 in Java; peradessosupponiamochela personaabbia tre attributi nome, cognome , anni e due metodicreaPerso-na(...) e stampaDati(...) :

3 CLASSIE OGGETTI 30

public class Persona{

/* questo metodo inizializza gli attributi nome,cognome ed anni

*/public void creaPersona(String n,String c,int a){

nome = n;cognome = c;anni = a;

}

// questo metodo stampa gli attributipublic void stampaDati(){

System.out.println("Nome: "+nome);System.out.println("Cognome: "+cognome);System.out.println("Età: "+anni);

}

// attributiprivate String nome;private String cognome;private int anni;

}

Abbiamodefinitoquindigli attributi pri vateedi metodipublic: l’incapsulamen-to ègarantito!Riflettiamounattimosullasintassi:

attrib uti: la dichiarazionedi un attributo richiede il modificatore di accesso(usaresemprepri vate!), il tipo dell’attributo (String , int , etc. chepuòesseresia un tipo primitivo cheunaclasse- vederela sezione5 per i tipiprimitivi del linguaggio)edil nomedell’attib uto (anni , nome, etc.);

metodi: la dichiarazionedi un metodorichiedeinvece: il modificatore di ac-cesso(può esseresia public che pri vate, in questocasoperò il metodonon potrà essereinvocatoda un oggetto - è beneusarloper “funzioni diservizio”), il tipo di ritor no chepuò essere:o un tipo primiti vo o unaclasseo void: cioè il metodonon restituiscealcuna informazione. Seil


tipo di ritor no èdiversodavoid, deveessereusatal’istruzionereturn val-ore_da_restituire; comeultima istruzionedel metodo; il valore_da_resti-tuir e deve avereun tipo in match col tipo di ritor no (devono essereglistessitipi). Seguequindi il nomedel metodoe fra parentesitondesi speci-ficanogli argomenti (anchedetti firma del metodo): ancheessiavrannoun tipo (primitivo o unaclasse) edun nome; più argomentivannoseparatidaunavirgola.La listadegli argomentipuòesserevuota.Nel nostrocasogli argomentipassatial metodocreaPersona(...) ser-vonoper inizializzare gli attributi: con l’ assegnamentonome = n; stiamodicendocheall’attributonome stiamoassegnandogli la variabile n.

// vieneusatoper i commentisuunasingolalinea,mentre/* e */ vengonousatiperscriverecommentisupiù linee(il compilatoreignorai commenti).Il metodoprintln(...) dellaclasseSystem èusatoperscriverel’output avideoe + serveperconcatenarestringhe(vederela sezione5).La classe, cosìcomeè statadefinita,nonserve ancoraa molto: vogliamocreareoggetti chesianoistanzedi questaclasse, sui quali possiamoinvocaredei meto-di. Dove andremoad istanziareun genericooggetto di tipo Persona ? Primadi risponderea questadomandaaffrontiamoun altro discorsoimportantecheciserviràpercapire“alcune cose”:

3.3 Metodi ed attrib uti statici

Gli attributi static sonoutili quandoè necessariocondividerli fra più oggetti,quindi anzichéaverepiù copiedi un attributo chedovrà esserelo stessoper tuttigli oggetti istanzadella stessaclasse, essovieneinzializzatounavolta per tuttee postonella memoriastatica. Un simile attributo avrà la stessavita del pro-gramma,peresempiopossiamoimmaginarechein unaclasseData è utile averememorizzatoun array (cfr. 5) dei mesi dell’anno:

private static String[] mesi = {"Gen","Feb","Mar","Apr","Mag","Giu","Lug","Ago","Set","Ott","Nov","Dic"};

Talearraysaràcondiviso fra tutti gli oggetti di tipo Data .Siccometalearray, è in realtàcostante, risultacomododefinirlo tale: in Javasiusala parolafinal perdefinireun attributocostante:

private static final String[] mesi = {"Gen","Feb","Mar","Apr","Mag","Giu",


"Lug","Ago","Set","Ott","Nov","Dic"};

Quindi mesi nonèmodificabile!Allo stessomodoè possibiledefinireun metodostatic : un talemetodopuòes-sererichiamatosenzala necessitàdi istanziare la classe(vederela sottosezione3.6.2perunesempio).In Javaesisteunpuntodi inizio per ogni programma, dovepotercrearel’ogget-to istanzadella classeed invocarei metodi: il metodomain(...) . Essovienerichiamatoprima che qualsiasioggetto è statoistanziato,pertantoè necessariochesiaun metodostatico. La suadichiarazione,chedeve comparirein una solaclasse, è la seguente:

public static void main(String args[]){}

Quindièpublic perpoteresserevistoall’esterno,èstatic peril motivochesi dice-va prima,nonhaalcuntipo di ritor no, accettadegli argomenti di tipo Stringchepossonoesserepassatia lineadi comando.

3.4 Costruir eun oggetto

Possiamoadessoaffrontarela costruzionedi un oggetto.In Javaunoggettovienecostruitoconil seguenteassegnamento:

Prova primo = new Prova();

Analizziamola sintassi:stiamodicendocheil nostrooggetto di nomeprimo èuna istanzadellaclasseProva e chelo stiamocostruendo, con l’ operatore new,attraversoil costruttore Prova() .L’oggettochevienecosìcreatoè postonellamemoriaheap(o memoriadinami-ca), la qualecrescee dimuniscea run-time, ogni volta cheun oggettoè creatoedistrutto.N.B. Mentrela costruzionela controlliamonoi direttamente,la distruzionevienegestitaautomaticamentedalla JVM: quandoun oggetto non vienepiù usato,laJVM si assumela responsabilitàdi eliminarlo, senzachenoi cenepossiamoac-corgere,tramiteil meccanismodi GarbageCollection!L’assegnamentodicechela variabileoggettoprimo èunriferimento adunogget-to, istanzadellaclasseProva .Il concettodi riferimentoèimportante:molti pensanocheJavanonabbiai punta-tori: sbagliato! Javanonhala sintassidapuntatoremanehail comportamento.


Infatti unavariabile oggetto serve per accedere all’ oggettoe non per memo-rizzarne le sue informazioni!; pertantoun oggetto di Java si comportacomeunavariabile puntatore di C++ . La gestionedei puntatorivienecompletamentenascostaal programmatore,il qualepuòsolousareriferimenti agli oggetti.La situazionedopola costruzionedell’oggettoprimo è la seguente:

primo

Prova

Figura15: L’oggettoprimo appenacreato

Sottolineiamocheconla seguentescrittura:

Prova primo;

nonèstatocreatoalcunoggetto,infatti si stasemplicementedicendochel’oggettoprimo cheverrà creatosaràunaistanzadi Prova o di unasuasottoclasse; si haquestasituazione:

primo

Prova

Figura16: L’oggettoprimo nonancoracreato

cioé primo non è ancora un oggetto in quantonon fa riferimentoa niente!La costruzionedovràavvenireconl’istruzione:

primo = new Prova();

Comesi è dettoprima,il metodoProva() è il costruttore dell’oggetto, cioéè il metodochesi occupadi inizializzaregli attributi dell’oggetto.Essendoun metodopuòessereoverloadato, cioépuòessereusatoconargomentidiversi. Un costruttore privo di argomentisi dicecostruttore di default: senonseneforniscenessuno,Javasi occupadi crearneunodi defaultautomaticamentechesi occupadi inizializzaregli attributi.Il costruttorehalo stessonomedellaclasseenonhaalcuntipo di ritorno.Inoltre essoè richiamatosoltantounavolta,cioéquandol’oggettovienecreatoenonpuòesserepiù richimatodurantela vita dell’oggetto.


3.5 La classePersona e l’oggettoeugenio

Vediamoalloracomescrivereunaversionemigliore dellaclassePersona , in cuiforniamouncostruttoreedun main :


// Costruttore: inizializza gli attributi nome, cognome, annipublic Persona(String nome,String cognome,int anni){

this.nome = nome;this.cognome = cognome;this.anni = anni;

}



}


// mainpublic static void main(String args[]){

Persona eugenio = new Persona("Eugenio","Polito",26);eugenio.stampaDati();

}

}

Commentiamoquestaclasse: abbiamodefinito il costruttore Persona(Stringnome, String cognome, int anni) chesi occupadi riceverein ingressoi treparametrinome, cognome ed anni e si occupadi inizializzaregli attributi nome,cognome e anni con i valori dei parametri. Comesi può notareè statausata


la parolachiave this : questonon è altro che un puntatoreche fa riferimen-to all’oggetto attuale (o implicito). Quindi la sintassithis.nome significa “f airiferimentoall’attributo nome dell’oggettocorrente”. In questocasoè essenzialeperchèil nomedell’argomentoedil nomedell’attributo sonoidentici. Comeve-dremo,this èutile ancheperrichiamarealtri costruttori.Il metodostampaDati() serveperstamparegli attributi dell’oggetto.Il metodomain(...) contieneal suointernodueistruzioni:

Persona eugenio = new Persona("Eugenio","Polito",26); contaleistru-zionestiamocreandol’ oggettoeugenio : essovienecostruitoconil costrut-tore cheha la firma (gli argomenti)String,String,int (l’unico cheab-biamodefinito). A run time la situazione,dopoquestoassegnamento,saràla seguente:

eugenio Persona

cognome = "Polito"

nome = "Eugenio"

anni = 26

stampaDati()

Figura17: L’oggettoeugenio dopola costruzione

eugenio.stampaDati(); richiamail metodostampaDati() sull’oggetto eu-genio ; il “.” vieneusatoperaccedereal metodo.

E seavessimovoluto costruire l’ oggettocol costruttoredi default? Avremmoottenutoun errore,perchénellaclassenonsarebbestatotrovatodal compilatorealcuncostruttoresenzaargomenti, quindi èbenefornirneuno:


// Costruttore di defaultpublic Persona(){

this("","",0);}

// Costruttore: inzializza gli attributi nome, cognome, annipublic Persona(String nome,String cognome,int anni){

this.nome = nome;


this.cognome = cognome;this.anni = anni;

}



}



Persona eugenio = new Persona("Eugenio","Polito",26);Persona anonimo = new Persona();eugenio.stampaDati();anonimo.stampaDati();

}

}

Il costruttore di defaultrichiamail costruttore chehacomeargomenti:String,String, int , attraversoil riferimentoall’argomentoimplicito this . In questoesempioil costruttore è un metodocheusal’ overloading: in baseal numero etipo di argomenti, il compilatoreselezionala versionecorrettadel metodo(cfr.Sezione2.7).L’output delprogrammaè il seguente:

Nome: EugenioCognome: PolitoEtà: 26Nome:Cognome:Età: 0


3.6 Realizzare le relazioni fra classi

3.6.1 Uso

Riprendiamol’esempiodellasezione2.6.1:vediamocomesi realizzala relazionedi uso. Supponiamochela classePersona usi la classeComputer per eseguireil prodottoe la sommadi 2 numeri,quindi definiamola classeComputer e poi laclassePersona :

public class Computer{

// restituisce il prodotto di a * bpublic int calcolaProdotto(int a, int b){

return a*b;}

// restituisce la somma di a + bpublic int calcolaSomma(int a, int b){

return a+b;}

}

Tale classeha il metodocalcolaProdotto(...) che si occupadi calcolareil prodottodi due numeri, passaticomeargomentoe di restituirne il risultato(return a*b; ). Il discorsoèanalogoperil metodocalcolaSomma(...) .La classePersona inveceè:



this("","",0);}


this.nome = nome;this.cognome = cognome;


this.anni = anni;}



}

/* usa l’oggetto ’phobos’ istanza di Computerper eseguire il prodotto e la somma degliinteri a e b passati come argomenti */

public void usaComputer(int a, int b){

Computer phobos = new Computer();int res = phobos.calcolaProdotto(a,b);System.out.println("Risultato del prodotto "+a+

" * "+b+": "+res);res = phobos.calcolaSomma(a,b);System.out.println("Risultato della somma "+a+

" + "+b+": "+res);}



Persona eugenio = new Persona("Eugenio","Polito",26);eugenio.usaComputer(5,5);

}}

Il metodousaComputer(...) crea(quindiusa) unoggettophobos , istanzadellaclasseComputer (Computer phobos = new Computer(); ) richiamail metodo


calcolaProdotto(...) suphobos , passandogligli argomentia e b. Il risultatodel calcolovienepostotemporaneamentenella variabile locale res : all’uscitadal metodotale variabile verràeliminata;ogni variabile locale deve esserein-izializzata, altrimenti il compilatoreriportaun errore!L’ istruzionesuccessivaSystem.out.println(...) stampal’output a video.res = phobos.calcolaSomma(a,b); richiamasull’oggetto phobos il metodocalcolaSomma(...) ed il risultato viene posto in res (tale variabile è statagià dichiarata quindi non si deve specificaredi nuovo il tipo, inoltre il risulta-to del prodottovienepersoperchéadessores contieneil valoredella somma!).L’istruzionesuccessivastampail risultatodellasomma.Notiamo che così comela variabile locale res nasce, vive e muore in questometodo, anchel’ oggettophobos ha lo stessociclo di vita: quandoil metodoter-mina, l’ oggetto phobos vienedistrutto automaticamentedal Garbage Collectordella JVM e la memoriadalui occupatavieneliberata.N.B. Gli oggetti costruiti nel main (cosìcomele variabili) vivono per tutta ladurata del programma!Nel main vienecreatol’ oggettoeugenio cheinvocail metodousaComputer(...)perusare il computer.

3.6.2 Metodi static : un esempio

Riprendiamola classeComputer : comepossiamonotare,nonhadegli attribu-ti ; in realtà,nonci importaistanziaretaleclasseperché,cosìcomeèstatadefini-ta, fungepiù dacontenitoredi metodichedaclasseistanziabile.Pertantoi metodidi taleclasseli possiamodefinirestatic :

public class Computer{

// restituisce il prodotto di a * bpublic static int calcolaProdotto(int a, int b){

return a*b;}

// restituisce la somma di a + bpublic static int calcolaSomma(int a, int b){

return a+b;}

}

Adessodobbiamorivedereil metodousaComputer(...) dellaclassePersona :




this("","",0);}



}



/* usa i metodi della classe Computer per eseguireil prodotto e la somma fra gli interi a e bpassati come argomenti */

public void usaComputer(int a, int b){

int res = Computer.calcolaProdotto(a,b);System.out.println("Risultato del prodotto "+a+

" * "+b+": "+res);res = Computer.calcolaSomma(a,b);System.out.println("Risultato della somma "+a+

" + "+b+": "+res);}




Persona eugenio = new Persona("Eugenio","Polito",26);eugenio.usaComputer(5,5);

}}

Comesi puònotarenelmetodousaComputer(...) , questavoltanonvienecreatoun oggetto istanzadella classeComputer , ma si usaquest’ultimaper accedereai metodicalcolaSomma(...) e calcolaProdotto(...) , essendodei metodistatic .

3.6.3 Aggregazione

Riprendiamol’esempiodiscussonellasezione2.6.2:sidicevachelaclassePersonaaggrega la classeData , perchéogni personaha una datadi nascita.Definiamola classeData :

public class Data {/* Costruttore: inizializza gli attributi giorno,

mese, anno con i valori passati comeargomenti */

public Data(int giorno, int mese, int anno){

this.giorno = giorno;this.mese = mese;this.anno = anno;

}

// stampa la Datapublic void stampaData(){

System.out.println(giorno+"/"+mese +"/"+ anno) ;}

// attributiprivate int giorno, mese, anno;

}

Tale classeha gli attributi giorno , mese e anno che vengonoinizializzati colcostruttoreepossonoesserestampatiavideocol metodostampaData() .La classePersona :


public class Persona {/* Costruttore: inizializza gli attributi nome, cognome,

e data di nascita */public Persona(String nome,

String cognome,int giorno,int mese,int anno)

{this.nome = nome;this.cognome = cognome;dataDiNascita = new Data(giorno,mese,anno);

}

/* stampa gli attributi e richiama il metodostampaData() sull’oggetto dataDiNascitaper la stampa della data di nascita */

public void stampaDati(){

System.out.println("Nome: "+nome);System.out.println("Cognome: "+cognome);System.out.print("Nato il: ");dataDiNascita.stampaData();

}

// attributiprivate String nome;private String cognome;private Data dataDiNascita;


Persona eugenio = new Persona("Eugenio","Polito",31,12, 1976) ;eugenio.stampaDati();

}}

contienegli attributi nome, cognome e dataDiNascita (istanzadi Data ): quindil’aggregazionesi realizzain Javacomeattributo.Notiamochel’ oggettodataDiNascita vienecreatonel costruttorecongli argo-


menti passaticomeparametri: l’ oggettovienecostruitosolo quandosi sacomefarlo.Osserviamochel’incapsulamentoègarantito:gli attributi dell’oggettodataDi-Nascita possonoessereletti solocol metodostampaData() .N.B. Comesi è dettoil main deve comparireuna sola volta in una sola classe;per chiarezza, quandosi ha più di unaclasse, è consigliabileporlo in un’altraclasse. Quindi, in questocaso,lo togliamodallaclassePersona e lo poniamoinunanuovaclasse, diciamoApplicazione :

public class Persona {/* Costruttore: inizializza gli attributi nome, cognome,

e data di nascita */public Persona(String nome,



}




}// attributiprivate String nome;private String cognome;private Data dataDiNascita;

}

e la classeApplicazione conterràil main :

public class Applicazione {



Persona eugenio = new Persona("Eugenio","Polito",31,12, 1976) ;eugenio.stampaDati();

}}

In seguitoverràutilizzatoquestomododi procedere.

3.6.4 Ereditarietà

Vogliamoestendere la classePersona in mododa gestirela classeStudente ,cioévogliamocheStudente erediti daPersona : questoè logicamentevero dalmomentocheogni Studente èuna Persona .Definiamola classePersona :

import java.util.Random;


/* Costruttore: inizializza gli attributi nome, cognome,e data di nascita */

public Persona(String nome,String cognome,int giorno,int mese,int anno)


}



System.out.println("Nome: "+nome);System.out.println("Cognome: "+cognome);System.out.print("Nato il: ");


dataDiNascita.stampaData();}

// autoesplicativopublic void mangia(){

System.out.println("\nMangio con forchetta e coltello\n");}

// stampa casualmente ’n’ numeri (magari da giocare al lotto:)public void conta(int n){

System.out.print("Conto: ");Random r = new Random();for (int i = 0; i < n; i++)

System.out.print(r.nextInt(n)+"\t") ;System.out.println();

}

// attributiprivate String nome;private String cognome;private Data dataDiNascita;

}

Conl’ istruzioneimport java.util.Random si staimportandola classeRandomcheècontenutanel packagejava.util (perl’uso deipackagevederela sezione5) eservepergeneraredei numeripseudo-casuali.Il costruttoreedil metodostampaDati() sonostatigiàdiscussi.Il metodomangia() stampaa video un messaggiomolto eloquente;il simbolo“ � n” serveperandareacapo.Il metodoconta(...) riceve comeargomentoun intero n, e stampan numericasualiattraversoun ciclo iterativo (peri cicli vedere5).Adessovogliamodefinire la classeStudente comesottoclassedi Persona , incui:

� il metodomangia() vieneereditato;

� il metodoconta(...) vieneriscritto ;

� il metodostampaDati() vieneesteso.

� vieneaggiunto il metodofaiFilaInSegreteria() ;


Supponiamoinoltrechela nuovaclasseabbial’ attributoanniDiScuola .La classeStudente èdunque:

public class Studente extends Persona{

/* Costruttore: richiama il costruttore della classe base(inializzando gli attributi nome, cognome, dataDiNascita)ed inializza il membro anniDiScuola */

public Studente(String nome,String cognome,int giorno,int mese,int anno,int anniDiScuola)

{super(nome,cognome,giorno,mese,ann o);this.anniDiScuola = anniDiScuola;

}

/* Riscrive il metodo omonimo della classe base:Stampa i numeri 1,2,...,n */

public void conta(int n){

System.out.print("Conto: ");for (int i = 1; i <= n; i++)

System.out.print(i+"\t");System.out.println();

}

/* Estende il metodo omonimo della classe base:richiama il metodo della classe base omonimoed in più stampa l’attributo anniDiScuola */


super.stampaDati();System.out.println("Anni di scuola: "+anniDiScuola);

}

/* stampa il messaggio ... */public void faiFilaInSegreteria(){


System.out.println("...Aspetto il mio turnoin segreteria...");

}

// attributoprivate int anniDiScuola;

}

In Java l’ ereditarietàè resapossibileconla parola chiaveextends .Il costruttore richiama il costruttore della classebase, cheha la firma String,String, int ,int, int , attraversolaparolachiavesuper ; inoltreinizializzailmembro anniDiScuola . Notiamochepercostruiregli attributi nome, cognome,dataDiNascita ènecessarioricorrereal costruttoredellaclassebaseperchéhan-no tutti campodi visibilità (o scope)pri vate.Il metodoconta(...) è statoriscritto : ora stampa“correttamente”i numeri1,2,.. . ,n.Il metodostampaDati(...) è statoesteso: richiamail metodoomonimodellaclassebaseedin più stampal’ attributoanniDiScuola .Infine è statoaggiuntoil metodofaiFilaInSegreteria chestampaun messag-gio di attesa.. .Comesi è detto gli attributi della classebasenon sonoaccessibilialla classederivata perchéhannoscopepri vate. Tuttavia è possibileconsentiresolo alleclassiderivatedi avereun accessoprotettoagli attributi, attraversoil modifica-tore di accessoprotected. La classePersona può esserepertantoriscritta nelseguentemodo:

import java.util.Random;

public class Persona{// Costruttore di defaultpublic Persona(){

this("","",0,0,0);}

/* Costruttore: inizializza gli attributi nome, cognome,anni e data di nascita */

public Persona(String nome,String cognome,int giorno,int mese,int anno)


{this.nome = nome;this.cognome = cognome;this.dataDiNascita = new Data(giorno,mese,anno);

}




}

// autoesplicativopublic void mangia(){

System.out.println("\nMangio con forchetta e coltello\n");}

// stampa casualmente ’n’ numeri (magari da giocare al lotto:)public void conta(int n){

System.out.print("Conto: ");Random r = new Random();for (int i = 0; i < n; i++)

System.out.print(r.nextInt(n)+"\t") ;System.out.println();

}

// attributiprotected String nome;protected String cognome;protected Data dataDiNascita;

// mainpublic static void main(String args[])


{Persona eugenio = new Persona("Eugenio","Polito",31,12, 1976) ;eugenio.stampaDati();eugenio.mangia();eugenio.conta(5);

}

}

Adessopossiamoavereaccessodirettoagli attributi dellaclassebasedallaclassederivataStudente :

public class Studente extends Persona{

/* Costruttore: inizializza gli attributipublic Studente(String nome,

String cognome,int giorno,int mese,int anno,int anniDiScuola)

{this.nome = nome;this.cognome = cognome;this.dataDiNascita = new Data(giorno,mese,anno);this.anniDiScuola = anniDiScuola;

}

/* Riscrive il metodo omonmio della classe base:Stampa i numeri 1,2,...,n */

public void conta(int n){

System.out.print("Conto: ");for (int i = 1; i <= n; i++)

System.out.print(i+"\t");System.out.println();

}

/* Estende il metodo omonimo della classe base:richiama il metodo della classe base omonimoed in più stampa l’attributo anniDiScuola */

public void stampaDati()


{super.stampaDati();System.out.println("Anni di scuola: "+anniDiScuola);

}

/* stampa il messaggio ... */public void faiFilaInSegreteria(){

System.out.println("...Aspetto il mio turno in segreteria...");}

// attributoprivate int anniDiScuola;

}

Notarecomeadessonel costruttore si possaaccederedirettamenteagli attributidellaclassebase(this.nome, this.cognome, this.dataDiNascita ).Un’altra cosada osservareè che si è resonecessarioinserireun costruttore didefaultnella classebaseperchéil costruttore della classederivatava a cercaresubitoil costruttoredi defaultdellasuperclasseepoi inizializzagli attributi!Vediamounaapplicazionedi esempio:

public class Applicazione{

public static void main(String args[]){

Persona bill = new Persona("Bill","Cancelli",13,13,1984 );bill.stampaDati();bill.conta(5);bill.mangia();Studente tizio = new Studente("Pinco","Pallino",1,1,197 0,15) ;tizio.stampaDati();tizio.conta(5);tizio.mangia();tizio.faiFilaInSegreteria();

}}

Unapossibileesecuzioneè la seguente:Nel main abbiamocreato l’ oggetto bill (istruzionePersona bill = new

Persona("Bill","Cancelli",13,13,1984) ; ), il qualeinvocai metodistam-paDati(); , conta(5); e mangia(); .


Figura18: Esecuzionedel programmaApplicazione.java

Èstatoquindicreatol’ oggettotizio comeistanzadellaclasseStudente . Richia-ma il metodostampaDati : comesi può vederein Figura 18, oltre al nome,cognome e data di nascita vienestampatol’ attributoanniDiScuola (ricor-diamocichetale metodoè statoesteso, proprio per permetteredi stamparetaleattributo).Vienepoi richiamatoil metodoconta(5) : siccometalemetodoè statoriscritto ,stampaavideola sequenzacorrettadei numeri1,2,.. . ,n.L’oggettotizio invocapoi il metodomangia() , cheessendoereditato stampalostessomessaggiocheèstatostampatoprecedentementedallostessometodoinvo-catodabill .Infine tizio invoca il metodoaggiunto nella classeStudente faiFilaInSe-greteria() chestampaunmessaggio.OsserviamocheseavessimoinvocatofaiLaFilaInSegreteria() sull’oggettobill avremmoottenutounmessaggio di errore,perchétalemetodononèdefinitonellaclassePersona .


3.7 Classiastratte

Nella sezione2.6.4 abbiamoparlato del concettodi classeastratta: vediamoadessocomesi realizzain Java.Comesi è detto, un Animale può essereconsideratoun contenitore di oper-azioni (dal momentoche non si sa comedefinire tali operazioni in generale:comemangia() o comunica() un Animale ?) per tutte le classiderivate, comePersona , Cane etc.:cioéla classeAnimale èunaclasseastratta.Supponiamochetale classeabbiaduemetodiastratti mangia() e comunica()edunoconcretodorme() , dalmomentochetutti gli animalidormonoallo stessomodo:

public abstract class Animale{

// metodo astratto per mangiarepublic abstract void mangia();

// metodo astratto per comunicarepublic abstract void comunica();

// metodo concreto per dormirepublic void dorme(){

System.out.println("Dormo...");}

}

Quindi unaclasseastratta è definitatalecon la keyword abstract : questotipodi classepuò conteneresia metodiastratti (definiti ovviamenteabstract ), siametodiconcreti.Ogni classederivatada una classeastrattadeve implementarei metodiastrattidella classebase!PeresempiounaeventualeclasseCane potrebbeaverequestaforma:

public class Cane extends Animale{

// costruttorepublic Cane(String nome){

this.nome = nome;}


// implementa il metodo della classe basepublic void comunica(){

System.out.println("Sono "+nome+" e faccio Bau Bau");}

// implementa il metodo della classe basepublic void mangia(){

System.out.println("Mangio con la bocca e le zampe");}

// attributoprivate String nome;

}

PertantoCane estendela classeAnimale : realizzai metodiastratti mangia() ecomunica ederedita il metododorme() .AnalogamenteunaclassePersona potrebbeesserecosì:

public class Persona extends Animale{

// costruttorepublic Persona(String nome, String cognome){

this.nome = nome;this.cognome = cognome;

}

// implementa il metodo della classe basepublic void comunica(){

System.out.println("...Salve mondo, sono "+nome+" "+cognome);}

// implementa il metodo della classe basepublic void mangia(){

System.out.println("Mangio con forchetta e coltello");}

// estende il metodo della classe base


public void dorme(){

super.dorme();System.out.println("ed in più russo!");

}

// aggiunge il metodo:public void faiGuerra(){

System.out.println("...Sono un animale intelligenteperché faccio le guerre...");

}

private String nome,cognome;}

Questaclasseimplementai metodiastratti della classebase, estendeil metododorme() edaggiungeil metodofaiGuerra() .Definiamoun main nellaclasseApplicazione :

public class Applicazione{


Cane bill = new Cane("bill");bill.comunica();bill.mangia();bill.dorme();System.out.println("\n------------ ----- ----- -");Persona george = new Persona("George","Fluff");george.comunica();george.mangia();george.dorme();george.faiGuerra();

}}


L’esecuzionedelprogrammaè la seguente:

Figura19: Esecuzionedel programmaApplicazione.java

Nel main vienecreatol’ oggettobill cheè unaistanzadellaclasseCane: sudi essoviene invocatoil metodocomunica() chestampal’ attributo nome (ini-zializzatonel costruttore) ed il verso“Bau Bau”. bill invocaquindi il metodomangia() , chestampaunastringache“ci spiega” comeil caneriescaamangiare.Infine vienerichiamatosubill il metododorme() .Allo stessomodovienecreatol’ oggettogeorge cheèun’istanzadi Persona : essoinvocagli stessimetodicheinvocal’ oggetto bill ed in più richiamail metodofaiGuerra() .


3.8 Interfacce

Le interfacce sonoun meccanismoproprio di Java che, comevedremonellasezionesuccessiva, consentonodi avereun supportoparzialema sufficienteperl’ ereditarietàmultipla.Attraversounainterfacciasi definisceuncomportamentocomuneaclassichefradi loro nonsonoin relazione. Comesi èdetto,ancheunaclasseastrattadefinisceun contenitore di metodiper le classi derivate, quindi in questocasosi usalarelazionedi ereditarietà. Quandosi parla invecedi interfacciasi definisconoimetodichele classidovrannoimplementare, pertantoin unainterfaccianon pos-sonoesisteremetodiconcreti!In UML unainterfacciasi disegnacosì:

Figura20: DiagrammaUML per interface

Considerimo,peresempio,i file HTML edi file bytecodedi Java: ovviamenteessinonhannonulla in comune,senonil fattodi supportarele stesseoperazioni,comeapri(...) , chiudi(...) , etc.Vediamoalloracomecostruireunainterfacciacomunedi operazionidausaresudiversi file, per aprirli , determinarneil tipo e chiuderli. Definiamoallora uninterfacciaFileType :

public interface FileType{

// apre il filepublic void open();

// verifica se il tipo di file è OKpublic boolean fileTypeOk();

// chiude il filepublic void close();

}

Si stadicendochel’ interfacciaFileType (definitacon la keyword interface )definiscei tremetodiopen() , fileTypeOk() , close() edogni classechevuoleimplementarequestainterfaccia deve implementare i metodiin essadefiniti .Supponiamoadessodi voler aprire e verificare un file bytecodedi Java (per lastrutturadei bytecodeJavacfr. [1]):


import java.io.*;

public class FileClass implements FileType{

/* Costruttore: inizializza il nome del fileche si vuole leggere */

public FileClass(String nome){

nomeDelFile = nome;}

// apre il file fisico il cui nome è nomeDelFilepublic void open(){

try {fileClass = new DataInputStream(new

FileInputStream(nomeDelFile));} catch (FileNotFoundException fne) {

System.out.println("File "+nomeDelFile+" non trovato.");}

}

/* verifica se il file è un file bytecode di Java:legge i primi 4 byte (cioé 32 bit = int) e controllase tale intero è il numero esadecimale 0xcafebabe,cioé è l’header del file .class */

public boolean fileTypeOk(){

int cafe = 0;try {

cafe = fileClass.readInt();} catch (IOException ioe) {}

if ((cafe ^ 0xCAFEBABE) == 0) return true;else return false;

}

// chiude il file fisicopublic void close(){

try {


fileClass.close();} catch (IOException ioe) {

System.out.println("Non posso chiudere il file");}

}

// file fisicoprivate DataInputStream fileClass;

// nome del fileprivate String nomeDelFile;


if (args.length != 0) {FileClass myFile = new FileClass(args[0]);myFile.open();if (myFile.fileTypeOk())

System.out.println("Il file "+args[0]+" è un bytecode Java");

else System.out.println("Il file "+args[0]+" non è un file .class!");

myFile.close();}elseSystem.out.println("uso: java FileClass \"nome del file\"");

}}

Provare a compilarlo e ad eseguirlo (sintassi: java FileClass “nome” dove“nome” è un nomedi file .class, per esempioprovare con: java FileClassFileClass.class . . . )La classeFileClass implementale operazionidell’interfacciaattraversola key-word implements . Quindi,comesi vededalcodice,la classedeve implementaretutti i metodidell’interfaccia.Il costruttore riceve comeargomentoil nomedel file che usaper inizializzarel’ attributonomeDelFile .Il metodoopen() implementail metodoomonimodell’interfaccia FileType :quindi tentadi aprireil file comestreamdi bytee senon trova il file solleva unaeccezione(peri file e le eccezionicfr. la sezione5).


Il metodofileTypeOk verificaseil file in apertoèunabytecodeJava: sel’ headero intestazionecominciaconil numeroesadecimale0xCAFEBABE(0x significacheciò chesegueè un numeroin base16) allorail file è un bytecodeJava, altrimentinon lo è. Notarecheper il testsi è usatol’operatorefra bit XOR- in Javaˆ, cherestituisce0 sei bit sonouguali,1 altrimenti.close chiudelo stream: senon lo trova (. . .magariè statocancellatoo sposta-to.. . ) sollevaunaeccezione.Il main richiamain ordinei tremetodidi cui sopra.Dal momentocheun bytecodeè un file di byte,si sonousatele classidi accessoai file del package java.io .In 5 verràdiscussocomeaccedereai file.

In UML implements si disegnacosì:

Figura21: DiagrammaUML per implements

DunqueFileClass implemental’ interfacciaFileType .Analogamentesevolessimoverificareunfile HTML, unELF di Linux (file esegu-bile) etc., non dobbiamofar altro chescriveredelle classiche implementanoleoperazionidell’interfacciaFileType .L’utilizzo delle interfacceèconveniente,almenoperduemotivi:

� si separa l’ interfacciadall’implementazione;

� si haunagaranziapernonfareerrori: si modificasolol’ implementazioneenonl’ interfaccia.


3.9 Ereditarietà multipla

In 2.6.5 si è parlato della ereditarietà multipla in teoria: realizziamoadessoqualcheesempiopratico.Comesi è dettoin 2.6.5l’ ereditarietàmultipla hatre forme,di cui soloduesonosupportatein Java.Vediamocomerealizzareil matrimonio fra una classeconcreta ed una astrat-ta: poichéin Javaogni classeha un solopadre, nonè possibileereditare dadueo più classicontemporaneamente;sembrerebbea prima vista cheil matrimonio“non possaesserecelebrato”.In realtàè possibilefarlo, perchéunainterfacciaèunaclasseastrattasenzametodiconcreti, quindipossiamofareunmatrimoniofraunaclasseconcretaedunainterfaccia. L’esempiodellaPila dellasezione2.6.5diventapertanto:

Figura22: DiagrammaUML peril matrimoniofra classeconcretaed interfaccia

La nostraPila dovràavereunastrutturaFIFO (First In FirstOut)anchedettaFCFS(First ComeFirst Served)cioé il primo elementocheentradeve essereilprimo elementoaduscire(pensateadunapila di piatti.. . ); quindi la strutturachedobbiamoimplementareèquesta:

top

pop()

10

20

5

16

4

5

push(20)

Figura23: UnaPila di numeriinteri

L’operazionepush(...) inserisceun elementosullacimadellapila, mentre


pop() preleva l’elementoin cima. L’attributo top punta alla cima della strut-tura.Scriviamoallora l’ interfacciaStack : essadefiniscele operazioni in astratto cheverrannoimplementatedaPila sull’array .

public interface Stack{

// inserisce un oggetto ’element’ nella pilapublic void push(Object element);

// preleva l’oggetto dalla cima della pilapublic Object pop();

// verifica se la pila è pienapublic boolean isFull();

// verifica se la pila è vuotapublic boolean isEmpty();

}

Pila deve implementare Stack ed estendere array : poichéJava fornisceunbuonsupportopergli arrayattraversola classeVector del package java.util ,useremotaleclassecomearray :

import java.util.Vector;

public class Pila extends Vector implements Stack{

// alloca una Pila di numElements elementipublic Pila(int numElements){

super(numElements);maxElements = numElements;top = 0;

}

// inserisce un element nella Pilapublic void push(Object element){

if (!isFull()) {super.addElement(element);


top++;}else System.out.println("Pila Piena!");

}

// preleva l’elemento in cima alla Pilapublic Object pop(){

if (!isEmpty())return super.remove(--top);

else {System.out.println("Pila Vuota!");return null;

}}

// restituisce ’true’ se la Pila è vuota, ’false’ altrimentipublic boolean isFull(){

return (top == maxElements);}

/* riscrive il metodo omonimo della superclasse :restituisce ’true’ se la Pila è vuota, ’false’altrimenti */

public boolean isEmpty(){

return (top == 0);}

// puntatore alla cima della Pilaprivate int top;// contatore del numero degli elementi della Pilaprivate int maxElements;

}

PoichéPila èunVector , supportatutti i metodidi taleclasse, inoltrepoichéim-plemental’ interfacciaStack deveimplementare tutti i metodidi tale interfaccia.Il costruttore richiamail costruttore della classebaseVector , settal’ attributonumElements (cioéil numeromassimodi elementichela pila puòmemorizzare)al valorepassatoglicomeargomentoe inizializzail top a 0 (quindi la pila è vuo-


ta).I metodiisFull() ed isEmpty() restituisconotrue se,rispettivamentela pila èpiena(quindi top è ugualeal massimovaloredi elementichela pila puòsuppor-tare)esela pila èvuota(top èugualea0).Il metodopush(...) inserisceun elementopassatoglicomeargomentoin cimaalla pila: sela pila è pienavienesegnalatoun errore.Notiamochein realtàl’in-serimentoavvienetramitela chiamataal metodoaddElement(...) dellaclassebaseVector chesi preoccupadi inserirel’elementonelvettorefisico.pop è l’ operazionecomplementarea push(...) .Unaapplicazioned’esempiopotrebbeesserela seguente:

public class ProvaPila{


if (args.length != 0){

Pila pila = new Pila((new Integer(args[0])).intValue());// inserisci elem. finché la pila non è pienaint i = 1;while (!pila.isFull())

{pila.push(new Integer(i++));

}// preleva elem. finché la pila non è vuotawhile (!pila.isEmpty())

{System.out.println("elemento prelevato: "

+pila.pop());}

}else

System.out.println("uso: java ProvaPila num_elem");}

}


Unapossibileesecuzioneè la seguente:

Figura24: Esecuzionedi ProvaPila

Osserviamoadessoun fattoimportante:riprendiamol’ iterfacciaStack ; con-sideriamoi duemetodi

� public void push(Object element);

� public Object pop();

Comesi puòvedere,push(...) prendecomeargomentounelementoil cui tipo èObject , mentrela funzionepop() restituisceun Object . Cosavuol dire questo?Semplicementechetali funzionioperanosuoggetti di tipo Object : macomesi èdettonellasottosezione3.6.4,ogni classederivada Object , quindiquestimetodifunzionanosuqualunque tipo!Pertantola nostraPila , che implemental’interfaccia Stack , saràunapila chepotràcontenereelementidi qualsiasi tipo: allora potràcontenerenumeriinteri,numerireali,oggetti Persona , etc.etc.Utilizzandoil tipo cosmicoObject (comeparametro di funzionee/o tipo di ri-torno di un metodo), si puòsimulare il polimorfismo parametrico (cfr. sezione2.7); tuttavia, mentrein C++ (cfr. [2]) è possibileistanziareoggetti dello stessotipo (cioéconun template di C++ si possonoaveresolocollezioniomogenee),in Java è possibilemixare tipi diversi (ogni classeè-un Object ), quindi si pos-sonoottenerecollezioni eterogenee.Vediamocosasignificaquestofattonel nostrocaso:


public class ProvaPila{


if (args.length != 0){

Pila pila = new Pila((new Integer(args[0])).intValue());// inserisci elem. finché la pila non è pienaint i = 1;while (!pila.isFull())

{// inserisce un interopila.push(new Integer(i));// inserisce un realepila.push(new Float(i*Math.PI));// inserisce una stringapila.push(new String("Sono il numero: "+i));i++;

}// preleva elem. finché la pila non è vuotawhile (!pila.isEmpty())

{System.out.println("elemento prelevato: "

+pila.pop());}

}else

System.out.println("uso: java ProvaPila num_elem");}

}

Stavoltanellapila vengonoinseriti rispettivamente:unnumerointero,unnumerorealeedunastringa:abbiamocosìottenutounapila “universale” di oggetti.Occorreosservarecheunaclassepuò implementare più interfacce: ad esempio,sevogliamochela nostraPila salvi il contenutodellapila suun file, possiamoscriverePila così:

public class Pila extends Vector implements Stack, FileStack{

...}


dove Vector e Stack sonole stessevistesopre,mentreFileStack è una inter-faccia chedefiniscei metodiper l’accessoai file fisici. Pertantounaclassepuòestendereunasolaclassebasemapuò implementarepiù interfacce.La secondaformadi ereditarietàmultipla è il duplice sottotipo: cioéunaclasseimplementadueinterfaccefiltrate. SeabbiamounainterfacciaA edunainterfac-cia B, èpossibilefarequesto:

public interface A {...};

public interface B extends A {...};

Una interfacciapuòestendere un’altra interfaccia:di più puòestendere un nu-mero illimitato di interfacce, cioési puòavereunacosadelgenere:

public interface X extends A1, A2,..., An {...}

doveogniAi � i � 1 � 2 �� n, sonointerfacce!UnaclasseconcretaY implementeràX:

public class Y implements X {...}

L’ereditarietà multipla sottoformadi composizionedi oggetti non è supporta-ta (cfr. sezione2.6.5) per questionidi sicurezzadel codice e per non renderecomplessala JVM.

4 LE OPERAZIONISUGLI OGGETTI 67

4 Le operazioni sugli oggetti

4.1 Copia eclonazione

Supponiamodi averela seguenteclasse:

public class A{

// costruttore di default: richiama il costruttore A(int num)public A(){

this(0);}

/* costruttore: setta l’attributo num al valore passato comeargomento */

public A(int num){

this.num = num;}

// assegna un nuovo valore a numpublic void set(int num){

this.num = num;}

// stampa numpublic void print(){

System.out.println(num);}

// attributoprivate int num;


A primo = new A(1453);primo.print();A secondo = new A();


secondo.print();secondo = primo;secondo.set(16);primo.print();secondo.print();

}}

Seeseguiamotaleprogramma,otteniamoil seguenteoutput:

145301616

Esaminiamoil main : vienecreatol’ oggetto primo cheinizializza il membronum a 1453;quandosi richiamail metodoprint() sull’oggettoprimo , si ottienea video1453.Vienepoi creatol’ oggettosecondo chevienecostruitocol costruttore di default(quindi il membro numè0) eedèrichiamatosuquestooggettoprint() chestam-pa0.Si eseguepoi l’assegnamentosecondo = primo .Si richiamapoi il metodoset(...) sull’oggettosecondo , passandocomeargo-mentol’intero 16.Quandosi eseguel’istruzionesecondo.print(); , vienestampatoa videoil nu-mero16.Invocandoprint suprimo , invecedi ottenereil numero1453,otteniamo16.Checosaèsuccesso?Comesi èdettonellasezione3.4,lavariabileoggettoèunriferimento all’oggetto,cioéessaserve peraccedere alle informazionidell’oggettoalla qualesi riferiscee nonpermemorizzarle.Allora conl’assegnamentosecondo = primo; , non si sta facendouna copiadivalori , masi stafacendounacopia di riferimenti : siaprimo chesecondo pun-tano allo stessooggetto. In sostanzasi ècreatounsecondoriferimentoall’oggettoprimo .


Quandogli oggetti primo e secondo sonostaticostruiti,nello heapsi haunasituazionedel genere:

num = 1453

A

Asecondo

num = 0

primo

Figura25: Gli oggetti primo e secondo dopola creazione

edopol’assegnamentosecondo = primo; si ha:

num = 1453

A

Asecondo

num = 0

primo

Figura 26: Gli oggetti primo e secondo dopo l’assegnamentosecondo =primo;

Pertantoogni modificasullo stato(attributi) di un oggettosi ripercuotesullostatodell’altro.Vogliamo evitare questasituazione: cioé vogliamo che il riferimento, dopo lacopia,rimangaintatto.PerfarequestoJavametteadispozioneil metodoclone()nella classeObject : quindi basteràinvocaretale metodoe verrà eseguita unacopia totale dell’oggetto(ricordiamoancorauna volta che ogni oggetto derivada Object implicitamente). È necessarioimplementare l’ interfacciaCloneable(già definita in Java) per indicareche la clonazionedell’oggetto è possibile: ilmetodoclone() di Java è protected, quindi per poterlo invocareè necessarioimplementareCloneable . Inoltre poichéil tipo di ritorno di questometodoèObject , ènecessarioun castnel tipo correntedell’oggetto:


public class A implements Cloneable{

// costruttore di default: richiama il costruttore A(int num)public A(){

this(0);}

/* costruttore: setta l’attributo num al valore passato comeargomento */

public A(int num){

this.num = num;}

/* implementa il metodo dell’interfaccia Cloneable:richiama il metodo clone() di Object */

public Object clone(){

try {return super.clone();

} catch (CloneNotSupportedException e) {return null;

}}

// assegna un nuovo valore a numpublic void set(int num){

this.num = num;}

// stampa numpublic void print(){

System.out.println(num);}

// attributoprivate int num;



A primo = new A(1453);A secondo = new A();secondo = (A)primo.clone();secondo.set(16);primo.print();secondo.print();

}}

Seeseguiamotalecodice,otteniamoil seguenteoutput:

145316

La situazionenelloheapdopola clonazione, cioédopol’istruzione

secondo = (A)primo.clone();

è la seguente:

num = 1453

A

Asecondo

primo

num = 1453

Figura27: Gli oggetti primo e secondo dopola clonazione

I dueoggetti hannoadesso“vite indipendenti”.


Dopol’istruzione:

secondo.set(16);

La situazioneè la seguente:

num = 1453

A

Asecondo

primo

num = 16

Figura28: Gli oggetti primo e secondo dopol’istruzionesecondo.set(16);

Occorrenotarecheseunaclasseaggregaun’altraclasse, ènecessariodefinireil metodoclone() anchenellaclasseaggregata, altrimentiquest’ultimanonver-rebbeclonatasefosseeseguitoun clone() suunoggettodell’altra classe!


4.2 Confronto

Un’altra operazioneimportante,chepuòricorrerespessoin unaapplicazioneve-ra,è il confronto di oggetti dellastessaclasse.Javamettea disposizioneil metodoequals(...) nellaclasseObject checon-frontadueoggetti e restituisce

� true sei dueoggetti sonoidentici (cioésonolo stessoriferimento),

� false altrimenti

Talemetodononèmoltoutile se,peresempio,vogliamoconfrontareduepersone:in questocasoè necessarioconfrontaretutti gli attributi e restituiretrue sesonouguali,false altrimenti.Risultaalloraconvenienteriscri vere talemetodo:


//Costruttore: inizializza gli attributipublic Persona(String nome,String cognome,int anni){


}

/* riscrive il metodo della classe base Object:testa se due persone sono uguali dal punto divista degli attributi */

public boolean equals(Object object){

if (object instanceof Persona)return ((this.nome.equals(((Persona)obj ect). nome) ) &&

(this.cognome.equals(((Persona)objec t).co gnome) ) &&(this.anni == ((Persona)object).anni));

elsereturn false;

}

// attributiprivate String nome,cognome;private int anni;



Persona pippo = new Persona("Pippo","Caio",2);Persona pluto = new Persona("Pippo","Caio",2);

if (pippo.equals(pluto))System.out.println("Sono la stessa persona");

else System.out.println("Sono persone diverse");}

}

Il metodopublic boolean equals(Object object) riscri ve il metodoomon-imo di Object : comesi puònotare,talemetodoinizia conunconfrontoeprecisa-mente:

if (object instanceof Persona)

questocontrollo è molto importante. Infatti, quandonel main viene eseguital’istruzione pippo.equals(pluto) , al metodoequals(...) si sta passandocomeargomentol’ oggetto pluto cheè una istanzadi Persona : possiamoim-maginareunasituazionedelgenere:

Persona

nome = "Pippo"

cognome = "Caio"

anni = 2

pluto

Object

Figura29: Un oggettohasempreun riferimentoimplicito adObject

Poichéogni classederiva da Object , allora ogni oggetto è ancheun riferi-mentoadun Object (a tempodi esecuzionedel programma), quindi pluto è unoggettodi tipo Persona , maanchedi tipo Object !


Se avessimouna classeCane (con un unico attributo nome) ed un oggettobill , istanzadi taleclasse, avremmoallora:

nome = "bill"

Canebill

Object

Figura30: L’oggettobill istanzadi Cane

Riguardiamoadessoil metodoequals(...) e notiamoche accettacomeargomentoun Object : nessunoci vietaalloradi scriverenel main l’istruzione:

pluto.equals(bill);

Ma hasensoconfrontareunoggettodi tipo Persona conunoggettodi tipo Cane?Ovviamenteno!Abbiamoquindi bisognodi controllare a run time il tipo dinamico (cioé il tipodell’oggetto durante l’esecuzionedel programmachepuò essereuna istanzadiunaqualunqueclassedella gerarchia di ereditarietà) dell’oggettopassatocomeargomentoal metodoequals(...) : seil tipo di tale oggetto è Persona , allorapossiamoconfrontaregli attributi dei dueoggetti chesonosicuramenteistanzediPersona , altrimentiil confrontodegli attributi nonhasenso(sonoovviamentedueoggetti di tipo diverso).Questocontrollovienefattoconla keyword instanceof ,la cui sintassiè:

if (nome_dell’_oggetto instanceof Nome_della_Classe) {...}

il risultatosaràtrue seil tipo dinamicodi nome_dell’_oggetto è esattamenteNome_della_Classe , false altrimenti.Nel nostrocaso(sia pippo chepluto sonooggetti Persona ), talecontrollo (if(object instanceof Persona) ) saràtrue , perchéil tipo dinamicodi pluto èPersona .Osserviamoperòcheprima e dopoquestocontrollostiamousandopippo comeistanzadi Object enondi Persona ! Pertantosetentiamodi accedereadunqual-siasiattributodi Persona , otteniamounerrorea tempodi compilazione. Quindiènecessariospecificarecheseil controllodi instanceof andràabuonfinedurantel’esecuzionedelprogramma,il tipo di pluto dovràessereripristinato aPersona :questaoperazioneèdettadowncastingevieneeseguitaconla sintassi:


(Nome_della_classe_derivata)nome_dell ’_ogg etto

Questotipo di conversioneè pericolosa: usarlasolo quandonecessarioe so-prattutto,prima di eseguire il cast verificare il tipo dinamicodell’oggetto coninstanceof . Comevedremo,questaconversionepuòesserespessoevitatasesiricorreal polimorfismo!

4.3 Binding dinamico

Consideriamodueclassi, peresempioBase dacui deriva Derivata :

public class Base{

// richiama stampa()public void f(){

stampa();}

// stampa un messaggiopublic void stampa(){

System.out.println("Sono la classe base");}

}

public class Derivata extends Base{

// riscrive il metodo della classe basepublic void stampa(){

System.out.println("Sono la classe derivata");}

// stampa la stringa "ciao"public void g(){

System.out.println("Ciao dalla classe derivata");}

}

Supponiamoinoltredi avereil seguentemain :


public class Prova{


Base base = new Base();Derivata derivata = new Derivata();base.f();derivata.f();derivata.g();

}}

Seeseguiamoil Prova , otteniamoil seguenteoutput:

Sono la classe baseSono la classe derivataCiao dalla classe derivata

Vengonocreatii dueoggetti base e derivata , istanze,rispettivamente,di Basee Derivata .base invocail metodof() : essorichiamail metodostampa() chestampail mes-saggio:Sono la classe base .derivata richiamail metodof() cheè statoereditatodaBase : a suavolta f()invocail metodostampa() (riscritto nella classederivata). Grazieal meccanis-modelbindingdinamico, la versionedi stampa richiamatasuderivata èproprioquellacheappartienealla classeDerivata . In sostanzail metododaselezionarea run-time dipendedal tipo dinamicodell’oggetto: siccomeil tipo dinamicodiderivata è Derivata , vieneselezionatoil metodostampa() chestampail mes-saggio Sono la classe derivata .L’istruzione derivata.g() stampaa video il messaggioCiao dalla classederivata .Adessomodifichiamoil main nel seguentemodo:

public class Prova{


Base base = new Base();Derivata derivata = new Derivata();

base = derivata;base.f();


derivata.f();}

}

Stavolta vengonocreatii dueoggetti base e derivata , e vieneeseguito l’asseg-namento:

base = derivata;

cioévienecreatoun secondoreferencea derivata :

Derivata

Base

f()

stampa()

g()

stampa()

f()

metodo ereditato

base

derivata

Figura31: base = derivata;

quindinonci meravigliamo seotteniamo,comerisultato,il seguenteoutput:

Sono la classe derivataSono la classe derivata

È del tutto normaleperchéabbiamocreatoun nuovo referencealla classederivata, il cui tipo dinamicoè Derivata checontieneil metodostampa() chestampail messaggioSono la classe derivata .Adessoproviamoadeseguireunanuova istruzionenel main :

base.g();

Seproviamoacompilare,stavoltaotteniamounbelmessaggiodi errore,checi in-formacheg() nonèunmetododi Base ! E anchequestofattoèdel tuttonormale:quandoil compilatoreavvia la compilazione,si rendecontocheil tipo staticodibase è Base , pertantoquandotrova l’istruzionebase.g() , cercail metodog() enonlo trovanellaclasseBase .N.B. Il bindingdinamicoin Javaè offerto per default: selo si vuoledisabilitare,è necessariodichiararei metodifinal . Talekeyword puòessereapplicataanchealle classi: peròciò impediscela derivazione, quindi è beneriflettereprima diusarla!


4.4 Serializzazione

Una operazioneinteressanteed importantechepuò esserefattasu un oggetto èla serializzazione: cioéla possibilitàdi salvarelo stato(cioél’insiemedei valoridegli attributi in un certoistantedi tempo)di un oggettosuun file. Successiva-menteil contenutodell’oggettopuòessereripristinato.Perrealizzarequestomeccanismosuunaclasse, quest’ultimadeve implementarel’ interfaccia Serializable del package java.io : tale interfaccia contieneimetodi

void writeObject(java.io.ObjectOutputStrea m out) throwsIOExceptionvoid readObject(java.io.ObjectInputStrem in) throwsIOException, ClassNotFoundExcpetion

cheservono, rispettivamente,per salvareed aprireun oggetto e devono, ovvia-mente,essereimplementatenellaclassecherealizzala serializzazione.Facciamoun esempio:supponiamodi volerserializzare la classePersona :

import java.io.Serializable;

public class Persona implements Serializable{// Costruttore di defaultpublic Persona(){

this("","",0,0,0);}/* Costruttore: inizializza gli attributi nome, cognome,

anni e data di nascita */public Persona(String nome,


{this.nome = nome;this.cognome = cognome;this.dataDiNascita = new Data(giorno,mese,anno);

}

/* stampa gli attributi e richiama il metodostampaData() sull’oggetto dataDiNascita


per la stampa della data di nascita */public void stampaDati(){


}

// attributiprotected String nome;protected String cognome;protected Data dataDiNascita;

}

Allo stessomodo, la classeData deve essereserializzatae quindi deve imple-mentare l’ interfacciaSerializable :

import java.io.Serializable;

public class Data implements Serializable{

/* Costruttore: inizializza gli attributi giorno,mese, anno con i valori passati comeargomenti */

public Data(int giorno, int mese, int anno){

this.giorno = giorno;this.mese = mese;this.anno = anno;

}

// stampa la Datapublic void stampaData(){

System.out.println(giorno+"/"+mese +"/"+ anno) ;}

// attributiprivate int giorno, mese, anno;

}


A questopuntopossiamodefinirei duemetodicherealizzanoil salvataggioedilripristino degli oggetti:

import java.io.*;

public class Serial {// Scrive l’oggetto sul file "persona.dat"public void writeFile(){

Persona pippo = new Persona("Tizio","Caio",1,1,2003);try{

FileOutputStream file = new FileOutputStream(fileName);ObjectOutputStream obj = new ObjectOutputStream(file);obj.writeObject(pippo);obj.close();

} catch (IOException ioe) {System.out.println(ioe);}}

// legge l’oggetto dal file "persona.dat" e lo stampa a videopublic void readFile(){

Persona pippo = null;try {

FileInputStream file = new FileInputStream(fileName);ObjectInputStream obj = new ObjectInputStream(file);pippo = (Persona)obj.readObject();obj.close();pippo.stampaDati();

} catch (Exception e) {System.out.println(e);}}

// attributo: nome del file in cui memorizzare gli oggettiprivate String fileName = "persona.dat";


Serial mySerialization = new Serial();mySerialization.writeFile();mySerialization.readFile();

}}


Il metodowriteFile() creaunoggettopippo di tipo Persona , eprovaadaprireil file persona.dat : sela classePersona , cosìcomeData , nonavesseroimple-mentatol’ interfacciaSerializable , il bloccotry {...} catch {...} avrebbesollevatounaeccezionea run time.Vienequindiapertounostreamdi output(vederelasezione5)di nomepersona.dat ,sucui vogliamoinviarele informazionidell’oggetto(istruzioneObjectOutputStreamobj = new ObjectOutputStream(file); ). Laserializzazionedell’oggettovieneeseguitaconl’istruzioneobj.writeObject(pippo); il file vienequindi chiuso.Simmetricamente,readFile() apreil file persona.dat comestreamdi inpute legge l’ oggetto: notareil cast forzato in Persona , poichéil tipo restituitodareadObject() è Object . Sull’oggetto appenaletto viene invocato il metodostampaDati(); . Eseguendoil programma,otteniamoil seguenteoutput:

Nome: TizioCognome: CaioNato il: 1/1/2003

Provare a modificareil programma,in modo da creareun array che con-tieneoggetti di tipo Persona e Studente (derivatoda Persona ) ed eseguire laserializzazione.

83

Parte III

APPENDICI

5 Una panoramicasul linguaggio

5.1 Tipi primiti vi

Java forniscei seguentitipi primitivi:

Tipo Valore Lunghezza(byte)

boolean true o false 1byte n � ri interi nell’intervallo [-28 � 28 � 1] 1

short n � ri interi nell’invervallo [-216 � 216 � 1] 2int n � ri interi nell’invervallo [-232 � 232 � 1] 4

long n � ri interi nell’invervallo [-264 � 264 � 1] 8float n � ri reali nell’invervallo [-232 � 232 � 1] 4

double n � ri reali nell’invervallo [-264 � 264 � 1] 8char caratteri 2

Tabella2: Tipi primitivi di Java

La memorizzazionedei tipi è fissa: cioé su ogni tipo di macchinala dimen-sioneèquellariportatasull’ultima colonnadellatabella2.Il tipo boolean assumesolo i valori di verità true e false : nonpossonoessereusatii valori 1 e0, comein C/C++!I tipi numericisonotutti consegno!Il tipo char memorizzai carattericonla codificaUnicodesu2 byte.Javasupportai seguenticaratteri speciali:�b backspace;�t tabulazione;�n newline;�r carriagereturn;�" virgoledoppie;�’ apice;

5 UNA PANORAMICA SUL LINGUAGGIO 84

��backslash.

Gli arraysi dichiaranoconla seguentesintassi:

String vect[] = new String[10];

Si stadichiarandoun arraydi stringhedi 10elementi.Le stringhein Java non sonoun tipo primitivo: esistela classeString prepos-ta alla loro gestione.Quindi le stringhesonooggetti e cometali devono esserecostruiti(cfr. sezione3.4).

5.2 Variabili

Le variabili sonodichiarateelencandoil tipo, il nome ed, eventualmente,unvalore iniziale; le costantihannoil prefissofinal :

char carattere = ’C’;char nuovaLinea = ’\n’;int numero;final float pi = 3.14;boolean vero = true;

Il simbolott= è chiamatooperatore di assegnamento, perchéassegnaun valore(chepuòessereancheun’altravariabile)adunavariabile.

5.3 Operatori

5.3.1 Operatori Aritmetici

Sonosupportateovviamentele 4 operazionifondamentalisuinumeri:+, -, *, /.Il restodi unadivisionesi ottienecon%.Le operazioniquali radicequadrata, elevamentoa potenza, coseno, etc. sonodisponibili,comemetodistatici nelpackage java.lang.Math .Gli operatoridi incrementoeddecrementosono � � e �!� .Esempi:

int a = 1, b = 3;int c = a * b;int c = ++a; /* c vale 2 (++a incrementa prima a di 1

e poi esegue l’assegnamento) */c--; // decrementa c di 1

/* */ servonopercommentisupiù linee, mentre// èusatopercommentisuunasingolalinea.


5.3.2 Operatori relazionali

I valori dellevariabili possonoessereconfrontaticongli operatori:

== uguale;

!= diverso;

< minorestretto;

> maggiorestretto;

<= minoreo uguale;

>= maggioreo uguale.

5.3.3 Operatori booleani

Pertestarepiù valori booleanivengonousatigli operatori:

&& and;

|| or;

! not.

Le condizionipossonoesserecombinateconquestioperatori.

5.3.4 Operatori subit

Tali operatorisono:

& andlogico;

| or logico;"

xor;

# not;

« shift adx.;

» shift asx.


5.4 Blocchi

I blocchi di istruzioni sonodelimitati da { e } . Ogni variabiledichiaratain unbloccodeve essereinizializzata.È possibiledichiararele variabili in ogni puntodel blocco.

5.5 Controllo del flusso

Il controllocondizionaleavvieneconl’istruzione:

if (condizione) {...} else {...};

Seil bloccoè compostodaunasolaistruzionesi possonoometterei delimitatori{ e } .Esempio:

if ((a > 1) && (b == 2)) a--;else

{b++;

}

Controllasea èmaggioredi 1 e b èugualea 2: in casoaffermativo decrementaadi 1, altrimenti incrementab di 1.N.B. Il controllovieneeseguito in corto circuito: sea è minoreo ugualedi 1, ilcontrollosub nonvieneneancheeseguito!I cicli iterativi (loop, di cui nonsi conosceil numerodi voltechedorvrannoessereeseguiti, si possonofarein 2 modi:

while (condizione){...}

oppure

do{...}

while (condizione);

Nel primo modo,si eseguesubito il testsulla condizionee si itera il bloccodiistruzionifinchéla condizione èvalutatatrue .Nel secondomodo,si esegueprima il bloccodi istruzionie poi si fa il testsullacondizione : la differenza,quindi, fra i duemodi è chenella secondaforma ilbloccodi istruzionivieneeseguito almeno1 volta.Perle iterazionifinitesi usail ciclo for :


int somma = 0;for (int i=0; i < 10; i++)

somma += i;

Questobloccoesegue10 volte l’istruzionesomma += i; cheassegnaa sommailsuovecchiovalorepiù i : taleciclo calcolala sommadei numerichevannoda0a 9. Notarecheil ciclo partedai=0 efiniscea i<10. Inoltreè possibiledichiarareedinizializzareunavariabilenel ciclo, comesi puòvedere.Taleciclo puòesseretrasformatoin un while : int somma= 0; int i = 0; while (i <10) somma+= i; i++; Le selezionimultiplepossonoesserefattetramiteswitch(evitandodi averedegli if ... else ... acascata:

switch (condizione){

case ... : ...; break;case ... : ...; break;...// la seguente istruzione è opzionaledefault : ...; break;

}

break; è necessarioper interromperei controlli, quandola condizioneè stataverificata.Esempio:

switch (a){

case 1: b++; break;case 2: b--; break;case 3: b*2; break;case 4: b+=3; break;

}

5.6 Operazioni (Metodi)

Le operazionisi dichiaranonelseguentemodo:

tipo_di_ritorno nome_della_funzione(argomenti){

...}


Il tipo_di_ritorno può essereun tipo primitivo e non (classe)o void : se iltipo_di_ritorno nonè void , nel bloccosi deve usare,comeultima istruzione,return .Gli argomenti possonoesseresia tipi primitivi che classi: nel casosi abbianopiù argomenti,essidevonoessereseparatidaunavirgola. Il nome_della_fun-zione non può essereunakeyword di Java (class, super, this, etc. ), néun numero,nèun segnodi punteggiatura.Esempio:

public int f(int a, int b){

int temp = 0;temp = a + b;temp %= 2;return temp;

}

Perladiscussionesulmodificatoredi accessopublic vederela sezione3.2.Ques-ta funzionericeve in ingressodueinteri a e b, nefa la somma,calcolail modulodella divisioneper 2 di tale sommae restituisceil risultato. N.B. I parametriinJavasonopassatiby value (per valore), ciò significachela funzionechiamantericeveil valoredellevariabili, facendoneunacopiatemporanea,enonla locazionedi memoria(riferimento) in cui tali variabili si trovano;questovuol dire cheunafunzionenon può modificare il contenutodei suoiparametri :

copia di b

copia di a

b

temp = 0

f(...)

f(...)

temp = (a + b)% 2

a

Figura32: Passaggiodei parametriadunafunzione


5.6.1 Il main

Ogni programmadeve avereun puntodi inizio: in Java un programmainizia efinisce nel main , cioé in una funzioneparticolareche identifica il ciclo di vitadellaapplicazionechescriviamo.Il main di unaapplicazionedeverisiedereall’internodi una solaclasse:

public class Prova{


System.out.println(’’Ciao’’);}

}

La semanticadel main è discussanellasezione3.Questoprogramminostampala stringa“Ciao” avideo.

5.6.2 I package

In Javasi possonometterele classichehannoqualcosain comunenei package:tutte le classidi unaapplicazionepossonoessereraggruppatein una“raccolta”.Tale linguaggiomettea disposizionemolti package: per esempioin java.langsonodefinite le classi come String , System , Integer etc., in java.util sitrovanole classidi utilità comeVector , Date , etc.etc.Perdefinireunpackagesi usalakeyword package (Sunconsigliadi usarei dominiInternetinvertiti, essendounici), p.e:

package com.ciao;

public class A{...}

Si stadefinendoil package com.ciao : è necessariocrearela directorycom checontienela sottodirectoryciao etuttele classidi talepackagedevonoesserepostiin quest’ultimadirectory.Perusareimportareun package in un’altraclassesi usala keyword import :

import com.ciao.A;...


importa,nellaclassecorrente,la classeA del package com.ciao . Sesi voglionoimportaretuttele classidi unpackagesi usala sintassi:

import com.ciao.*;...

5.6.3 Gli stream

Java mettea disposioneben60 classiper gli stream, cioé i flussidi byte, i cuiusi possonoandaredallagestionedei file alla gestionedei bytedi unarete.Ovvi-amentenon si discuterannotutti gli stream: consultarela documentazionedelleAPI del JDK, reperibilein [1] o il reference[4].A titolo di esempiovediamocomeleggereescrivereun file di testo.Per la lettura di un file di testo si usala classeBufferedReader del packagejava.io :

try {BufferedReader file =

new BufferedReader(new FileReader(‘‘pippo.txt’’));} catch (IOException readExcp) {

System.out.println(‘‘File non trovato’’);}

è necessariocautelarele operazionisui file in unbloccotry {}...catch {} !A questopuntoèsufficienteuncicloperscorrerelo streamcolmetodoreadLine() :

String line;while ((line = file.readLine()) != null){

System.out.println(line);}

Perla scrittura di un file di testosi usala classePrintWriter :

try {PrintWriter file2 =

new PrintWriter(new FileWriter(‘‘pluto.txt’’));}catch (IOException writeExcp) {

System.out.println(‘‘Non è stato possibile scrivere il file’’);}

e per scriverlo si usanoi metodiprint(...) o println(...) , a secondasesivogliaandareo menosuunanuova linea:


for (int i=0; i<10; i++)file2.println(i);

Scrivesul file file2 i numeri0,1,.. . ,9.

5.6.4 L’I/O a linea di comando

La scritturadi output è semplice,infatti bastaricorrerealla classeSystem dijava.lang(talepackageè importatoautomaticamentedalcompilatore):

System.out.println(‘‘...’’);

Perleggerele informazionidallaconsoleè necessariousaregli stream(cfr. [1]):nella trattazionesi usaun metodopiù semplice,cioé si leggel’input passatoalprogrammaa linea di comando. Supponendoche il programmaX necessitidiinput datastiera,si usa:

java X ciao,20,b

Si stannopassandoad X i parametriciao, 20, b che verrannoelaboratidalmain .

5.6.5 Le eccezioni

Le eccezionisonoun meccanismoutile per evitare che il programmasi arrestisubitodopol’esecuzionedi unaistruzionenonvalida. Il codicedasalvaguardaredaeventualierrori a run timedeve esserepostoin un bloccotry {...} catch{...} .Eseguendoil seguenteprogramma:

public class Div{

// calcola a/b e stampa il risultatovoid f(int a, int b){

int ris;ris = a/b;System.out.println("Il risultato è: "+ris);

}



Div m = new Div();m.f(2,0);

}}

otteniamoil seguenteoutput:

Exception in thread "main" java.lang.ArithmeticException: / by zeroat Div.f(Div.java:6)at Div.main(Div.java:14)

Cioéla JVM ci informacheèstataeseguitaunadivisioneperzero.Cauteliamoalloral’istruzionedi divisionein unbloccotry {...} catch {...} :

public class Div{

void f(int a, int b){

try {int ris = a / b;System.out.println("Il risultato è: "+ris);

} catch (Exception e) {System.out.println("Divisione per 0.");

}}


Div m = new Div();m.f(2,0);

}}

Stavolta si hacomeoutput:

Divisione per 0.

Occorreosservarechel’esecuzionedi unbloccotry {...} catch {...} èmoltopiù lentodi un if {...} else {...} , quindi è beneusarele eccezioniin situ-azioniin cui nonèpossibileusareun if , comep.e.nellagestionedeifile.


5.6.6 Installazione del JDK

Il JDK, cioél’ambientedi sviluppoperi programmiJavapuòesserescaricatodalsito ufficialedi SunMicrosystem, all’URL:

http://java.sun.com

dallasezioneDownload .La versioneattualedelJDK è la 1.4.0.Unavoltascaricatoedinstallato(èconsigliabileinstallarlosuLinuxnelladirecto-ry /usr/local ), è necessariosettarele variabili di ambientePATH, CLASSPATHeJAVA_HOME. SuLinuxtali variabili vannosettatenelfiledi configurazioneprofilechesi trova nelladirectory/etc ; ovviamenteè necessarioessereutenteroot perpoterscriveretalefile.È sufficienteaggiungerequestelinee:

export CLASSPATH=.:/usr/local/j2sdk1.4.0_0 1export JAVA_HOME=/usr/local/j2sdk1.4.0_01export PATH=$PATH:/usr/local/j2sdk1.4.0_01 /bin

A questopunto per poter compilareun programmaJava è sufficiente scrivereil comandojavac seguito dal nomedel file. Per esempio,se abbiamoil fileCiao.java , pergenerareil bytecodebastascriverea lineadi comando:

javac Ciao.java

otteniamocosìil file Ciao.class ; pereseguirlo si lanciala JVM:

java Ciao

Notarechestavolta il nomedel file Ciao èsenzaestensione.

6 LA LICENZA GNU GPL 94

6 La licenzaGNU GPL

GNU GENERAL PUBLIC LICENSE Version2, June1991Copyright (C) 1989,1991FreeSoftware Foundation, Inc. 59 TemplePlace,

Suite 330,Boston,MA 02111-1307USAEveryoneis permitted to copyand distrib ute verbatim copiesof this license

document,but changingit is not allowed.

Preamble

The licensesfor mostsoftwarearedesignedto take away your freedomto shareandchangeit. By contrast,theGNU GeneralPublicLicenseis intendedto guar-anteeyourfreedomto shareandchangefreesoftware–tomakesurethesoftwareisfreefor all its users.ThisGeneralPublicLicenseappliesto mostof theFreeSoft-wareFoundation’s softwareandto any otherprogramwhoseauthorscommit tousingit. (SomeotherFreeSoftwareFoundationsoftwareis coveredby theGNULibrary GeneralPublicLicenseinstead.)Youcanapplyit to your programs,too.

Whenwe speakof freesoftware,we arereferringto freedom,not price. OurGeneralPublicLicensesaredesignedto make surethatyou have thefreedomtodistributecopiesof freesoftware(andchargefor thisserviceif youwish),thatyoureceivesourcecodeor cangetit if youwantit, thatyoucanchangethesoftwareorusepiecesof it in new freeprograms;andthatyouknow youcando thesethings.

To protectyourrights,weneedto makerestrictionsthatforbid anyoneto denyyou theserightsor to askyou to surrendertherights. Theserestrictionstranslateto certainresponsibilitiesfor you if youdistributecopiesof thesoftware,or if youmodify it.

For example,if you distributecopiesof sucha program,whethergratisor fora fee, you mustgive the recipientsall the rights that you have. You mustmakesurethat they, too, receive or canget thesourcecode.And you mustshow themthesetermssothey know their rights.

We protectyour rights with two steps: (1) copyright the software, and (2)offer you this licensewhich givesyou legal permissionto copy, distributeand/ormodify thesoftware.

Also, for eachauthor’s protectionandours,we want to make certainthatev-eryoneunderstandsthatthereis nowarrantyfor this freesoftware.If thesoftwareis modifiedby someoneelseandpassedon, we want its recipientsto know thatwhatthey have is not theoriginal,sothatany problemsintroducedby otherswillnot reflecton theoriginalauthors’reputations.

Finally, any free programis threatenedconstantlyby softwarepatents. Wewish to avoid the dangerthat redistributorsof a free programwill individuallyobtainpatentlicenses,in effect makingtheprogramproprietary. To preventthis,


we have madeit clearthatany patentmustbelicensedfor everyone’s freeuseornot licensedat all.

The precisetermsandconditionsfor copying, distribution andmodificationfollow.

GNU GENERAL PUBLIC LICENSETERMSAND CONDITIONSFORCOPYING,DISTRIBUTION AND MODIFICATION

0. This Licenseappliesto any programor otherwork which containsa noticeplacedby the copyright holdersayingit may be distributedunderthe termsofthis GeneralPublic License.The"Program",below, refersto any suchprogramor work, anda "work basedon the Program"meanseither the Programor anyderivativework undercopyright law: thatis to say, awork containingtheProgramor a portion of it, either verbatimor with modificationsand/or translatedintoanotherlanguage.(Hereinafter, translationis includedwithout limitation in theterm"modification".)Eachlicenseeis addressedas"you".

Activities other thancopying, distribution andmodificationarenot coveredby this License;they areoutsideits scope. The act of running the Programisnot restricted,and the output from the Programis coveredonly if its contentsconstitutea work basedon the Program(independentof having beenmadebyrunningtheProgram).Whetherthatis truedependsonwhattheProgramdoes.

1. You maycopy anddistributeverbatimcopiesof theProgram’ssourcecodeas you receive it, in any medium,provided that you conspicuouslyandappro-priately publishon eachcopy an appropriatecopyright noticeanddisclaimerofwarranty;keepintactall thenoticesthatreferto thisLicenseandto theabsenceofany warranty;andgiveany otherrecipientsof theProgramacopy of thisLicensealongwith theProgram.

Youmaychargea feefor thephysicalactof transferringacopy, andyou mayat your optionoffer warrantyprotectionin exchangefor a fee.

2. You maymodify your copy or copiesof theProgramor any portionof it,thusforming a work basedon theProgram,andcopy anddistributesuchmodifi-cationsor work underthetermsof Section1 above, providedthatyou alsomeetall of theseconditions:

a) You mustcausethe modifiedfiles to carry prominentnoticesstatingthatyou changedthefilesandthedateof any change.

b) You mustcauseany work thatyou distributeor publish,thatin wholeor inpartcontainsor is derivedfrom theProgramor any partthereof,to belicensedasa wholeat nochargeto all third partiesunderthetermsof this License.

c) If themodifiedprogramnormallyreadscommandsinteractively whenrun,you mustcauseit, whenstartedrunningfor suchinteractiveusein themostordi-naryway, to print or displayanannouncementincludinganappropriatecopyright


noticeanda noticethat thereis no warranty(or else,sayingthat you provide awarranty)andthatusersmayredistributetheprogramundertheseconditions,andtelling the userhow to view a copy of this License. (Exception: if the Programitself is interactivebut doesnot normallyprint suchanannouncement,yourworkbasedon theProgramis not requiredto print anannouncement.)

Theserequirementsapply to the modified work as a whole. If identifiablesectionsof that work arenot derived from the Program,andcanbe reasonablyconsideredindependentandseparateworks in themselves,thenthis License,andits terms,do not apply to thosesectionswhen you distribute them as separateworks. But whenyou distribute thesamesectionsaspartof a wholewhich is awork basedon the Program,the distribution of the whole mustbe on the termsof this License,whosepermissionsfor otherlicenseesextendto theentirewhole,andthusto eachandeverypartregardlessof who wroteit.

Thus,it is not theintentof thissectionto claimrightsor contestyour rightstowork written entirelyby you; rather, the intent is to exercisethe right to controlthedistributionof derivativeor collectiveworksbasedon theProgram.

In addition,mereaggregationof anotherwork not basedon theProgramwiththeProgram(or with a work basedon theProgram)on a volumeof a storageordistributionmediumdoesnotbringtheotherwork underthescopeof thisLicense.

3. You may copy anddistribute the Program(or a work basedon it, underSection2) in objectcodeor executableform underthetermsof Sections1 and2aboveprovidedthatyoualsodooneof thefollowing:

a) Accompany it with the completecorrespondingmachine-readablesourcecode,which mustbedistributedunderthe termsof Sections1 and2 above on amediumcustomarilyusedfor softwareinterchange;or,

b) Accompany it with awrittenoffer, valid for at leastthreeyears,to giveanythird party, for a chargeno morethanyour costof physicallyperformingsourcedistribution,acompletemachine-readablecopy of thecorrespondingsourcecode,to bedistributedunderthetermsof Sections1 and2 aboveon amediumcustom-arily usedfor softwareinterchange;or,

c) Accompany it with theinformationyoureceivedasto theoffer to distributecorrespondingsourcecode. (This alternative is allowedonly for noncommercialdistribution andonly if you received the programin object codeor executableform with suchanoffer, in accordwith Subsectionb above.)

Thesourcecodefor a work meansthepreferredform of thework for makingmodificationsto it. For anexecutablework, completesourcecodemeansall thesourcecodefor all modulesit contains,plus any associatedinterfacedefinitionfiles,plusthescriptsusedto controlcompilationandinstallationof theexecutable.However, as a specialexception, the sourcecodedistributed neednot includeanything that is normally distributed(in either sourceor binary form) with the


majorcomponents(compiler, kernel,andsoon)of theoperatingsystemonwhichtheexecutableruns,unlessthatcomponentitself accompaniestheexecutable.

If distributionof executableor objectcodeis madeby offeringaccessto copyfrom a designatedplace,thenoffering equivalentaccessto copy thesourcecodefrom thesameplacecountsasdistribution of thesourcecode,eventhoughthirdpartiesarenot compelledto copy thesourcealongwith theobjectcode.

4. You may not copy, modify, sublicense,or distribute the ProgramexceptasexpresslyprovidedunderthisLicense.Any attemptotherwiseto copy, modify,sublicenseor distributetheProgramis void,andwill automaticallyterminateyourrights underthis License.However, partieswho have receivedcopies,or rights,from youunderthisLicensewill nothavetheir licensesterminatedsolongassuchpartiesremainin full compliance.

5. You arenot requiredto acceptthis License,sinceyou have not signedit.However, nothingelsegrantsyou permissionto modify or distributetheProgramor its derivative works. Theseactionsareprohibitedby law if you do not acceptthis License.Therefore,by modifying or distributing theProgram(or any workbasedontheProgram),you indicateyouracceptanceof thisLicenseto doso,andall its termsandconditionsfor copying, distributingor modifying theProgramorworksbasedon it.

6. EachtimeyouredistributetheProgram(orany workbasedontheProgram),the recipientautomaticallyreceivesa licensefrom the original licensorto copy,distributeor modify theProgramsubjectto thesetermsandconditions.You maynot imposeany furtherrestrictionsontherecipients’exerciseof therightsgrantedherein. You arenot responsiblefor enforcingcomplianceby third partiesto thisLicense.

7. If, asa consequenceof a court judgmentor allegationof patentinfringe-mentor for any otherreason(not limited to patentissues),conditionsareimposedonyou(whetherby courtorder, agreementor otherwise)thatcontradictthecondi-tionsof this License,they do not excuseyou from theconditionsof this License.If youcannotdistributesoasto satisfysimultaneouslyyourobligationsunderthisLicenseandany otherpertinentobligations,thenasa consequenceyou maynotdistribute the Programat all. For example,if a patentlicensewould not permitroyalty-freeredistributionof theProgramby all thosewhoreceivecopiesdirectlyor indirectly throughyou, then the only way you could satisfyboth it and thisLicensewouldbeto refrainentirelyfrom distributionof theProgram.

If any portionof thissectionis heldinvalid or unenforceableunderany partic-ular circumstance,thebalanceof thesectionis intendedto applyandthesectionasawholeis intendedto applyin othercircumstances.

It is not the purposeof this sectionto induceyou to infringe any patentsorotherpropertyright claimsor to contestvalidity of any suchclaims;this sectionhasthe solepurposeof protectingthe integrity of the free softwaredistribution


system,which is implementedby public licensepractices. Many peoplehavemadegenerouscontributions to the wide rangeof software distributed throughthat systemin relianceon consistentapplicationof that system;it is up to theauthor/donorto decideif he or sheis willing to distributesoftwarethroughanyothersystemanda licenseecannotimposethatchoice.

This sectionis intendedto make thoroughlyclear what is believed to be aconsequenceof therestof this License.

8. If thedistributionand/oruseof theProgramis restrictedin certaincountrieseitherby patentsor by copyrightedinterfaces,theoriginal copyright holderwhoplacestheProgramunderthis Licensemayaddanexplicit geographicaldistribu-tion limitation excludingthosecountries,sothatdistribution is permittedonly inor amongcountriesnot thusexcluded.In suchcase,this Licenseincorporatesthelimitation asif written in thebodyof this License.

9. TheFreeSoftwareFoundationmaypublishrevisedand/ornew versionsoftheGeneralPublicLicensefrom time to time. Suchnew versionswill besimilarin spirit to thepresentversion,but maydiffer in detailto addressnew problemsorconcerns.

Eachversionis givena distinguishingversionnumber. If theProgramspeci-fiesa versionnumberof this Licensewhich appliesto it and"any laterversion",youhavetheoptionof following thetermsandconditionseitherof thatversionorof any later versionpublishedby the FreeSoftwareFoundation.If the Programdoesnot specifya versionnumberof this License,you may chooseany versioneverpublishedby theFreeSoftwareFoundation.

10. If you wish to incorporatepartsof thePrograminto otherfreeprogramswhosedistribution conditionsaredifferent,write to theauthorto askfor permis-sion.For softwarewhichis copyrightedby theFreeSoftwareFoundation,write totheFreeSoftwareFoundation;wesometimesmakeexceptionsfor this. Our deci-sionwill beguidedby thetwo goalsof preservingthefreestatusof all derivativesof our freesoftwareandof promotingthesharingandreuseof softwaregenerally.

NO WARRANTY

11. BECAUSETHE PROGRAM IS LICENSEDFREEOF CHARGE,THEREIS NO WARRANTY FORTHE PROGRAM, TO THE EXTENT PERMITTEDBY APPLICABLE LAW. EXCEPTWHEN OTHERWISE STATED IN WRIT-ING THECOPYRIGHTHOLDERSAND/OROTHERPARTIESPROVIDE THEPROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EX-PRESSEDOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IM-PLIED WARRANTIESOFMERCHANTABILITY AND FITNESSFORA PAR-TICULAR PURPOSE.THE ENTIRERISK AS TO THE QUALITY AND PER-FORMANCEOFTHE PROGRAM IS WITH YOU. SHOULDTHE PROGRAM


PROVE DEFECTIVE,YOU ASSUMETHE COSTOFALL NECESSARY SER-VICING, REPAIR ORCORRECTION.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW ORAGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANYOTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PRO-GRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUEN-TIAL DAMAGESARISING OUT OFTHE USEORINABILITY TO USETHEPROGRAM (INCLUDING BUT NOT LIMITED TO LOSSOFDATA ORDATABEING RENDEREDINACCURATE OR LOSSESSUSTAINED BY YOU ORTHIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITHANY OTHER PROGRAMS),EVEN IF SUCH HOLDER OR OTHER PARTYHAS BEENADVISED OFTHE POSSIBILITY OFSUCHDAMAGES.

END OFTERMSAND CONDITIONSHow to Apply TheseTermsto Your New Programs

If youdevelopanew program,andyouwantit to beof thegreatestpossibleusetothepublic, thebestway to achievethis is to make it freesoftwarewhicheveryonecanredistributeandchangeundertheseterms.

To do so, attachthe following noticesto the program. It is safestto attachthemto the startof eachsourcefile to mosteffectively convey the exclusionofwarranty;andeachfile shouldhave at leastthe "copyright" line anda pointertowherethefull noticeis found.


<oneline to givetheprogram’snameandabrief ideaof whatit does.>Copyright(C) <year><nameof author>Thisprogramis freesoftware;youcanredistributeit and/ormodify it underthetermsof theGNU GeneralPublicLicenseaspublishedby theFreeSoftwareFoundation;eitherversion2 of theLicense,or (at youroption)any laterversion.Thisprogramis distributedin thehopethatit will beuseful,but WITHOUTANY WARRANTY; withouteventheimpliedwarrantyofMERCHANTABILITY or FITNESSFORA PARTICULAR PURPOSE.SeetheGNU GeneralPublicLicensefor moredetails.You shouldhave receivedacopy of theGNU GeneralPublicLicensealongwiththis program;if not,write to theFreeSoftwareFoundation,Inc., 59TemplePlace,Suite330,Boston,MA 02111-1307USA

Also addinformationonhow to contactyou by electronicandpapermail.If the programis interactive, make it outputa shortnotice like this when it

startsin aninteractivemode:Gnomovision version69, Copyright (C) year nameof authorGnomovision

comeswith ABSOLUTELY NO WARRANTY; for detailstype ‘show w’. Thisis freesoftware,andyou arewelcometo redistribute it undercertainconditions;type‘show c’ for details.

The hypotheticalcommands‘show w’ and‘show c’ shouldshow the appro-priate partsof the GeneralPublic License. Of course,the commandsyou usemay be calledsomethingotherthan‘show w’ and‘show c’; they couldevenbemouse-clicksor menuitems–whateversuitsyourprogram.

You shouldalsoget your employer (if you work asa programmer)or yourschool,if any, to signa"copyright disclaimer"for theprogram,if necessary. Hereis asample;alterthenames:

Yoyodyne,Inc.,herebydisclaimsall copyright interestin theprogram‘Gnomo-vision’ (which makespassesatcompilers)writtenby JamesHacker.

<signatureof Ty Coon>,1 April 1989Ty Coon,Presidentof ViceThisGeneralPublicLicensedoesnotpermitincorporatingyourprograminto

proprietaryprograms.If your programis a subroutinelibrary, you mayconsiderit moreusefulto permitlinking proprietaryapplicationswith thelibrary. If this iswhatyouwantto do,usetheGNU Library GeneralPublicLicenseinsteadof thisLicense.

Indice analiticoaccessoprotetto,67ADT, 11aggregazione,16,39

bindingdinamico,26,74blocchidi istruzione,84

classeastratta,20base,16definizione,13derivata,16in Java,27

clonazione,67collezionieterogenee,62composizione,21confronto,71copia,65costruttore,30

dati,11downcasting,73duplicesottotipo,21

eccezioni,89ereditarietà,16,42

peril riusodel codice,17ereditarietàmultipla,21,58

flussocontrollodel,84

GarbageCollector, 9, 30gerarchiadi ereditarietà,19

heap,30

incapsulamento,13in Java,27negli oggetti,14

nellaaggregazione,16nellarelazioned’uso,15nellaspecializzazione,18

interfacce,64interface,64

JDK, 91JVM, 6, 30

licenzaGPL,92line di comando,89

main,30matrimonio,21memoriadinamica,30metodi

astratti,20modificatoredi accesso,28

oggettocostruzionein Java,30definizione,14

operatori,82aritmetici,82booleani,83relazionali,83subit, 83

operazioni,11astratte,20statiche,29

overloading,26overriding,17

package,87passaggioparametri

by value,66polimorfismo

adhoc,26parametrico,26

101

INDICE ANALITICO 102

puro,25polimorfismoparametrico

simulazione,62progettazione,13

relazioni,15aggregazione,16ereditarietà,16ereditarietàmultipla,21relazione“è un” in Java,42relazione“ha un” in Java,39relazione“usa” in Java,35uso,15

riferimento,30

serializzazione,77simulazionedellaereditarietà,22sottoclasse,16sottotipo,16superclasse,16

this,33tipi primitivi, 81tipo, 10,11tipo a run-time,26

UML, 13aggregazione,16ereditarietà,17uso,15

uso,15,35

variabilelocale,37

RIFERIMENTI BIBLIOGRAFICI 103

Riferimenti bibliografici

[1] SunMicrosystem,http://java.sun.com

[2] Ira Pohl,Object-OrientedProgrammingUsingC++ ,TheBenjamin/CummingsPublishingCompany, Inc., 1993

[3] CayHorstmann- GaryCornell,Java2: i fondamenti,McGraw-Hill - SunMicrosystemsInc., 1999

[4] Cay Horstmann,Practical Object OrientedDevelopmentin C++ and Ja-va, Wiley ComputerPublishing,1997

(e-book ita) java introduzione alla programmazione orientata ad oggetti in java

Documents

javaclassi e oggetti

denire una classe

classe studente lavoratore

errori e suggerimenti

copia e clonazione4

diagramma uml

classe delle persone

binding dinamico e polimorsmo