Corso Java

...::: h t t p : / / m a g o n i c o l a . 4 t .
c o m
:::...
MANUALE COMPLETO DI JAVA
Pietro Castellucci
...::: h t t p : / / m a g o n i c o l a . 4 t . c o m
:::...
:::...
Indice generale
LEZIONE 1: Introduzione a Java........................................................................................................ 3 LEZIONE : La programmazione Java............................................................................................... 4 LEZIONE 3: !o"a "ono i #ac$age di Java ......................................................................................... % LEZIONE 4: &crittura di applicazioni 'a con"ole' ...........................................................................1( LEZIONE ): Il no"tro primo programma in Java .............................................................................11 LEZIONE *: +ipi primitivi di Java e valori ..................................................................................... 1 LEZIONE ,: -aria.ili ...................................................................................................................... 14 LEZIONE %: Operatori ..................................................................................................................... ( LEZIONE /: I"truzioni ..................................................................................................................... LEZIONE 1(: Eccezioni e cenni "ui thread ...................................................................................... % LEZIONE 11: Il pac$age 0ava.lang ...................................................................................................31 LEZIONE 1 : Il pac$age 0ava.util .................................................................................................... 3/ LEZIONE 13: Il pac$age 0ava.util .................................................................................................... )4 LEZIONE 14: Il pac$age 0ava.net .................................................................................................... ), LEZIONE 1): conclu"ioni "ui pac$age ............................................................................................ *1 LEZIONE 1*: Inter1acce gra1iche ed eventi ..................................................................................... * LEZIONE 1,: !o"a 2 una applicazione a 3ine"tre ........................................................................... *3 LEZIONE 1%: !o"a 2 un applet ........................................................................................................*% LEZIONE 1/: 4pplicazioni mi"te .................................................................................................... ,4 LEZIONE (: Inter1acce gra1iche: 56I e 47+ ...............................................................................,) LEZIONE 1: Le etichette ed i .ottoni ............................................................................................ ,% LEZIONE : !ontenitori e 5e"tione dei La8out ............................................................................ %, LEZIONE 3: 9enu ......................................................................................................................... /4 LEZIONE 4: Li"te e "celte ..............................................................................................................// LEZIONE ): Il +e"to: gli eventi: ;ialog ...................................................................................... 1() LEZIONE *: La ge"tione degli eventi in Java ............................................................................ 1(/ LEZIONE ,: Introduzione a "<ing ...............................................................................................11* LEZIONE %: 3ondamenti di di"egno con Java .............................................................................1 ( LEZIONE /: 3unzioni paint: repaint: update.. ............................................................................. 1 ( LEZIONE 3(: -i"ualizzazione di immagini .................................................................................. 1 LEZIONE 31: ;i"egno ................................................................................................................... 1 * LEZIONE 3 : 3igure geometriche e te"to ...................................................................................... 1 / LEZIONE 33: 1ile gra1;emo.0ava .................................................................................................. 13( LEZIONE 34: Note per compilare il programma ........................................................................... 134 LEZIONE 3): Il "uono di Java 1.1.= e 1. .= .................................................................................. 13) LEZIONE 3*: &uono: 0ava=."<ing."ampled .................................................................................. 13) LEZIONE 3,: Il pacchetto 0ava=."uond.midi.................................................................................. 13% LEZIONE 3%: &intetizzare "uoni ....................................................................................................13/ LEZIONE 3/: !onclu"ioni e .i.liogra1ia .......................................................................................14,
:::...
:::...
LEZIONE 1: Java appena uscito stato accolto con molto entusiasmo dalla comunit mondiale dei progettisti di software e dei provider di servizi Internet, questo perch Java permetteva agli utenti di Internet di utilizzare applicazioni sicure e indipendenti dalla piattaforma, che si possono trovare in qualsiasi punto della rete. Java quindi nato come linguaggio per la rete, per affiancare l'H per !e"t #ar$up %anguage &H!#%', il quale non un linguaggio di programmazione vero e proprio, e per dargli quella sicurezza che l'H!#% non ha. (a quando nato Java sulla rete si iniziato a poter parlare di numeri di carte di credito e di informazioni sicure, notizia che ha molto affascinato le grosse societ mondiali, le quali hanno trasformato la vecchia Internet, rete ad appannaggio delle sole universit e centri di ricerca, nell'attuale mezzo di comunicazione aperto a tutti. Il linguaggio di programmazione Java stato creato verso la met degli anni novanta, il pi) recente tra i suoi cugini, e per questo ancora in fase evolutiva, tanto che ogni anno circa ne viene rilasciata una nuova relase. (a linguaggio nato solo per la rete divenuto un vero e proprio linguaggio di programmazione, paragona*ile, dal punto di vista delle funzionalit, al pi) *lasonato +,,. Java e la maggior parte degli altri linguaggi possono essere paragonati solo dal punto di vista delle funzionalit, perch sono fondamentalmente molto diversi, infatti Java compila i sorgenti dei suoi programmi in un codice detto - tecode, diverso dal linguaggio della macchina su cui compilato, mentre linguaggi come il +,, compilano i sorgenti dei programmi in un codice che il codice della macchina & per macchina intendo computer , sistema operativo ' su cui eseguito. .uindi per eseguire un programma Java occorre avere uno strumento che chiamato Java /irtual #achine, la quale interpreta il * tecode generato dal compilatore Java e lo esegue sulla macchina su cui installato. 0razie alla Java /irtual #achine Java indipendente dalla piattaforma, infatti il programma compilato Java legato alla J/# e non al sistema operativo, sar quindi possi*ile eseguire lo stesso programma Java, compilato una sola volta su una qualche macchina con un compilatore Java versione 1, su una piattaforma 2indows e su una piattaforma %inu", per fare questo per3 c' *isogno che sia 2indows che %inu" a**iano installato una Java /irtual #achine che supporti la versione 1 di Java. %e due J/# installate sulle due piattaforme diverse sono lo stesso programma compilato una volta per 2indows ed una volta per %inu", come avveniva con i programmi scritti in linguaggi come il +4+,,. 5na Java Virtual Machine implementata anche nei vari -rowser &+ome 6etscape e 7"plorer' per poter eseguire i programmi Java incontrati nella rete, i cosidetti 8pplet. .uesto per3, unito al fatto che Java ancora si evolve, causa degli ovvi pro*lemi di incompati*ilit9 capita sempre che il pi) moderno -rowser supporti una versione precedente di Java rispetto all'ultima versione rilasciata dalla :un #icros stem, inoltre *isogna tener presente che non tutti gli utenti di Internet navigano usando l'ultima versione di 6etscape o di 7"plorer. .uindi volendo creare un applet ed inserirlo in un nostro documento H!#%, do**iamo tenere presente questi pro*lemi, e cercare di scrivere un programma che sia compati*ile con la maggior parte delle J/# inplementate nei vari *rowser. 5n altro pro*lema da affrontare quello della scelta del compilatore Java da utilizzare, infatti esistono vari am*ienti integrati per editare, compilare, de*uggare ed eseguire programmi Java, come quelli della -roland, della #icrosoft, della : mantec. !utti questi am*ienti offrono dei tool di sviluppo eccellenti, come editori grafici di finestre, de*ugger molto interessanti, per3 hanno due pro*lemi, il primo che si pagano, anche molto, il secondo sempre lo stesso della compati*ilit, infatti essi spesso si trovano indietro alla relase della sun, ed inoltre aggiungono delle classi che poi le J/# implementate nei *rowser non hanno. Il mio consiglio quallo di usare le J(; & Java Development Kit ' della :un, le quali comprendono sia il compilatore che la Java /irtual #achine per eseguire i programmi da noi compilati, inoltre sono freeware &non costano niente' e sono scarica*ili dalla rete ed i *rowser si adeguano pian piano a questa versione di Java. :e volete scrivere applet per i vecchi *rowser dovete scaricarvi la versione <.< di Java, per3 questa versione niente alla versione attualmente pi) gettonata, ovvero alla <.=.= & +hiamata per qualche motivo a me oscuro Java = , la si pu3 scaricare all'indirizzo http944>ava.sun.com4products4>d$4<.=4inde".html ', alla quale far3 riferimento anche io in questo corso e per la quale 6etscape versione ?.@" ed 7"plorer A hanno implementato la Java /irtual #achine &quasi tutta, io ho avuto qualche pro*lema con le :wing, che sono una li*reria standard di Java ='. :e avete intenzione di scaricarvi Java = vi consiglio di farlo la mattina verso tra le nove e le undici, perch il sito affollato e lento, inoltre il file da scaricare una ventina di mega, se volete potete scaricarvi anche la documentazione la quale molto utile, per3 anch' essa di circa venti mega. Io ho appena scaricato e installato la prossima versione, ovvero la Belase +andidate del Java = :oftware (evelopment ;it versione <.C Belase +andidate <, e vi assicuro che se la <.=.= era eccezionale questa incredi*ile, ho anche appena scoperto che uscita la Belase +andidate = del J(; <.C e che a fine aprile uscir finalmente la relase &Io la
Introduzione a Java
:::...
:::...
aspetto, non ho voglia di passare un'altra nottata in *ianco per scaricarmi una cosa che verr rimpiazzata dalla relase tra meno di un mese'. Der scaricarvi il prodotto dovrete iscrivervi, fatelo, l'iscrizione gratuita. 5n ultimo pro*lema che ha Java la lentezza, infatti, come gi detto, esso interpretato, quindi le istruzioni Java prima di essere eseguite dalla macchina vengono interpretate dalla J/#, ovvero per eseguire ogni istruzione il computer eseguir un numero di istruzioni macchina che pi) del doppio delle istruzioni che eseguire**e se la stessa istruzione fosse stata scritta in +, quindi avrete *isogno di computer veloci per eseguire *ene programmi Java, e di questo vi sarete sicuramente accorti anche navigando sulla rete. 8nche la memoria importante, si compila e si esegue anche con soli C=#* di B8#, ma per fare le cose velocemente ne occorrono almeno E?, pensate che l'ultimo am*iente integrato della -orland, il J*uilder C, ha come requisito minimo di B8# FE #ega* te. Der finire ritorno al Java (evelopment ;it della un Micro!"!tem, con questo possi*ile produrre tutto il software che si vuole senza dover pagare diritti di uso del prodotto come avviene con il -orland J*uilder, il : mantec +afe, e il #icrosoft /isual Java, vi consiglio di leggervi la licenza d'uso che troverete quando andrete a scaricare il J(; prima di cominciare a produrre software. 8 questo punto possiamo cominciare. LEZIONE #: %a principale differenza tra Java e gli altri linguaggi di programmazione ad oggetti che mentre con questi ultimi possi*ile anche porgrammare ad oggetti con Java si deve assolutamente programmare ad oggetti. .uindi punto fondamentale a questo punto spiegare cosa vuol dire programmare ad oggetti. :ostanzialmente la programmazione avviene allo stesso modo dei linguaggi GnormaliG, solo che sia i dati che le funzioni che li manipolano sono racchiusi in delle strutture dette classi. %e classi sono dei prototipi di oggetti, ovvero sono delle strutture astratte & non troppo vedremo ' che possono essere instanziate e quindi creare un oggetto &ma anche pi) di uno'. %a classe definisce tutte le propriet degli oggetti appartenenti a quella classe, detti attri*uti, e le funzioni che verranno usate per agire su di essi, detti metodi. 8d esempio possi*ile definire una classe delle persone, come segue9 Inizio classe persone Attributo annodinascita Metodo calcolaet (annoattuale) Fine classe persone %a classe delle persone cosH definita ha un attri*uto che annodinascita che sar sicuramente un numero intero ed un metodo che in *ase all' anno attuale passatogli calcola l'et della persona. 5sando il formalismo di Java,per definire la classe persone scriveremo9 class persone { public int annodinascita; public int calcolaeta ( int annoattuale ) { return ( annoattuale - annodinascita ); } } +ome si vede a**iamo dichiarato sia il metodo che l'attri*uto come pu*lic, vedremo tra poco cosa significa, vediamo anche che la classe comincia con I e finisce con J, cosH anche i metodi. .uesto ricorda molto il +, e devo dire che la sintassi di Java molto simile, anzi quasi uguale a quella del +, mentre per chi non conosce il +, le parentesi graffe rappresentano il *egin e l'end del pascal. %a classe avr un cosiddetto costruttore &o pi) di uno', che un metodo particolare che di solito viene utilizzato per inizializzare gli attri*uti quando viene instanziata la classe in un oggetto, esso una funzione che non ha nessun tipo di ritorno ed il nome uguale al nome della classe. Ho detto che i costruttori possono essere pi) di uno, che per3 il nome del costruttore deve essere lo stesso di quello della classe, chi a*ituato a programmare con linguaggi non orientati agli oggetti trover tutto questo strano, per3 possi*ile perch Java fa il cosidetto overloading di funzioni, ovvero funzioni con lo stesso nome che hanno parametri diversi &detti in informatica parametri formali' sono diverse, e al momento dell'invocazione viene scelta la funzione in *ase al parametro &detto parametro attuale'. .uesto vale per ogni metodo, non solo per i costruttori. class persone { public int annodinascita; public String Cognome ne! String();
La programmazione Java
:::...
"" Costruttori public persone(int annonascita) { t#is($%on Conosco$); t#is&annodinascita annonascita; } public persone(String Cognome) { t#is('); t#is&Cognome Cognome; } public persone(int annonascita ( String Cognome) { annodinascita annonascita; t#is&Cognome Cognome; } "" Funzione c#e calcola l)et del soggetto; public int calcolaeta ( int annoattuale ) { return ( annoattuale - annodinascita ); } }
:::...
%e linee che cominciano con 44 sono dei commenti, vengono ignorati dal compilatore, vi sono altri due tipi di commenti, quelli racchiusi tra 4K e 4 che permettono di definire commenti su pi) linee e quelli racchiusi tra 4KK e K4, che permettono sempre di definire commenti su pi) linee, sono detti commenti di documentazione, essi si devono trovare su*ito prima la dichiarazione di classi, di mem*ri di classi &attri*uti o metodi' o costruttori, e vengono inclusi nella eventuale documentazione del codice generata automaticamente. 6ell'esempio vediamo che ci sono tre costruttori, diversi per i parametri formali, che hanno lo stesso nome, vediamo inoltre un nuovo attri*uto che +ognome, esso una :tringa, definita come pu*lic :tring +ognomeLnew :tring&'M la parte prima dell'uguale chiara, lo meno quella a destra, quel new :tring&' crea un nuovo oggetto della classe :tring, e ne invoca il costruttore che non ha parametri, questo il modo standard usato da Java per instanziare gli oggetti di una classe. 6on deve sorprendere che il tipo di dato stringa sia una classe, in Java possi*ile usare oggetti che rappresentano tutti i tipi di dato del linguaggio, inseriti per completezza del linguaggio, detti involucri che a volte sono molto utili, per3 possi*ile anche usare i valori. .uindi ad esempio ci troveremo a lavorare sia con interi che con oggetti che rappresentano interi. 5n ultima cosa che salta all'occhio dall'esempio che i costruttori hanno volutamente dei parametri che hanno lo stesso nome degli attri*uti, anche questo possi*ile in Java, il quale sta*ilisce che quando c' un assegnamento alla sinistra dell'uguale ci deve essere l'attri*uto, e alla destra il parametro, comunque se non vogliamo confonderci possiamo usare il riferimento this, scrivendo ad esempio this.annodinascita intendiamo l'attri*uto. !his un riferimento all'oggetto, e nell'esempio lo troviamo anche come invocazione di funzione this&@', in questo caso esso un riferimento ad un costruttore dell'oggetto, in questo caso chiama il costruttore persone &int annodinascita', con il valore @. 7' quindi possi*ile in un costruttore chiamare un costruttore diverso della classe stessa, a patto che l'invocazione sia la prima istruzione del costruttore e che il costruttore sia diverso da quello attuale. 8 questo punto siamo pronti a creare oggetti appartenenti alla classe da noi appena definita, a**iamo tre modi per farlo, perch a**iamo creato tre costruttori, essi sono9 persone *ietro ne! persone(+,-.); oppure persone *ietro ne! persone($Castellucci$); oppure persone *ietro ne! persone(+,-.($Castellucci$); ora vogliamo creare un altro oggetto della classe persone
:::...
persone /ina ne! persone(+,-0); oppure persone /ina ne! persone($Marucci$); oppure persone /ina ne! persone(+,-0($Marucci$);
:::...
a questo punto ho creato due oggetti della classe persone, essi sono in una relazione con la classe detta di instNof, gli oggetti si chiamano uno Dietro e l'altro %ina, possi*ile anche copiare i riferimenti degli oggetti, ad esempio possi*ile scrivere9 persone *ietro1 *ietro; +ostruiti gli oggetti ne poso invocare i metodi, questo si fa indicando Oggetto.#etodo, ad esempio possi*ile invocare i metodi9 *ietro&calcolaeta(1'''); *ietro1&calcolaeta(1'''); /ina&calcolaeta(1'''); Introduciamo adesso degli attri*uti e dei metodi particolari, i cosidetti mem*ri statici. Der come a**iamo definito i mem*ri della classe non ci possi*ile referenziare direttamente dalla classe attri*uti e metodi & persone.annodinascita un errore', questo perch essi lavorano su una istanza della classe, ovvero su un oggetto, per3 a volte pu3 essere utile scrivere metodi e attri*uti che possano essere invocati senza dover istanziare l'oggetto, ma direttamente dalla classe, per fare questo occorre dichiararli static, ad esempio9 class 2itoliAzienda3attelapesca { public static int 2assodiInteresse 4; public String *roprietario ne! String(); public static 5loat InteressiMaturati (int *eriodo) { return((*eriodo 6 2assodiInteresse )"+'') } 2itoliAzienda3attelapesca(String nome) { *roprietario nome; } } .uindi potremo decidere ad esempio di instanziare un oggetto della classe !itoli8zienda/attelapesca solo se ci conviene, ad esempio facendo9 i5 (2itoliAzienda3attelapesca&InteressiMaturati(+1)7+''') CompraAzioni(+''''); (ove +ompra8zioni&int 1' una funzione che instanzia 1 !itoli8zienda/attelapesca. Introduciamo adesso la relazione isNa tra classi, data una classe possi*ile creare una nuova classe da questa facendo come si dice in gergo una specializzazione della prima classe. %a nuova classe creata in relazione isNa con la prima. +reata una classe studente dalla classe &detta superclasse' persone, la nuova classe eredita dalla prima tutti i metodi e gli attri*uti, con la possi*ilit di definirne dei nuovo o di ridefinirne alcuni, in Java l'estensione di una classe si esplicita con la parola chiave e"tends. class studente e8tends persone { int matricola; "" Costruttori public studente(int annonascita) { super(annonascita($%on Conosco$);
:::...
} public studente (String Cognome) { super('(Cognome); } public studente(int annonascita ( String Cognome) { super(annonascita(Cognome); } }
:::...
+ome si vede dall'esempio la classe studente eredita tutti i metodi e gli attru*uti della classe persone, definisce un nuovo attri*uto matricola e nei suoi costruttori chiama i costruttori della classe persone, con super&'. super&' pu3 essere, come this&', una invocazione di un altro costruttore &tra parentesi vanno i parametri eventuali' o un riferimento alla classe &alla superclasse in questo caso', quindi super.annodinascita rappresenta l'attri*uto annodinascita della superclasse persone. %e relazioni isNa e instNof sono le due relazioni pi) importanti dei modelli ad oggetti. 8desso concludo con un esempio ed alcune considerazioni sull'esempio per spiegare il significato del pu*lic che a**iamo introdotto sopra, e del private e protected &attri*uti e metodi possono essere dichiarati come pu*lic, private e protected'. class A { public int a; pri9ate int b; protected int c; "" Suoi medodi( attributi e costruttori } class : e8tends A { public 5loat a; pri9ate 5loat b; protected 5loat c; "" Suoi medodi( attributi e costruttori } class C { "" Suoi medodi( attributi e costruttori } 8**iamo definito tre classi, 8,- e +, - definita da 8 ridefinendone i tre attri*uti, da interi a reali. In 8, nei suoi costruttori e nei suoi metodi ho li*ero accesso ai propri attri*uti di tipo intero, senza limitazioni, ovvero posso scriverli e leggerli a piacimento. In - e + accade lo stesso per i propri attri*uti, ma vediamo cosa succede per quelli delle altre classi. 8d esempio in - &in un suo metodo ' se scrivo espressioni con a,* e c, scriver3 delle espressioni per dei float &in Java importantissimo il tipo delle espressioni', per referenziare invece gli attri*uti omonimi di 8 da cui ereditata, do**iamo scrivere come sappiamo, super.a, super.* e super.c &e sono degli interi'. Il nostro compilatore Java non dar pro*lemi per le prime due ma ci dar errore per la terza, questo perch il c di 8 protected, questo vuol dire che possi*ile leggere e scrivere quell'attri*uto solo all'interno della classe a cui appartiene, ma non possi*ile leggerlo e scriverlo da classi estranee o da sottoclassi. 8 questo punto mettiamoci in un metodo di +, instanziamo qui dentro un oggetto della classe - &lo chiamo *' e scriviamo le espressioni *.a, *.* e *.c , il nostro simpatico compilatore a questo punto ci dar *uona solo la prima, questo perch la terza protected ed quindi visi*ile solo nella classe di appartenenza e la seconda private, questo significa che visi*ile solo alla classe di appartenenza e alle sue sottoclassi, e + non sottoclasse di -. :opra ho un po' *arato, ovvero ho parlato di atri*uti di classi e di oggetti come se fossero la stessa cosa, ma in effetti lo sono, solo con la piccola differenza che se accedo all'attri*uto di una classe & 6O#7+%8::7.6O#78!!BI-5!O 'questo sar sicuramente static, e vi acceder3 solo in lettura, in pratica una costante. .uando instanzier3 la classe in un oggetto &6O#7+%8::7 6O#7O007!!OL new 6O#7+%8::7 &parametri'M ', accedendo allo stesso attri*uto dell'oggetto
:::...
:::...
& 6O#7O07!!O.6O#78!!BI-5!O ' acceder3 allo stesso valore di prima, e non potr3 modificarlo & static'. :e cercher3 invece di accedere ad un attri*uto non dichiarato static di una classe avr3 ovviamente errore, infatti questo attri*uto verr creato al momento della creazione dell'oggetto della classe, ed il pi) delle volte verr inizializzato dal costruttore dell'oggetto. :pero di essere stato a**astanza chiaro nella trattazione dell'argomento, per3 devo dirvi che i modelli ad oggetti sono piuttosto complicati, ed impossi*ile spiegarli in dettaglio in un solo paragrafo, occorrere**e un corso dedicato interamente a loro. Ovviamente quello che vi ho detto non tutto sui modelli ad oggetti, ho solo introdotto alcuni concetti che ci *asteranno per fare i nostri programmi in Java, se dovessi accorgermi durante il corso di avere tralasciato qualche punto importante per i nostri scopi aprir3 volentieri una piccola parentesi. Der il lettore che volesse approfondire l'argomento non mi sento di consigliare un testo, perch ve ne sono vari sull'argomento e tutti egregi, se invece vi accontentate di una introduzione all'argomento potreste vedere i capitoli iniziali di ogni *uon manuale di programmazione per principianti di %inguaggi ad oggetti &+,, o Java', come ad esempio Java9 (idattica e Drogrammazione di ;.8rnold e J.0osling &7d. 8ddisonP2esle ' +apitoli =,C e ?. #i raccomando per3 che sia per principianti, perch sui testi di programmazione avanzata l'argomento dato per scontato.
LEZIONE 3:
I pac$age sono delle collezioni di classi, racchiuse in una collezione che le accomuna. :ono in pratica delle li*rerie a cui l'utente pu3 accedere e che offrono varie funzionalit. I pac$age possono anche essere creati dall'utente, ad esempio racchiudendovi tutte le classi che ha definito per svolgere alcune funzioni che poi user in vari programmi, ma questo a noi non interessa, perch ci interesser vedere i pac$age sicuramente pi) interessanti definiti in Java. 7' questa la vera potenza odierna di Java, il numero di classi gi definite che svolgono i pi) svariati compiti, ed anche la parte che continua sempre di pi) a crescere e ad aggiornarsi con le nuove versioni di Java &J(; <.C ne ha *en <Q#*'. I pac$age di Java sono cosH tanti che ne descriver3 per sommi capi alcuni in un intero capitolo &il capitolo C' del corso, e ne vedremo pi) o meno in dettaglio un paio, ovvero quelli che ci serviranno per definire interfacce grafiche e applets. Ovviamente tutti i pac$age del linguaggio sono descritti nella mastodontica guida in linea del J(; scarica*ile insieme al pacchetto del compilatore &%a J(; (ocumentation <.C *eta di <@A #ega* te zippata di una trentina di #ega', la quale anch'essa gratuita, e che se avete voglia di passare un paio d'ore a scaricarla vi consiglio di prenderla insieme al compilatore,comunque a vostra disposizione anche in linea &c' il lin$ nella pagina www.>avasoft.com o www.>ava.sun.com , lo stesso, sono parenti stretti'. Il nucleo del linguaggio Java contiene solo le parole chiave per la costruzione delle classi, i commenti, i normali costrutti if, switch, while, doPwhile, for, etichette, *rea$, continue e return &manca il goto',che vedremo in dettaglio nel prossimo capitolo, tutto il resto implementato nei pac$age del linguaggio, comprese le normali primitive di Input e di Output. In questo paragrafo vedremo la lista dei pac$ages di Java e ne vedremo uno in particolare, quello che ci interessa vedere per scrivere la nostra prima applicazione Java ancor prima di avere visto i costrutti, ovvero quello in cui possiamo trovare le istruzioni di input e output. %a lista completa dei pac$ages di Java <.=.< in ordine alfa*etico la seguente 9 com&sun&image&codec&;peg( com&sun&;a9a&s!ing&pla5&!indo!s(com&sun&;a9a&s!ing&pla5&moti5( ;a9a&applet( ;a9a&a!t( ;a9a&a!t&color( ;a9a&a!t&datatrans5er( ;a9a&a!t&dnd( ;a9a&a!t&e9ent( ;a9a&a!t&5ont( ;a9a&a!t&geom( ;a9a&a!t&im( ;a9a&a!t&image( ;a9a&a!t&image&renderable( ;a9a&a!t&print( ;a9a&beans( ;a9a&beans&beanconte8t( ;a9a&io( ;a9a&lang( ;a9a&lang&re5( ;a9a&lang&re5lect( ;a9a&mat#( ;a9a&net( ;a9a&rmi( ;a9a&rmi&acti9ation( ;a9a&rmi&dgc( ;a9a&rmi&registr<( ;a9a&rmi&ser9er( ;a9a&securit<( ;a9a&securit<&acl( ;a9a&securit<&cert( ;a9a&securit<&inter5aces( ;a9a&securit<&spec( ;a9a&s=l( ;a9a&te8t( ;a9a&util( ;a9a&util&;ar( ;a9a&util&zip( ;a9a8&accessibilit<( ;a9a8&s!ing( ;a9a8&s!ing&border( ;a9a8&s!ing&colorc#ooser( ;a9a8&s!ing&e9ent( ;a9a8&s!ing&5ilec#ooser( ;a9a8&s!ing&pla5( ;a9a8&s!ing&pla5&basic( ;a9a8&s!ing&pla5&metal( ;a9a8&s!ing&pla5&multi( ;a9a8&s!ing&table( ;a9a8&s!ing&te8t( ;a9a8&s!ing&te8t&#tml( ;a9a8&s!ing&te8t&#tml&parser( ;a9a8&s!ing&te8t&rt5( ;a9a8&s!ing&tree( ;a9a8&s!ing&undo( org&omg&C>?:A( org&omg&C>?:A&@<nAn<*acAage( org&omg&C>?:A&>?:*acAage( org&omg&C>?:A&portable( org&omg&C>?:A&2<peCode*acAage( org&omg&Cos%aming( org&omg&Cos%aming&%amingConte8t*acAage( sun&tools&tt<debug( sun!&io( sun!&util& :em*rano pochini in effetti, sem*ra quasi che io a**ia detto un stupidaggine in riferimento alla potenza di Java, ma se pensate che solo il pac$age >ava.io comprende A@ classi e <@ interfacce capite *ene che quelli di sopra sono una collezione di classi corposa. 8 questo punto vorremmo fare l'input e output da consolle, per fare questo do**iamo usare il pac$age >ava.lang . Der usare un pac$age in una nostra classe, prima della definizione della classe do**iamo inserire l'istruzione import, ad esempio volendo usare il pac$age >ava.awt do**iamo inserire all'inizio del nostro file9 import ;a9a&a!t&6;
Cosa sono i Package di Java
:::...
:::...
%a K sta ad indicare che vogliamo usarne tutte le classi, se invece vogliamo usarne solo una classe possiamo specificarlo, ad esempio, import >ava.awt.RrameM potremo usare solo la classe Rrame dell'awt. 6el caso nostro, in cui vogliamo fare una operazione di output, dovremmo dichiarare all'inizio import >ava.lang.KM oppure, sapendo che la classe del pac$age >ava.lang che contiene i metodi per fare questo : stem potremmo scrivere import ;a9a&lang&S<stem; %a classe : stem a sua volta avr al suo interno una import >ava.io &che il pac$age per l'input e l'output' per accedere alle classi dell'input e dell'output, e le user per mandare quello che vogliamo su schermo. 8**iamo visto un esempio di pac$age che al suo interno invoca un altro pac$age per fargli svolgere dei compiti, in queste li*rerie Java accade spesso questo, ed proprio questo fenomeno che a molti fa apparire Java un linguaggio ostico, per3 superato questo *locco psicologico di fronte a quest'aspetto del linguaggio, la programmazione diviene semplice ed immediata. Ho introdotto il pac$age >ava.lang, vi dico anche che questo il pi) importante di Java, in questo sono racchiuse le classi fondamentali del linguaggio, tanto che non serve dichiarare l'import, perch >ava lo importa automaticamente. Inoltre vorrei soffermarmi su un aspetto fondamentale dell'importare i pac$age, se io importo nel mio file il pac$age >ava.lang, anche se esso importer il pac$age >ava.io, io dal mio file non potr3 usare le classi di >ava.io, per farlo devo importarlo esplicitamente. .uesto succede anche se programmo una applicazione in pi) file &con pi) classi', in ogni file devo importare i pac$age che mi occorrono per la classe che sto definendo, non *asta importarli in una sola. /ediamo le classi che contiene quindi questo pac$age >ava.lang tanto importante per il linguaggio9 $oolean a**iamo detto che i tipi di dato possono essere anche rappresentati da oggetti dettiM contenitori questa la classe che genera i contenitori per i tipi di dato *ooleani &vero, falso'. $"te questa la classe che genera i contenitori per i tipi di dato interi corti &di un * te'. %haracter questa la classe che genera i contenitori per i tipi di dato caratteri. %haracter& u'!et questa la classe che genera i contenitori per i tipi di dato caratteri con codifica unicode. %haracter&(nicode$loc) questa la classe che genera i contenitori per i tipi di dato caratteri con codifica unicode =.@. %la!! rappresenta classi e interfacce a runtime &in esecuzione', in Java possi*ile a tempo di esecuzione creare, mandare in esecuzione e compilare classi, il compilatore e l'esecutore sono mischiati in modo strano, ma a noi non serviranno queste classi GparticolariG, perch scriveremo delle applicazioni tranquille. %la!!Loader caricatore di classi a tempo di esecuzione. %ompiler compilatore di classi a tempo di esecuzione. Dou'le questa la classe che genera i contenitori per i tipi di dato reali in virgola mo*ile di E? *it. *loat questa la classe che genera i contenitori per i tipi di dato reali di C= *it in virgola mo*ile. Integer questa la classe che genera i contenitori per i tipi di dato interi. Long questa la classe che genera i contenitori per i tipi di dato interi doppi.
:::...
Math contiene metodi che emulano funzioni matematiche. Num'er classe di oggetti contenitori numeri generici.
:::...
O'+ect questa la classe da cui derivano tutte le classi del linguaggio Java, ovvero ogni classe sottoclasse &non per forza diretta' di questa. ,ac)age contiene metodi per estrapolare informazioni sui pac$age di Java. ,roce!! Java un linguaggio che permette di gestire !hread, ovvero programmini che girano in Darallelo, questa classe si occupa di loro, come le altre classi di >ava.lang9 Buntime, BuntimeDermission, !hread, !hread0roup, !hread%ocal, !hrowa*le ecurit"Manager per la sicurezza hort questa la classe che genera i contenitori per i tipi di dato interi corti. tring questa la classe che genera i contenitori per i tipi di dato stringhe di caratteri. tring$u--er questa la classe che genera i contenitori per i tipi di dato stringhe di caratteri modifica*ili. "!tem la classe che interagisce con il sistema, essa contiene molti metodi utili, e dei riferimenti ad altre classi &detti class field', quella che useremo ad esempio noi per creare un output su schermo a caratteri. Void questa la classe che genera i contenitori per i tipi di dato void, ovvero senza tipo. .uesto sem*ra un tipo di dato inutile, ma vedremo che non lo affatto, anzi utilissimo, infatti utile quando si vuole definire un metodoPprocedura &un metodo che non ha valore di ritorno', in Java esistono solo funzioni, le quali sono o**ligate a ritornare un valore del tipo che dichiarano. (ichiarando un metodo come void, si emula la procedura, ovvero non vi la necessit del return.
LEZIONE 4:
#i rendo conto che tutta la parte descrittiva fatta fin' ora stata a**astanza noiosa, sono d'accordo con voi, per3 sono sicuro che mi scusiate per esserlo stato, perch i concetti introdotti sono RO6(8#76!8%I per la parte meno noiosa che sta per cominciare, ovvero la programmazione. Drima di cominciare per3 devo dirvi un'ultima cosa, con gli a*ituali linguaggi di programmazione possi*ile fare due tipologie di programmi, escludendo le li*rerie dinamiche &.(%%' o statiche &.%I-' e varie, ovvero le applicazioni a consolle e le applicazioni a finestre, le prime sono quelle pi) semplici da costruire, che non hanno grafica e che hanno interfaccia a caratteri, tipo le vecchie applicazioni (O:, o >avac.e"e stesso & il compilatore Java ', mentre le seconde sono quelle 2indows o 1P2indows, con tutti i *ottoni, menu e via dicendo, pi) complicate da fare, ma estremamente gradevoli da vedere. +on Java possi*ile fare oltre a queste due una terza applicazione, quella che gira su 2e*, ovvero l'applet. Inizialmente Java era nato solo come linguaggio per il 2e*, ma poi si visto che era un linguaggio completo con cui era facile scrivere anche applicazioni a consolle e a finestre. 8nche io sto facendo la mia !esi in Informatica usando Java, e la mia una applicazione a finestre. %e prime applicazioni che vedremo sono chiaramente le pi) semplici, anche se le meno spettacolari, ovvero le applicazioni a consolle. 5n applicazione pu3 essere composta da una o pi) classi, tutte rinchiuse in omonimi files tipicamente, solo per una questione di semplicit di reperimento, anche se possi*ile definirne pi) di una in un file e chiamare i files con nomi diversi dalle classi in essi contenute, ma se si scrive una applicazione a consolle o una a finestre vi una classe speciale che deve essere contenuta in un file che ha il suo stesso nome. .uesta classe che chiamer3 ad esempio ciao conterr un metodo, chiamato main che rappresenta l'entr point del programma, ovvero il punto dal quale comincer l'esecuzione del programma. .uando un programma in Java viene compilato generer uno o pi) files .class, tra cui nel nostro caso ci sar
Scrittura di applicazioni "a console"
:::...
anche ciao.class, per cominciare l'esecuzione del programma dovremo *attere9 ;a9a ciao BI%3I>C
:::...
(a notare che gli esegui*ili Java non sono .717, ma .class, questo perch per essere eseguiti hanno *isogno della citata Java /irtual #achine, che appunto il porgramma >ava.e"e. Raccio un esempio9 class ciao { public static 9oid main(StringBC args) { "" Commento( =uesto programma non 5a niente& } } /ediamo che main dichiarato static void, static perch esso invocato all'inizio dalla J/#, prima che ciao sia instanziato automaticamente in un oggetto, void perch non deve ritornate niente. .uesta classe la scriver3 in un file chiamato ciao.>ava, e la compiler3 scrivendo >avac ciao.>ava 6-9 7' assolutamente o**ligatorio chiamare i file sorgenti di Java con l'estensione .>ava, altrimenti il compilatore non li compila, inoltre se ho creato ciao.>ava (7/O *attere >avac ciao.>ava e non >avac ciao per compilarlo. +ome parametro il metodo main ha una stringa chiamata args, questa rappresenta i parametri con cui viene invocato il programma, ad esempio se scriver3 una volta compilato ciao in ciao.class ;a9a ciao *ietro Castellucci argsB'C sar uguale a *ietro argsB+C sar uguale a Castellucci questo a tempo di esecuzione. 6otate anche che la J/# >ava.e"e esegue ciao.class specificandogli semplicemente >ava ciao, a differenza del compilatore >avac.e"e, anzi se si *atte >ava ciao.class d errore, provate a farlo.
LEZIONE 5:
.uesto che stiamo per fare in effetti non il nostro prima programma in Java, gi qualcuno lo a**iamo fatto sopra, questo il primo programma Java che faccia qualcosa. 5seremo le cose viste nel paragrafo precedente per creare una applicazione a consolle, e quelle del paragrafo prima per scrivere qualcosa sullo schermo. Iniziamo a editare un file che chiameremo +iao#ondo.>ava, mi raccomando alle lettere maiuscole e minuscole, in Java sono importantissime, non solo a livello di programma, ma anche per i files, mi auguro inoltre che a**iate un editore che supporti >ava, perch se editate con l'edit del (O: non sarete molto aiutati nella stesura dei programmi, mentre con l'editore specializzato avrete le indentazioni fatte ad o$, i colori diversi per le parole chiave, per i commenti, eccS Dotete scaricare gratuitamente degli editori appositamente creati o rivisti per Java sulla rete, potete provare al sito http944omega.di.unipi.it della facolt di Informatica di Disa, al settore Besources P ftp, oppure ai vari siti della tucows & www.tucows.com ', dove troverete il *luette &una versione demo', che ha un *ell'editore, solo mi raccomando in questo caso, il *luette un compilatore >ava, ma non so se interamente compati*ile con il Java della :(; che sto esponendo io, quindi fate attenzione. 6el nostro file +iao#ondo.>ava scriveremo9 class CiaoMondo { public static 9oid main(StringBC args) { S<stem&out&print ($Ciao mondo( sono il primo programma in Da9a $); S<stem&out&println ($di $EargsB'CE$ $EargsB+C); } } +ompiliamo il programma scrivendo al solito >ava +iao#ondo.>ava e ora possiamo eseguirlo, scriveremo9 ;a9a CiaoMondo 2F>%>MG 2F>C>%H%>MG
Il nostro primo programma in Java
:::...
e vedremo un output simile a questo9 Ciao mondo( sono il primo programma in Da9a di 2F>%>MG 2F>C>H%>MG
:::...
:e non mettiamo il nome e il cognome il programma generer una eccezione, che una sorta di errore a runtime, dovuta al fatto che nel main si riferiscono argT@U e argT<U che non sono presenti. .ueste eccezioni sono si degli errori a runtime, ma si possono prevedere e gestire, proprio perch Java un linguaggio GsicuroG, e invece di *loccarsi e dare il solito B56!I#7 7BBOB deto dagli altri linguaggi, lancia una eccezione, che se prevista dal programmatore non *locca il programma. /edremo nel prossimo cappitolo come gestire eventuali eccezioni, ed anche come usarle per i nostri scopi, si pensi ad esempio ad un programma che va a leggere da file e che non trova il suddetto file, Java lancer la sua eccezione, noi la raccoglieremo e faremo leggere un altro file. %a versione senza riscio di eccezioni e pi) coreografica la seguente9 class CiaoMondo1 { public static 9oid main(StringBC args) { S<stem&out&println ($6666666666666666666666666666666666666666666666666$); S<stem&out&println ($66 Ciao mondo( sono il primo programma in Da9a 66$); S<stem&out&println ($6666666666666666666666666666666666666666666666666$); S<stem&out&println ($ IIIII$); S<stem&out&println ($'" 8 8 JJ'$); S<stem&out&println ($ I o I$); S<stem&out&println ($ IJJKKK"I$); S<stem&out&println ($ IKKKKKI$); } } 8 questo punto non resta che farvi i miei complimenti, avete scritto il vostro primo programma in Java. :e vi sem*ra pochino, non temete dal prossimo capitolo vedremo i costrutti e allora potremo s*izzarrirci a scrivere tutti i programmi che desideriamo.
LEZIONE 6:
Der tipi primitivi di un linguaggio si intende i tipi di dato gi definiti nel linguaggio e dai quali si pu3 partire con la costruzione di espressioni, o di tipi composti. I tipi sono molto importanti in tutti i linguaggi di programmazione tipati, e sono fondamentali in Java che un cosiddetto linguaggio fortemente tipato. Il concetto di tipo molto naturale, se io vedo un numero, ed esempio <A.?, posso dirne su*ito l'insieme di numeri a cui appartiene, in questo caso ai reali. :e vedo una operazione ? 4 A posso dire9 . di intero intero / di tipo intero e 0 una funzione che prende due interi e mi restituisce un reale, formalmente si scrive cosH9 " L int 8 int 5loat quindi posso dire che tutta l'espressione ?4A di tipo intero. .uesta che a**iamo fatto all'incirca una inferenza di tipi, in informatica una pratica molto attuata, che per essere spiegata tutta, come per i modelli ad oggetti, avre**e *isogno di un corso intero. I pro*lemi non sono con queste espressioni, cosiddette chiuse, che non hanno varia*ili, ma con quelle con le varia*ili, ogni linguaggio usa una sua tecnica, chi non tipa le espressioni, chi sta*ilisce il tipo dal contesto della espressione e ne da un tipo in conseguenza anche alle singole espressioni e chi come Java fa dichiarare i tipi di tutte le varia*ili all'inizio. I tipi primitivi di Java sono gli stessi degli altri linguaggi di programmazione, solo che sono leggermente diversi come valori, essi sono. 'oolean ovvero valori che possono essere true e false
Tipi primitivi di Java e valori
:::...
:::...
char i caratteri, sono di <E *it, e sono codificati 5nicode <.<.A, negli altri linguaggi sono 8:+II, di soli Q *it. '"te interi di Q *it con segno, ovvero numeri compresi tra meno &due alla settima' e due alla ottava. !hort interi di <E *it con segno. int interi di C= *it con segno. long interi di E? *it con segno. -loat reali di C= *it in virgola mo*ile &I777 VA?P<FQA'. dou'le reali di C= *it in virgola mo*ile &I777 VA?P<FQA'. (a questi ovviamente possi*ile definire nuovi tipi di dato che vengono detti tipi composti, ad esempio una stringa un vettore di caratteri, ed un tipo composto. +ome a**iamo visto nella precedente lezione nel pac$age >ava.lang sono contenuti i contenitori per questi tipi di *ase, ovvero se dichiaro int mi riferisco ad un intero, mentre se dichiaro Integer mi riferisco alla classe interi. :e uso le classi, avr3 anche una serie di attri*uti e metodi utili per lavorare su questi, ad esempio in alcuni saranno definite le costanti #I6N/8%57 e #81N/8%57 &#inimo e massimo valore', nelle classi Rloat e (ou*le ci saranno le costanti 6708!I/7NI6RI6I!W e DO:I!I/7NI6RI6I!W, 6a6 per indicare un valore non valido e il metodo is6an&' per controllare se un valore valido, ad esempio si pu3 utilizzare dopo una divisione per controllare che non sia stata fatta una di solito catastrofica divisione per zero. !utto questo negli altri linguaggi di programmazione non c'. /ediamo quali sono i letterali di ogni tipo di Java, ovvero i valori costanti che ogni tipo pu3 assumere. %'unico letterale per i riferimenti agli oggetti null, si pu3 utilizzare ovunque si aspetti un riferimento ad un oggetto, null un oggetto non creato o non valido, esso non di nessun tipo. I letterali *ooleani sono true e false, ad indicare rispettivamente il valore vero e il valore falso. I letterali interi sono stringhe di cifre ottali, decimali o esadecimali. %'inizio della costante serve a dichiarare la *ase del numero, uno zero iniziale indica la *ase otto, @" o @1 indica la *ase <E e niente indica la notazione decimale. 8d esempio il numero <A in *ase dieci pu3 essere rappresentato come9 <A in notazione decimale @<V in notazione ottale @"f oppure @1R in notazione esadecimale. %e costanti intere che terminano con l o % sono considerate long, meglio che terminino con %, perch l si confonde facilmente con l'unit &non dal compilatore, ma da noi che leggiamo i programmi', se non hanno lettera terminale sono considerati degli int. :e un letterale int viene assegnato direttamente ad uno short o ad un * te viene trattato come se fosse tale. I letterali in virgola mo*ile vengono espressi come numeri decimali, con un punto opzionale seguito eventualmente da un esponente che comincia con una e, secondo la usuale notazione mantissaPesponente. Il numero pu3 essere seguito da una f &R' o da un d &(' per indicare che a precisione singola o doppia, per default sono in precisione doppia. CA, CA. , C.Ae<, .CAe= denotano lo stesso numero. %o zero pu3 essere positivo o negativo, confrontandoli si ottiene l'uguaglianza, per3 utile nei calcoli, si pensi a <d4@d e <d4P@d. 6on possi*ile assegnare direttamente una costante dou*le ad una float, anche se entra nel suo range, se si vuole effettuare questa operazione si deve fare un esplicita forzatra detta casting che poi vedremo cos'. I caratteri sono racchiusi tra apici, come ad esempio '=', e i caratteri speciali vengono rappresentati da delle
:::...
sequenze, dette sequenze di escape, esse sono9 1n newline, va accapo 1t ta* 1' *ac$space, cancella a sinistra 1r return, rappresenta il carattere speciale I6/IO 1- form feed 11 il carattere *ac$slash 12 apice 13 doppio apice
:::...
1ddd un char di cui si fornisce il valore ottale &d sono cifre ottali, ad esempio XC=F, devono essere di tre o meno cifre e minori di XCVV', si pu3 dare anche la rappresentazione esadecimale, sempre di quattro cifre, ecco in ordine i caratteri di sopra rappresentati con il loro numero esadecimale9 Xu@@@8, Xu@@@F, Xu@@@Q, Xu@@@(, Xu@@@+, Xu@@A+, Xu@@=V e Xu@@==. %e stringhe vengono scritte tra virgolette, come ad esempio GDietroG, tutte le sequenze di escape valide possono essere inserite in una strunga, creando cose interessanti, ad esempio9 S<stem&out&println($Jt%omeLJt*ietroJnJtCognomeLJtCastellucci$ ); dar come risultato9 %omeL *ietro CognomeL Castellucci
LEZIONE 7:
%e varia*ili sono dei valori modifica*ili, ovvero sono dei nomi che rappresentano un valore di un certo tipo, il valore associato al nome pu3 essere variato. 8d esempio se dico che 1 una varia*ile di tipo intero, e poi dico che 1 ha valore <@, se scrivo l'espressione A , 1, come se avessi scritto l'espressione A , <@. +redo che comunque tutti voi a**iate dimestichezza con le varia*ili, in quanto sono la cosa principale di ogni linguaggio di programmazione, detto ci3 vediamo come Java tratta le varia*ili. Innanzitutto, prima di essere usata, una varia*ile deve essere dichiarata, in Java una dichiarazione di varia*ile composta da tre parti9 modificatori, tipo e identificatori. I modificatori sono opzionali, e sono sostanzialmente quelli che sta*iliscono l'accesso alle varia*ili, ovvero i pu*lic, private e protected visti nel precedente capitolo, detti modificatori di accesso, e poi ci sono static, s nchronized e final. %'ordine con cui vengono messi non importante, anche se *ene usare sempre la stessa convenzione, per la leggi*ilit del codice. 8nche static stato visto, permette di dichiarare degli attri*uti e dei metodi costanti che possono essere invocati anche prima che un oggetto venga instanziato, final invece dichiara che ad un campo il valore pu3 essere assegnato solo una volta, quando viene inizializzato & una costante anch'essa', il modificatore s nchronized per ora non lo vediamo, e forse non lo vedremo proprio, serve per dichiarare che ad un metodo, in caso di multiprogrammazione &con i thread', vi si pu3 accedere in mutua esclusione, ovvero un thread alla volta. 0li identificatori possono essere uno o pi) di uno, separati da virgole, e sono i nomi che avranno le varia*ili. 8d esempio la dichiarazione di 1 dell'esempio precedente sar9 int M; ma posso anche dichiararne pi) di uno, ad esempio valida la seguente dichiarazione9 int M(N(O; double P 4&+1; Ovviamente essendo gli attri*uti delle classi, devono essere dichiarati all'interno di queste, le dichiarazioni fatte all'esterno sono errate.
Variabili
:::...
:::...
+ome si vede dall'esempio possi*ile anche inizializzare una varia*ile al momento della sua creazione, semplicemente aggiungendo dopo il nome l'uguale ed il valore che prende. (opo la dichiarazione della varia*ile, e la sua inizializzazione, ovunque venga scritto l'identificatore della varia*ile si intende il suo valore attuale, tranne che in un caso, nell'assegnamento di un nuovo valore. 8d esempio se io scrivo 1 L <@ intendo per 1 la varia*ile e non il suo valore, e con quell'uguale <@ dico che il nuovo valore che ha la varia*ile <@. :e dopo scrivo9 M ME+; +on la 1 a sinistra dell'uguale intendo dire la varia*ile chiamata 1, mentre con la 1 a destra intendo dire il valore attuale della varia*ile 1, quell'espressione 1,< sar quindi in questo caso +' E + e =uindi ++( o99ero per M M E +; #o detto M ++;
Drovate ad esempio questo programmino che fa due conti9 class p { int M(N(O; double P 4&+1; +0;
public double A static int : +'+;
pri9ate 5inal int C
1; true;
protected static boolean @ public p() { M +' ; N M; O MEN;
S<stem&out&println ($AllJ)inizio #oL M $EME$( N $ENE$( O $EO); M ME+; N O - M; S<stem&out&println ($G55ettuo le operazioniL JnM M E + ;JnN O - M;Jned ottengoL$); S<stem&out&println ($M $EME$( N $ENE$( O $EO); } } class decl { public static 9oid main(StringBC a) { p *ro9a ne! p(); } } come sapete, visto che decl la classe che contiene il main dovete editare il programma in un file chiamato
:::...
:::...
decl.>ava, poi eseguitelo e vedete cosa succede. /i sono anche altri attri*uti per far vedere l'uso dei modificatori. (all'esempio si vede che io ho creato una classe p e ne ho instanziato l'oggetto Drova, invocandone il costruttore. .uesto l'ho dovuto fare perch le varia*ili sono degli attri*uti, e quindi, se non sono static, sono attri*uti di un oggetto, per questo motivo ho dovuto creare un oggetto per potere lavorare con le sue varia*ili. 8*ituatevi a programmare sotto questa ottica, perch i programmi Java sono tutti cosH. :iccome il main del programma (7/7 essere dichiarato static &e deve avere una stringa come perametro' esso viene eseguito in assenza dell'oggetto, e quindi delle varia*ili non statiche. :e avessi voluto creare una sola classe avrei dovuto scrivere qualcosa del tipo9 class decl1 { int M(N(O; "" Main public static 9oid main(String BC a) { decl1 *ro9a ne! decl1(); } "" Costruttore public decl1() { M +' ; N M; O MEN; S<stem&out&println ($AllJ)inizio #oL M $EME$( N $ENE$( O $EO); M ME+; N O - M; S<stem&out&println ($G55ettuo le operazioniL JnM M E + ;JnN O - M;Jned ottengoL$); S<stem&out&println ($M $EME$( N $ENE$( O $EO); } } In questo secondo esempio, editato e compilato in decl=.>ava, non si capisce *ene quando vedo decl= come classe e quando come oggetto, infatti il main nella classe, e nel mai ne viene creato l'oggetto, quindi invocato il costruttore e qui dentro si ragiona in termini di oggetto instanziato. +omunque possi*ile, vedrete che il programma funzionante anche in questo caso, ed un giorno quando avrete pi) familiarit con il linguaggio lo potrete fare anche voi, ma per ora io ve lo sconsiglio vivamente, perch fondamentale a questo punto distinguere *ene classe e oggetto, cosa che con l'esperienza viene pi) facilmente. 0li identificatori Java devono cominciare con una lettera &oppure con N o Y' seguita da una sequenza lunga a piacere di caratteri e cifre, che essendo codificate 5nicode sono molto pi) numerose delle lettere e delle cifre 8:+II usate dagli altri linguaggi. :ono spiacente di non avere una mappa completa dei caratteri unicode da darvi, ma posso dirvi che tra i caratteri sono compresi i caratteri greci, cirillici, ara*ici, eccetera. /ediamo adesso come dichiarare e inizializzare un arra , la dichiarazione avviene mettendo un paio di parentesi quadre dopo il tipo9 int BC 9ettore@iInteri; 0li arra in Java sono quasi degli oggetti, solo che essi non possono essere estesi per aggiungervi nuovi
:::...
:::...
metodi. .uello dichiarato sopra un riferimento ad unn'arra , che per3 il linguaggio non ha allocato, se voglio inizializzare l'arra elemento per elemento, come si fa con gli altri linguaggi, devo dichiararne le dimensioni9 int BC 9ettore@iInteri ne! intB+''C;
(a questo momento in poi posso iniziare a mettere elementi nel vettore nelle posizioni da @ a FF, se vado fuori avr3 una eccezione di out of range. 8l momento della creazione posso anche inizializzare un arra , *asta scrivere9 int BC 9ettore@iInteri { +(1(4(+'(+''(000('( Q&altri 9aloriQ};
Dosso anche creare dei vettori i cui elementi sono dei vettori, e cosH via, questo si fa cosH9 doubleBC BC matriceIdentita@i>rdine4 { '&' ( +&' ( '&' } ( { '&' ( '&' ( +&' } }; { { +&' ( '&' ( '&' } (
Il prossimo programma usa gli arra , lo editeremo in un file chiamato vett.>ava9 class 9ett { static int %>MG '; +;
static int C>H%>MG
static int *A*G?I%> '; static int HAM:A +; static int R+ 1; static int R1 4; static int R4 .; static int CICCI> 0; static int C>MM S; static int 2>*> -; static int *I**> T; static int CA%G ,; static int *A*G?A +'; static int *A*G?>%G ++; static String personaggiBCBC { {$*aolino$($*aperino$}( {$*ietro$($Hambadilegno$}( {$RFI$($%on Speci5icato$}( {$RF>$($%on Speci5icato$}( {$RFA$($%on Speci5icato$}( {$Ciccio$($@i %onna *apera$}( {$%on Speci5icato$($:assettoni$}( {$%on Speci5icato$($2opolino$}( {$*ippo$($%on Speci5icato$}( {$*luto$($%on Speci5icato$}( {$%on Speci5icato$($*aperina$}( {$%on Speci5icato$($*aperone$}( };
:::...
public static 9oid main(String BC a) { int *ersonaggio2mp; int %umero +; S<stem&out&println ($Alcuni *ersonaggi della Palt @isne<$); *ersonaggio2mp *A*G?I%>;
:::...
S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp HAM:A; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp R+; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp R1; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp R4; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp CICCI>; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp C>MM; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp CA%G; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+;
:::...
*ersonaggio2mp *I**>;
:::...
S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp *A*G?>%G; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); %umero %umeroE+; *ersonaggio2mp 2>*>; S<stem&out&println($%umeroL$E%umeroE$Jt%omeL$EpersonaggiB*ersonaggio2mpCB%>MGCE$ CognomeL$EpersonaggiB*ersonaggio2mpCBC>H%>MGC); S<stem&out&println($Uo contato $E%umeroE$ personaggi( ne erano molti di piVW$); "" Ruesto si c#e X da99ero un programma inutileW /)autore& } } 5na piccola nota sul programma, avete visto nel main che vengono dichiarate delle varia*ili & possi*ile farlo', vengono usate normalmente non dichiarandole static, questo perch le varia*ili definite nel main, o in una funzione in generale, non sono degli attri*uti, quindi non sono legati all'oggetto o alla classe, ma solo alla funzione in cui sono definiti. In queste definizioni non si mettono i modificatori, perch essi sono associati alle classi. 8 questo punto non resta che vedere i tipi composti, ma facile per noi identificarli ora con delle classi, ad esempio volendo definire il tipo composto +omplessi definiremo9 class Complessi { pri9ate double *arte?eale; pri9ate double *arteImmaginaria; Complessi (double ?e( double Im) { *arte?eale ?e; *arteImmaginaria Im; } "" a =uesto punto de5iniremo tutti i nostri o99i metodi sul nou9o tipo double dammi*arte?eale() { return *arte?eale; }; double dammi*arteImmaginaria() { return *arteImmaginaria; }; double calcolaModulo() { return (;a9a&lang&Mat#&s=rt((*arteImmaginaria6*arteImmaginaria)E (*arte?eale6*arte?eale))); }; } Der provarla potete scrivere il seguente&prova+omplessi.>ava'9
:::...
class pro9aComplessi { public static 9oid main (StringBC arg) { Complessi % ne! Complessi(4&'(+&+); double ?e %&dammi*arte?eale(); double Im %&dammi*arteImmaginaria(); double mod %&calcolaModulo(); S<stem&out&println($%umero complessoL$E?eE$Ei$EImE$ #a modulo $Emod); } }
:::...
LEZIONE 8:
0li operatori del linguaggio Java sono gli stessi degli altri linguaggi, in pi) ogni nuovo tipo avr i propri metodi che ne implementeranno nuovi operatori, come a**iamo visto nell'esempio della classe +omplessi. 8**iamo gi visto gli operatori di accesso alle classi e agli oggetti, ovvero il semplice punto. /olendo accedere al campo 1 dell'oggetto " scriveremo semplicemente ".1, anche se " ha un metodo W&int valore', noi vi accediamo, o meglio in questo caso lo invochiamo scrivendo ".W&CF'M +i sono i soliti operatori aritmetici9 ,,P,K,4 e Z. (a notare che le operazioni sono anch'esse tipate, ovvero se sommo due interi ho un valore intero, cosH per tutte le operazioni, in modo che data una espressione sempre possi*ile definirne il tipo del risultato. Java fa un forte controllo sui tipi, infatti non possi*ile assegnare un carattere ad un intero, cosa possi*ile nel linguaggio +, ma anche impossi*ile assegnare un dou*le ad un float, senza un esplicito casting. Il casting consiste nel forzare un valore di un tipo ad assumere un tipo diverso. :e scrivo A io intendo un intero, mentre se ne faccio un cast a float intender3 la versione di A reale, per farlo scriver3 &float' A. Racendo cosH posso fare i famosi assegnamenti di interi a reali e di reali dou*le a reali float, si pensi ad esempio a 9 double 9+ +'&'; 5loat 91; int 94 0; e si pensi agli assegnamenti errati seguenti9 91 9+; 9+ 94; :e effettuiamo dei cast, diventano leciti anche per Java9 91 (5loat) 9+; 9+ (double) 94; (a notare che la divisione tra interi, a differenzache in altri linguaggi da un intero, quindi se si vuole il numero reale derivato dalla divisione dei due numeri interi " e , *isogna prima trasformarli in reali9 5loat risultato (5loat ) 8 " (5loat) <; Der le stringhe esiste un operatore di concatenamento9 String a $*ietro $ ; String b a E $Castellu$; String bE $cci$ Il risultato sar Dietro +astellucci. %'operatore il ,. 8**iamo ad un certo punto usato un assegnamento particolare, ovvero ,L, questa una a**reviazione, se devo scrivere aLa,<M posso a**reviare e scrivere a,L<, che lo stesso. /ale lo stesso per ogni operatore *inario. %'operatore , appende ad una stringa anche
Operatori
:::...
:::...
caratteri e numeri, si pensi agli output degli esempi precedenti, dove scrivevamo ad esempio9 S<stem&out&println($%umero complessoL$E?eE$Ei$EImE$ #a modulo $Emod); :em*ra strano questo, anche in considerazione del fatto che a**iamo detto che le espressioni Java sono *en tipate a differenza del +, questo avviene per3 perch il sistema effettua delle conversioni implicite di tipi primitivi e oggetti in stringhe. 8d esempio definendo un qualsiasi oggetto, se ne definisco un metodo to:tring &', il sistema che si trover a lavorare con stringhe e con quest'oggetto ne invocher automaticamente il metodo to:tring&'. Java inoltre offre altri quattro operatori che sono delle a**reviazioni, due di incremento di varia*ili e due di decremento, sia 1 una varia*ile, io posso scrivere9 MEE EEM M---M che stanno rispettivamente ad indicare valuta prima e poi incrementa 1, incrementa prima e poi valuta 1, valuta e decrementa 1 ed infine decrementa e valuta 1, questo vuol dire che l'espressione 1,, un comando di assegnamento, ma anche una espressione che restituisce un risultato, risultato che in questo caso 1 prima di essere incrementata. 8d esempio9 M +'; N MEE; mi dar come risultato 1L<< e WL<@. Drovate ad editare ed eseguire il seguente class incdec { public static 9oid main(String BC a) { int M(N(O(P(3; M +'; S<stem&out&println($M $EM); N MEE; S<stem&out&println($N MEEL #o M $EME$(N $EN); O EEN; S<stem&out&println($O EENL #o O $EOE$(N $EN); P O--; S<stem&out&println($P O--L #o P $EPE$(O $EO); 3 --P; S<stem&out&println($3 --PL #o 3 $E3E$(P $EP); } } 8ltri operatori sono quelli di confronto, ovvero9 4 maggiore di, "[ restituisce true se " maggiore stretto di , false altrimenti 45 maggiore o uguale di, "[L restituisce true se " maggiore o uguale di , false altrimenti
:::...
6 minore di, "\ restituisce true se " minore stretto di , false altrimenti
:::...
65 minore o uguale di, "\L restituisce true se " minore o uguale di , false altrimenti 55 uguale, "LL restituisce true se " uguale a , false altrimenti 75 diverso, "]L restituisce true se " diverso da , false altrimenti /i sono gli operatori logici ^^, __ e ], che rappresentano l'and, l'or e il not9 (ate " e valori *ooleani, " ^^ sar vera se " e sono entram*e vere, sar falsa altrimenti &se tutte e due false o se una vera e l'altra falsa'. " __ sar vera se " oppure o entram*e sono vere &sar falsa solo se sono am*edue false'. ]" sar vera se " falsa, mentre sar falsa se " vera. /i sono gli ovvi operatori *inari orientati ai *it9 Y( A%@ bit a bit I ( >? bit a bit Z( >? GSC/FSI3>( bit a bit e gli s#i5t( 77( [[( 777& .ueste operazioni *inarie sono molto utili nella costruzione di maschere. %' ultimo operatore da vedere l'operatore condizionale, che permette di definire espressioni con due differenti risultati a seconda di un valore *ooleano. :i consideri ad esempio l'espressione seguente9 int 3aloreAssoluto ( a[' \ -a L a );
/alore8ssoluto assumer il valore Pa se a negativo oppure a se positivo o nullo. 8 questo punto siamo in grado di scrivere tutte le espressioni che vogliamo nel linguaggio Java.
LEZIONE 9:
:iamo pronti per vedere i costrutti principali del linguaggio Java. 8**iamo gi visto i commenti, i quali non possono essere annidati, ovvero illecito il seguente commento9 4K .uesto sicuramente un commento 4K 8nche questo lo K4 K4 :i possono per3 mettere commenti di una linea nei commenti di pi) linee, perch sono diversi, lecito ad esempio il seguente9 4K .uesto sicuramente un commento 44 8nche questo lo K4 anche se francamente a**astanza inutile. %e prime istruzioni che vedremo di Java sono le istruzioni di dichiarazione, che sono delle dichiarazioni di varia*ili locali, vengono usate per dichiarare varia*ili e assegnare loro un eventuale valore iniziale. .ueste istruzioni le a**iamo gi viste, e sono simili alla dichiarazione di attri*uti, tranne che per la mancanza di modificatori. %e varia*ili locali prima di essere usate devono essere inizializzate. %e varia*ili locali possono essere dichiarate in un punto qualsiasi di un *locco, e non per forza all'inizio, ed esse esistono solo all'interno del *locco in cui sono dichiarate. 5n *locco come una istruzione, solo che inizia con I e finisce con J, ed all'interno pu3 contenere tante istruzioni, anche eventualmente altri *locchi. { istruzione +; istruzione 1; Q& istruzione ;-+; { sottoistruzione+; sottoistruzione1; Q&& sottoistruzionen; }; "" X l)istruzione ; istruzione ;E+; Q& istruzione n; }"" Ruesto blocco pu] essere il corpo di un metodo oppure un blocco *ensate al medodoL 9oid pippo() { int ; ';
Istruzioni
:::...
{ int A '; AEE; "" istruzione A }; ;EE; "" istruzione : AEE; "" istruzione C }
:::...
%'istruzione 8 non da' pro*lemi, in quanto usa una varia*ile locale inizializzata, dichiarata all'interno del suo stesso *locco. %'istruzione - lo stesso, mentre l'istruzione + errata, in quanto la varia*ile che usa dichiarata in un *locco interno e non visi*ile all'esteno. :e nel *locco interno avessi scritto >,,M non avrei avuto pro*lemi perch la varia*ile > era stata dichiarata in un *locco esterno &(entro si vede quello che c' fuori ma fuori non si vede quello che c' dentro, come accade in tutti i linguaggi di programmazione a *locchi'. 8**iamo visto nell'esempio che anche >,, una istruzione, essa sia una espressione che una istruzione come la sua altra forma e ,,> e la sua speculare di decremento. 8ltre sono le espressioni che si possono considerare delle istruzioni, esse sono le chiamate di metodi che restituiscano o meno un valore, e le istruzioni di creazione di oggetti, quelle con new, ad esempio new O*>ect&'M una istruzione valida. 5n'altra istruzione molto simile ad una espressione l'istruzione di assegnamento, quella del tipo9 %ome3ariabile espressione;
.uindi fino ad ora a**iamo visto le prime sei istruzioni9 (ichiarazione di varia*ile localeM -loccoM Rorme di incremento e decremento di varia*ili, prefisse e postfisseM +reazione di oggettiM Invocazione di metodiM 8ssegnamento a varia*iliM !utte le istruzioni terminano con un M %e altre istruzioni sono dette costrutti, e sono molto simili a quelle degli altri linguaggi di programmazione, le vediamo una ad una. I!truzione condizionale i5 (GM*:>>/) IS2 .uesta istruzione esegue l'istruzione denominata I:!, la quale pu3 essere una qualsiasi istruzione del linguaggio, solo se l'espressione *ooleana 71D-OO% vera, altrimenti viene saltata. 5na variante quella in cui se invece 71D-OO% falsa viene eseguita un'altra istruzione, essa 9 i5 (GM*:>>/) IS2 else IS21 (a notare che I:! e I:!= sono istruzioni generiche, quindi anche *locchi o altre istruzioni condizionali, in questo secondo caso si parla di if annidati. I!truzione !8itch S!itc# (GM*) { case CS2++L Q& Lcase CS2+nL IS2+ case CS21+L Q& L case CS21nL IS21 Q& case CS2m+L Q& L case CS2mnL IS2m de5ault IS2mE+; }; (ove 71D una espressione, +:!i> sono delle costanti dello stesso tipo dell'espressione 71D e I:!i sono delle istruzioni. %'istruzione valuta 71D, e confronta il risultato con le costanti dei case, se ne trova una uguale esegue l'istruzione corrispondente. :e invece non trova nessuna costante uguale esegue l'istruzione dopo il default, la quale opzionale, nel caso in cui assente e nessun case ha la costante uguale al valore di 71D si salta lo switch.
:::...
:i consideri ad esempio il seguente comando9 s!itc# (0E+) { case S L S<stem&out&println ($:ra9o$); de5ault L S<stem&out&println ($Asino( X sei$); };
:::...
I!truzione -or 5or (e8p di inizializzazione; e8b booleana; e8p di incremento) IS2? esegue l'istruzione I:!B un numero di volte pari ai valori contenuti in un intervallo. !ipicamente l'istruzione di inizializzazione inizializza una varia*ile ad un valore, varia*ile che viene incrementata &o decrementata' dalla istruzione di incremento e nell' espresione *ooleana viene controllato che la varia*ile assuma i valori voluti, infatti appena l'espressione *ooleana falsa si esce dal ciclo for. Raccio un esempio, voglio inizializzare i valori di un vettore di <@@ interi tutti a zero, invece di scrivere <@@ assegnamenti far39 int 9 ne! intB+''C; 5or (int i ' ; i[+''; iEE) 9BiC ';
+ome si vede la varia*ile si pu3 anche dichiarare nell'istruzione di inizializzazione, cosH si vedr solo all'interno del for. I!truzione 8hile !#ile (GM*:>>/) IS2 7segue I:! fintanto che 71D-OO% vera, ad esempio l'inizializzazione di prima si pu3 fare con il while cosH9 int 9 ne! intB+''C; int i '; !#ile (i[+'') { 9BiC '; iE +; }; oppure in forma pi) compatta, sfruttando l'incremento in forma compatta9 int 9 ne! intB+''C; int i '; !#ile (i[+'') 9BiEEC '; I!truzione do98hile do IS2 !#ile (GM*:>>/); 7' come il while, solo che prima esegue l'istruzione e poi controlla l'71D-OO%, di nuovo l'inizializzazione precedente diviene9 int 9 ne! intB+''C; int i '; do { 9BiC '; iE +; } !#ile (i[+''); oppure ancora in modo pi) compatto9 int 9 ne! intB+''C; int i '; do 9BiEEC ' !#ile (i[+''); Etichette 7' possi*ile etichettare delle istruzioni, come in codice assem*ler, questo utile in com*inazione con istruzioni di *rea$ e di continue9 etic#ettaL istruzione; I!truzione di 'rea) %'istruzione *rea$ viene utilizzata per uscire da un *locco o da uno switch, quando si incontra un *rea$ si
:::...
:::...
esce dal *locco pi) interno, mentre se si mette una etichetta, si esce fino a dove dichiarata l'etichetta. 7sempio9 { !#ile ( C>%@ ) { !#ile (C>%@1) { i5 (RFA/C>SA) breaA; } } } Si esce in =uesto caso dal !#ile interno( mentreL { pippoL !#ile ( C>%@ ) { !#ile (C>%@1) { i5 (RFA/C>SA) breaA pippo; } } } si esce fuori da tutti e due i while. I!truzione di continue In un ciclo salta tutte le istruzioni che lo seguono e va a valutare direttamente l'espressione *ooleana, ad esempio9 !#ile (Condizione) { istruzioni; i5 (Colpo@iScena) continue; altre istruzioni; }; :i entra nel ciclo , si eseguno istruzioni, se +olpo(i:cena true salta altre istruzioni e riva a valutare +ondizione, se ancora vera continua il ciclo eseguiendo istruzioni , ecc.. I!truzione di return Drovoca la conclusione dell'esecuzione del metodo in cui si trova e il ritorno al chiamante. :e il metodo void *asta scrivere returnM , altrimenti deve contenere una espressione dello stesso tipo del metodo, ad esempio int pippo() { return +'; } con l'istruzione return possi*ile anche *loccare l'esecuzione di un costruttore o di un metodo static. 8**iamo finito la nostra panoramica sulle istruzioni, siamo pronti ora a costruire una qualsiasi applicazione a consolle. Racciamo un paio di esempi, iniziamo a scrivere un programmino che stampi i primi numeri, quelli minori di A@@ della famosa serie di Ri*onacci. Der chi non la conoscesse la serie di Ri*onacci una sequenza infinita di numeri, i cui primi due elementi sono9 <, <, e gli altri elementi vengono calcolati come somma dei precedenti due, ad esempi, l'iPesimo numero di Ri*onacci dato dalla somma dell' iP< esimo numero e dell' iP= esimo, formalmente, vedendo Ri*o come una funzione9 Fibo ( i ) Fibo ( i - + ) E Fibo ( i - 1 );
Il programma da scrivere in Ri*o.>ava il seguente9 class Fibo
:::...
{ public static 9oid main (StringBC args) { int basso +( alto +; "" int alto +; S<stem&out&println (basso); !#ile (alto[0'') { S<stem&out&println(alto); altoE basso; basso }; } } alto - basso;
:::...
Der esercizio potreste provare a fare un programma che calcola <@ ] , sapendo che <] L < e che dato n intero, n] L n K &&nP<']'. %a soluzione contenuta nel file Ratt.>ava. Ora proviamo a scrivere un nostro crivello di 7ratostene fatto in casa, ovvero un modo per calcolare tutti i numeri primi fino ad un dato numero, sia questo ad esempio <@@M %'algoritmo procede cosH, + X primo& 1 X primo( tolgo i suoi multipli 4 X primo( tolgo i suoi multipli e cosH via fino a trovare il mio massimo. class Gratostene { static int MAM +'''; int BC numeri ne! intBMAMC; ne! booleanBMAMC;
boolean BC primi
public Gratostene() { int i; 5or (i ';i[MAM;iEE) { numeriBiC iE+; primiBiC true; }; } 9oid elMul(int a) {
:::...
5or (int ; 1;;6a[ MAM;;EE) primiB(;6a)-+C 5alse; } int prossimo(int n) { int tmp n; !#ile (WprimiBtmpC) { tmpEE; i5 (tmp7 MAM) breaA; } return tmpE+; } 9oid calcola*rimi() { int num 1; !#ile (num[ MAM) { elMul(num); num prossimo(num); }; } 9oid scri9i*rimi() { S<stem&out&println($I numeri primi 5ino a $EMAME$ sonoL$); 5or (int i '; i [ MAM ; iEE) i5 (primiBiC) S<stem&out&print(numeriBiCE$ $); } public static 9oid main(StringBC args) { Gratostene e ne! Gratostene();
:::...
e&calcola*rimi(); e&scri9i*rimi(); } }
:::...
...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE 10:
:::...
/e eccezioni sono un modo c#iaro per controllare gli errori( senza con5ondere il codice con tante istruzioni di controllo dell)errore& Ruando si 9eri5ica una situazione di errore 9iene lanciata una eccezione( c#e se 9iene in seguito catturata permette di gestire l)errore( altrimenti 9iene eseguita dal supporto a tempo di esecuzione di Da9a una ruotine di de5ault& Gsiste in Da9a una classe G8ception( e le eccezioni sono degli oggetti appartenenti a =uesta classe( =uindi esse possono essere trattate come 9eri e propri componenti del linguaggio& 3ediamo come X possibile creare una eccezione& Si de9e creare una classe c#e estende 2#ro!able( o meglio G8ception ( la =uale X una estensione di 2#ro!able& Supponiamo di 9olere creare una eccezione per dire c#e ri5eriamo una stringa 9uota( scri9eremoL public class GrroreStringa3uota e8tends G8ception { GrroreStringa3uota() { super($Attenzione( stai ri5erendo una stringa non inizializzata$); } } Ruesta classe si de9e tro9are in un 5ile c#iamato come la classe( o99ero GrroreStringa3uota&;a9a @opo a9erla creata 9orremmo un modo per lanciarla( o99ero per mettere in risalto la situazione di errore( c#e a =uesto punto spero sia catturata da =ualcuno& /e eccezioni 9engono lanciate con l)istruzione t#ro!( la =uale de9e essere in un metodo c#e de9e essere dic#iarato con una clausola t#ro!s( ad esempio( nel nostro caso se 9oglio creare un metodo di stampa della stringa c#e controlla anc#e l)errore( scri9er] nella mia classeL public 9oid Stampa (String a) t#ro!s GrroreStringa3uota "6 ^ Ruesto 9uol dire c#e =uesta 5unzione pu] lanciare una eccezione di tipo GrroreStringa3uota6" { i5 (a null) t#ro! ne! GrroreStringa3uota(); else S<stem&out&println(a); } Ruindi a =uesto punto il metodo Stampa mander sullo sc#ermo la stringa passatagli come parametro( e generer una eccezione di tipo GrroreStringa3uota se il puntatore era null& /)eccezione lanciata da noi si dice eccezione controllata( =uesta de9e essere obbligatoriamente gestita( mentre =uelle lanciate da Da9a non per 5orza de9ono essere catturate e gestite& 3ediamo ora come catturare le eccezioni( ad esempio la nostra GccezioneStringa3uota& /e eccezioni 9engono catturate =uando 9engono in9ocati i metodi c#e sono dic#iarati con la clausola t#ro!s( per catturarle bisogna in9ocare il metodo in blocc#i tr<( essi #anno la sintassi seguenteL tr< :/>CC> "" Ruesto X un blocco pericoloso( pu] lanciare eccezioni& catc# (2ipo di Gccezione da catturare) :/>CC> "" Ruesto X un blocco di ripristino& catc# (2ipo di Gccezione da catturare) :/>CC> "" Ruesto X un blocco di ripristino& Q& 5inall< :/>CC> Il corpo di =uesta istruzione 9iene eseguito 5ino alla 5ine oppure 5ino alla 9isione di una eccezione( in caso di eccezione si esaminano le clausole catc# per 9edere se esiste un gestore per =uella eccezione o per una sua superclasse( se nessuna clausola catc# cattura l)eccezione( essa 9iene lanciata nel metodo c#e l)#a pro9ocata (c#e l)#a lanciata)& Se nel tr< X presente una clausola 5inall<( il suo codice 9iene eseguito dopo a9er completato tutte le altre operazioni del tr<( indipendentemente dal 5atto c#e =uesta abbiano lanciato una eccezione o no& Ad esempio il nostro metodo Stampa pu] essere c#iamato cos_L Sia M la stringa da stampareL tr< {Stampa(M);} catc# (GrroreStringa3uota e) {S<stem&out&println ($Spiacente$);} In =uesto caso se M X null 9err lanciata l)eccezione e catturata( =uindi 9err stampata la stringa Spiacente(
Eccezioni e cenni sui thread
:::...
:::...
altrimenti M& Se a9essi scritto Stampa(M) 5uori dalla tr< a9rei a9uto errore( perc#` le eccezioni generate da me( de9ono obbligatoriamente essere catturate( =uesto obbliga il programmatore a scri9ere codice $buono$& /e eccezioni di Da9a possono essere in9ece catturate oppure no& Il seguente esempio riprende il CiaoMondo del primo capitolo( c#e se in9ocato senza parametri da9a una eccezione di Arra<Inde8>ut>5:oundsG8ception( c#e =uesta 9olta 9iene gestita; class CiaoMondo { public static 9oid main(StringBC args) { S<stem&out&print ($Ciao mondo( sono il primo programma in Da9a $); String %ome; String Cognome; tr< {%ome argsB'C;} catc# (Arra<Inde8>ut>5:oundsG8ception e) {%ome $%on #ai inserito il tuo %ome$;} ; tr< {Cognome argsB+C;} catc# (Arra<Inde8>ut>5:oundsG8ception e) {Cognome $%on #ai inserito il tuo Cognome$;} ; S<stem&out&println ($di $E%omeE$ $ECognome); } } *ro9atelo( e pro9ate ad eseguirlo nei seguenti modiL ;a9a CiaoMondo %ome Cognome ;a9a CiaoMondo %ome ;a9a CiaoMondo e 9edete cosa succede( 5ate lo stesso con il CiaoMondo del primo capitolo& /e eccezioni sono un modo c#iaro per controllare gli errori( senza con5ondere il codice con tante istruzioni di controllo dell)errore& Ruando si 9eri5ica una situazione di errore 9iene lanciata una eccezione( c#e se 9iene in seguito catturata permette di gestire l)errore( altrimenti 9iene eseguita dal supporto a tempo di esecuzione di Da9a una ruotine di de5ault& Gsiste in Da9a una classe G8ception( e le eccezioni sono degli oggetti appartenenti a =uesta classe( =uindi esse possono essere trattate come 9eri e propri componenti del linguaggio& 3ediamo come X possibile creare una eccezione& Si de9e creare una classe c#e estende 2#ro!able( o meglio G8ception ( la =uale X una estensione di 2#ro!able& Supponiamo di 9olere creare una eccezione per dire c#e ri5eriamo una stringa 9uota( scri9eremoL public class GrroreStringa3uota e8tends G8ception { GrroreStringa3uota() { super($Attenzione( stai ri5erendo una stringa non inizializzata$); } } Ruesta classe si de9e tro9are in un 5ile c#iamato come la classe( o99ero GrroreStringa3uota&;a9a @opo a9erla creata 9orremmo un modo per lanciarla( o99ero per mettere in risalto la situazione di errore( c#e a =uesto punto spero sia catturata da =ualcuno& /e eccezioni 9engono lanciate con l)istruzione t#ro!( la =uale de9e essere in un metodo c#e de9e essere dic#iarato con una clausola t#ro!s( ad esempio( nel nostro caso se 9oglio creare un metodo di stampa della stringa c#e controlla anc#e l)errore( scri9er] nella mia classeL public 9oid Stampa (String a)
:::...
:::...
t#ro!s GrroreStringa3uota "6 ^ Ruesto 9uol dire c#e =uesta 5unzione pu] lanciare una eccezione di tipo GrroreStringa3uota6" { i5 (a null) t#ro! ne! GrroreStringa3uota(); else S<stem&out&println(a); } Ruindi a =uesto punto il metodo Stampa mander sullo sc#ermo la stringa passatagli come parametro( e generer una eccezione di tipo GrroreStringa3uota se il puntatore era null& /)eccezione lanciata da noi si dice eccezione controllata( =uesta de9e essere obbligatoriamente gestita( mentre =uelle lanciate da Da9a non per 5orza de9ono essere catturate e gestite& 3ediamo ora come catturare le eccezioni( ad esempio la nostra GccezioneStringa3uota& /e eccezioni 9engono catturate =uando 9engono in9ocati i metodi c#e sono dic#iarati con la clausola t#ro!s( per catturarle bisogna in9ocare il metodo in blocc#i tr<( essi #anno la sintassi seguenteL tr< :/>CC> "" Ruesto X un blocco pericoloso( pu] lanciare eccezioni& catc# (2ipo di Gccezione da catturare) :/>CC> "" Ruesto X un blocco di ripristino& catc# (2ipo di Gccezione da catturare) :/>CC> "" Ruesto X un blocco di ripristino& Q& 5inall< :/>CC> Il corpo di =uesta istruzione 9iene eseguito 5ino alla 5ine oppure 5ino alla 9isione di una eccezione( in caso di eccezione si esaminano le clausole catc# per 9edere se esiste un gestore per =uella eccezione o per una sua superclasse( se nessuna clausola catc# cattura l)eccezione( essa 9iene lanciata nel metodo c#e l)#a pro9ocata (c#e l)#a lanciata)& Se nel tr< X presente una clausola 5inall<( il suo codice 9iene eseguito dopo a9er completato tutte le altre operazioni del tr<( indipendentemente dal 5atto c#e =uesta abbiano lanciato una eccezione o no& Ad esempio il nostro metodo Stampa pu] essere c#iamato cos_L Sia M la stringa da stampareL tr< {Stampa(M);} catc# (GrroreStringa3uota e) {S<stem&out&println ($Spiacente$);} In =uesto caso se M X null 9err lanciata l)eccezione e catturata( =uindi 9err stampata la stringa Spiacente( altrimenti M& Se a9essi scritto Stampa(M) 5uori dalla tr< a9rei a9uto errore( perc#` le eccezioni generate da me( de9ono obbligatoriamente essere catturate( =uesto obbliga il programmatore a scri9ere codice $buono$& /e eccezioni di Da9a possono essere in9ece catturate oppure no& Il seguente esempio riprende il CiaoMondo del primo capitolo( c#e se in9ocato senza parametri da9a una eccezione di Arra<Inde8>ut>5:oundsG8ception( c#e =uesta 9olta 9iene gestita; class CiaoMondo { public static 9oid main(StringBC args) { S<stem&out&print ($Ciao mondo( sono il primo programma in Da9a $); String %ome; String Cognome; tr< {%ome argsB'C;} catc# (Arra<Inde8>ut>5:oundsG8ception e) {%ome $%on #ai inserito il tuo %ome$;} ; tr< {Cognome argsB+C;} catc# (Arra<Inde8>ut>5:oundsG8ception e)
:::...
{Cognome $%on #ai inserito il tuo Cognome$;} ; S<stem&out&println ($di $E%omeE$ $ECognome); } } *ro9atelo( e pro9ate ad eseguirlo nei seguenti modiL ;a9a CiaoMondo %ome Cognome ;a9a CiaoMondo %ome ;a9a CiaoMondo e 9edete cosa succede( 5ate lo stesso con il CiaoMondo del primo capitolo&
:::...
LEZIONE 11:
Il Package lang
Il package java.lang
Ruesto pacAage lo abbiamo gi 9isto precedentemente( adesso per] ne esaminiamo alcune 5unzionalit c#e non abbiamo 9isto& Innanzitutto c)X da dire c#e =uesto X uno dei pacAage piV importanti dell)A*I di Da9a& Gsso contiene moltissime classi e inter5acce 5ondamentali per la programmazione Da9a( tanto c#e =uesto pacAage 9iene automaticamente incluso nei nostri porgrammi& Il suo contenuto X il seguenteL Intefacce Cloneable Comparable ?unnable Classi :oolean :<te C#aracter C#aracter&Subset C#aracter&Fnicode:locA Class Class/oader Compiler @ouble Float In#eritable2#read/ocal Integer /ong Mat# %umber >b;ect *acAage *rocess ?untime ?untime*ermission Securit<Manager S#ort String String:u55er S<stem 2#read 2#readHroup 2#read/ocal 2#ro!able 3oid Eccezioni Arit#meticG8ception Arra<Inde8>ut>5:oundsG8ception
:::...
Arra<StoreG8ception ClassCastG8ception Class%otFoundG8ception Clone%otSupportedG8ception G8ception IllegalAccessG8ception IllegalArgumentG8ception IllegalMonitorStateG8ception IllegalStateG8ception Illegal2#readStateG8ception Inde8>ut>5:oundsG8ception InstantiationG8ception InterruptedG8ception %egati9eArra<SizeG8ception %oSuc#FieldG8ception %oSuc#Met#odG8ception %ull*ointerG8ception %umberFormatG8ception ?untimeG8ception Securit<G8ception StringInde8>ut>5:oundsG8ception Fnsupported>perationG8ception Errori AbstractMet#odGrror ClassCircularit<Grror ClassFormatGrror Grror G8ceptionInInitializerGrror IllegalAccessGrror IncompatibleClassC#angeGrror InstantiationGrror InternalGrror /inAageGrror %oClass@e5FoundGrror %oSuc#FieldGrror %oSuc#Met#odGrror >ut>5Memor<Grror StacA>9er5lo!Grror 2#read@eat# FnAno!nGrror Fnsatis5ied/inAGrror FnsupportedClass3ersionGrror 3eri5<Grror 3irtualMac#ineGrror
:::...
%el primo capitolo abbiamo 9isto le classi in9olucro per i tipi primiti9i inclese in =uesto pacAage( in =uesta sezione esamineremo alcune classi del pacAage c#e 5anno delle cose piV complesse& /a prima classe c#e 9ediamo X la classe S<stem( la =uale inter5accia il nostro programma Da9a con il sistema sul =uale X eseguito& Innanzitutto la classe S<stem contiene tre attributi statici( essi sonoL static *rintStream err static InputStream in static *rintStream out =uesti rappresentano rispetti9amente lo standard error( lo standard input e lo standard output (c#e abbbiamo gi usato)( sono degli attributi particolari( in5atti essi sono di tipo classe( =uindi possono essere re5erenziati per prendere i metodi della classe( ad esempio( nella scritturaL S<stem&out&println($Ciao$); 9iene in9ocato il metodo println(String) della classe *rintStream( perc#` out X di tipo *rintStream& %ei nostri esempi abbiamo usato indi55erentemente le espressioniL S<stem&out&println($Ciao$); S<stem&out&println(true); S<stem&out&println(+');
:::...
S<stem&out&println()C));
:::...
In generale in Da9a =uesto non X possibile perc#` un metodo 9a in9ocato con il parametro attuale dello stesso tipo del parametro 5ormale( =uesta non X una eccezione( in5atti in9ocare il metodo println con tutti =uesti tipi di dato di9ersi X possibile perc#` *rintStream contiene tutti i metodi println dic#iarati con il parametro 5ormale adatto( in5atti essa contieneL 9oid println() 9oid println(boolean 8) 9oid println(c#ar 8) 9oid println(c#arBC 8) 9oid println(double 8) 9oid println(5loat 8) 9oid println(int 8) 9oid println(long 8) 9oid println(>b;ect 8) 9oid println(String 8) gli stessi metodi print( oltre o99iamente ad altri& /o stesso 9ale per err( essendo anc#)esso come out di tipo *rintStream( =uesto 9iene usato per segnalare gli errori a programma( X 5acile tro9are nei programmi espressioni del tipoL tr< {S<stem&out&println(stringaE$ 9s $EaltrastringaE$ $ Estringa&compare2o(altrastringa));} catc# (null*ointerG8ception e) {S<stem&err&println($G??>?GL /a seconda stringa stringa X nulla$);}; /)attributo in X in9ece di tipo InputStream( esso rappresenta come detto lo standard input& I metodi per agire su di esso saranno =uindi delle readL abstract int read() int read(b<teBC b) int read(b<teBC b( int o55( int len) Siccome X di tipo InputStream esso legge dei b<te( per 5argli leggere altre cose dobbiamo specializzarlo in =ualc#e altra cosa( nell)esempio seguente( c#e digiteremo in un 5ile c#iamato StandardI>&;a9a( gli 5aremo leggere intere linee& import ;a9a&io&6; class StandardI> { public static 9oid main(StringBC argomenti) { S<stem&out&println($Inserisc#i i tuoi input( batti end BI%3I>C per uscire$); InputStream?eader a ne! InputStream?eader(S<stem&in); :u55ered?eader I% ne! :u55ered?eader(a); String s ne! String(); !#ile(s&compare2o($end$)W ') { tr< {s I%&read/ine();} catc# (I>G8ception e) {s $G??>?G @I /G22F?A$;}; S<stem&out&println($/ettoL $Es); } } }
:::...
3ediamo alcuni metodi della classe S<stemL
:::...
static long current2imeMillis()( =uesto metodo restituisce il tempo corrente in millisecondi static 9oid e8it(int status)( =uesto metodo determina l)uscita dalla Da9a 3irtual Mac#ine( con un codice & static 9oid gc()( Da9a alloca tanti oggetti( e li disalloca =uando non sono piV usati e ser9e nuo9a memoria( per 5arlo usa un cosidetto Harbage Collector ( =uesto metodo esegue in =ualsiasi momento il garbage collector per liberare la memoria ancora allocata dal programma non usata( pu] essere molto utile in grosse applicazioni& static String geten9(String name)( restituisce una stringa contenente in5ormazioni riguardo al sistema su cui si esegue il programma( il metodo X dic#iarato deprecated sulle ultime @ocumentazioni on line del Da9a @e9elopment ait( =uesto perc#` il metodo presto scomparir( esso X delle prime 9ersioni del linguaggio( rimane ancora in =ueste per una =uestione di compatibilit con il 9ecc#io so5t!are& static *roperties get*roperties() ( X il nuo9o metodo per a9ere in5ormazioni sulle propriet del sistema& static String get*ropert<(String Ae<)( come =uello di prima( ma solo c#e prende in5ormazioni speci5ic#e riguardanti Ae< static String get*ropert<(String Ae<( String de5) static 9oid load(String 5ilename) ( carica in memoria il codice contenuto in 5ilename( c#e X una libreria dinamica& static 9oid load/ibrar<(String libname)( carica la libreria di sistema indicata da libname static String map/ibrar<%ame(String libname)( mappa una libreria in una stringa c#e la rappresenta& Ci sono i metodi per riassegnare gli standard input( output ed err( in altri 5lussi( ad esempio 5ile& static 9oid setGrr(*rintStream err) static 9oid setIn(InputStream in) static 9oid set>ut(*rintStream out) I seguenti metodi settano le propriet del sistema& static 9oid set*roperties(*roperties props) static String set*ropert<(String Ae<( String 9alue) Abbiamo usato degli oggetti di tipo *roperties( 9ediamo come sono 5attiL essi sono delle specializzazioni di tabelle #as# di ;a9a( sono sostanzialmente delle tabelle c#e #anno una serie di coppie C#ia9e - 3alore (In e55etti non sono proprio cos_( sono delle strutture molto usate in in5ormatica per contenere dati( per] a noi basta 9ederle cos_ per adesso)& In particolare le *roperties del sistema sonoL
Chiave 0ava.ver"ion 0ava.vendor 0ava.vendor.url 0ava.home
Descrizione de va ore associa!o -er"ione dell>am.iente di Java ?untime ;i"tri.utore dell>am.iente di Java ?untime 6?L del di"tri.utore di Java ;irector8 dove 2 in"tallato Java
0ava.vm."peci1ication.ver"i -er"ione delle "peci1iche della Java -irtual 9achine on 0ava.vm."peci1ication.vend ;i"tri.utore delle "peci1iche della Java -irtual 9achine or Nome delle "peci1iche della Java -irtual 9achine 0ava.vm.ver"ion 0ava.vm.vendor 0ava.vm.name 0ava."peci1ication.ver"ion -er"ione della implementazione della Java -irtual 9achine ;i"tri.utore della implementazione della Java -irtual 9achine Nome della implementazione della Java -irtual 9achine -er"ione dell>am.iente di Java ?untime
:::...
...::: h t t p : / / m a g o n i c o l a . 4 t . c o m 0ava."peci1ication.vendor 0ava."peci1ication.name 0ava.cla"".ver"ion 0ava.cla"".path o".name o".arch o".ver"ion 1ile."eparator path."eparator line."eparator u"er.name u"er.home u"er.dir
:::...
;i"tri.utore dell>am.iente di Java ?untime Java ?untime Nome dell>am.iente di Java ?untime -er"ione delle cla""i di Java #athname delle cla""i di Java Nome &i"tema Operativo 4rchitettura del &i"tema Operativo -er"ione del "i"tema Operativo &eparatore di 3ile @'/' "u 6NIA: 'B' "u 7indo<"C &eparatore di #ath @':' "u 6NIA: 'D'"u 7indo<"C Ne< Line @'Bn' "u 6NIA e 7indo<"C 4ccount name dell>utente Eome director8 dell>utente 7or$ing director8 dell>utente
Dotremmo quindi scrivere un programmino che ci da informazioni sul sistema, come il seguente, da editare in un file chiamato :istema.>ava import >ava.io.KM public class Sistema { public static 9oid main(StringBC arg) { "" Cambio lo standard output( uso il 5ile Sistema&t8t File outFile ne! File($Sistema&t8t$); File>utputStream 5!; tr< {5! ne! File>utputStream(outFile) ;} catc# (I>G8ception e) {5! null;}; *rintStream >utput ne! *rintStream(5!); S<stem&set>ut(>utput); "" Scri9o sul nuo9o standard outputL "" 2empoL long tempo S<stem&current2imeMillis(); S<stem&out&println($2empo in millisecondiL $Etempo); long t+ tempo"+'''; S<stem&out&println($2empo in secondiL $Et+); long sec t+bS'; long t4 t+"S'; long min t4bS';
:::...
long t. t4"S'; S<stem&out&println($2empo in ore #$Et.E$ m$EminE$ s$Esec); S<stem&out&println($JnG) il tempo passato dal +"+"+,-' ad ora&Jn$); "" *ropriet del sistemaL S<stem&out&println($Jn*roprieta) del sistemaLJn$); String tmp; S<stem&out&println($JnJtDA3AJn$); tmp S<stem&get*ropert<($;a9a&9ersion $); S<stem&out&println($3ersione dell)ambiente di Da9a ?untimeL $Etmp); tmp S<stem&get*ropert<($;a9a&9endor$); S<stem&out&println($@istributore dell)ambiente di Da9a ?untimeL $Etmp); tmp S<stem&get*ropert<($;a9a&9endor&url$); S<stem&out&println($F?/ del distributore di Da9aL $Etmp); tmp S<stem&get*ropert<($;a9a&#ome$); S<stem&out&println($@irector< do9e e) installato Da9aL $Etmp); tmp S<stem&get*ropert<($;a9a&9m&speci5ication&9ersion$); S<stem&out&println($3ersione delle speci5ic#e della Da9a 3irtual Mac#ineL $Etmp); tmp S<stem&get*ropert<($;a9a&9m&speci5ication&9endor$); S<stem&out&println($@istributore delle speci5ic#e della Da9a 3irtual Mac#ineL $Etmp); tmp S<stem&get*ropert<($;a9a&9m&speci5ication&name$); S<stem&out&println($%ome delle speci5ic#e della Da9a 3irtual Mac#ineL $Etmp);
:::...
tmp S<stem&get*ropert<($;a9a&9m&9ersion$); S<stem&out&println($3ersione della implementazione della Da9a 3irtual Mac#ineL $Etmp); tmp S<stem&get*ropert<($;a9a&9m&9endor$ ); S<stem&out&println($@istributore della implementazione della Da9a 3irtual Mac#ineL $Etmp); tmp S<stem&get*ropert<($;a9a&9m&name$); S<stem&out&println($%ome della implementazione della Da9a 3irtual Mac#ineL $Etmp); tmp S<stem&get*ropert<($;a9a&speci5ication&9ersion$); S<stem&out&println($3ersione dell)ambiente di Da9a ?untimeL $Etmp); tmp S<stem&get*ropert<($;a9a&speci5ication&9endor$); S<stem&out&println($@istributore dell)ambiente di Da9a ?untime Da9a ?untimeL $Etmp); tmp S<stem&get*ropert<($;a9a&speci5ication&name$ ); S<stem&out&println($%ome dell)ambiente di Da9a ?untimeL $Etmp); S<stem&out&println($JnJtC/ASSIJn$); tmp S<stem&get*ropert<($;a9a&class&9ersion$); S<stem&out&println($3ersione delle classi di Da9aL $Etmp); tmp S<stem&get*ropert<($;a9a&class&pat#$); S<stem&out&println($*at#name delle classi di Da9aL $Etmp); S<stem&out&println($JnJtSIS2GMA >*G?A2I3>Jn$);
:::...
tmp S<stem&get*ropert<($os&name$); S<stem&out&println($%ome Sistema >perati9oL $Etmp); tmp S<stem&get*ropert<($os&arc#$); S<stem&out&println($Arc#itettura del Sistema >perati9oL $Etmp); tmp S<stem&get*ropert<($os&9ersion$); S<stem&out&println($3ersione del sistema >perati9oL $Etmp); tmp S<stem&get*ropert<($5ile&separator$); S<stem&out&println($Separatore di FileL $Etmp); tmp S<stem&get*ropert<($pat#&separator$); S<stem&out&println($Separatore di *at#nameL $Etmp); tmp S<stem&get*ropert<($line&separator$); S<stem&out&println($%e! /ineL $Etmp); S<stem&out&println($JnJtF2G%2GJn$); tmp S<stem&get*ropert<($user&name$); S<stem&out&println($Account name dell)utenteL $Etmp); tmp S<stem&get*ropert<($user&#ome$); S<stem&out&println($Uome director< dell)utenteL $Etmp); tmp S<stem&get*ropert<($user&dir$); S<stem&out&println($PorAing director< dell)utenteL $Etmp); } } 7seguito sul mio sistema, l'output stato &:istema.t"t'9 !empo in millisecondi9 FAE=?<=CC?C@ !empo in secondi9 FAE=?<=CC !empo in ore h=EAE== mCC sAC 7' il tempo passato dal <4<4<FV@ ad ora. Droprieta' del sistema9 J:V:
:::...
<. /ersione dell'am*iente di Java Buntime9 null =. (istri*utore dell'am*iente di Java Buntime9 :un #icros stems Inc. C. 5B% del distri*utore di Java9 http944>ava.sun.com4 ?. (irector dove e' installato Java9 +9XDBO0B8##IXJ8/8:OR!XJB7X<.C A. /ersione delle specifiche della Java /irtual #achine9 <.@ E. (istri*utore delle specifiche della Java /irtual #achine9 :un #icros stems Inc. V. 6ome delle specifiche della Java /irtual #achine9 Java /irtual #achine :pecification Q. /ersione della implementazione della Java /irtual #achine9 <.C.@rc<P: F. (istri*utore della implementazione della Java /irtual #achine9 :un #icros stems Inc. <@.6ome della implementazione della Java /irtual #achine9 Java Hot:pot&!#' +lient /# <<./ersione dell'am*iente di Java Buntime9 <.C <=.(istri*utore dell'am*iente di Java Buntime Java Buntime9 :un #icros stems Inc. <C.6ome dell'am*iente di Java Buntime9 Java Dlatform 8DI :pecification %L: I
:::...
<. /ersione delle classi di Java9 ?V.@ =. Dathname delle classi di Java9 . I ;EM: O,E<:;IVO <. =. C. ?. A. E. 6ome :istema Operativo9 2indows FA 8rchitettura del :istema Operativo9 "QE /ersione del sistema Operativo9 ?.@ :eparatore di Rile9 X :eparatore di Dathname9 M 6ew %ine9
:::...
(;EN;E <. 8ccount name dell'utente9 pietro =. Home director dell'utente9 +9X2I6(O2:XDrofilesXDietr@@@ C. 2or$ing director dell'utente9 (9X%avoroXH!#%.I!XcorsoXesempiXcapCXlezE 5n'altra classe molto importante del pac$age >ava.lang di Java la classe O*>ect, questa la classe da cui vengono create tutte le altre classi di Java, ovvero, ogni altra classe di Java una estensione della classe >ava.lang.O*>ect. %a class O*>ect non contiene alcuna varia*ile, contiene << metodi che vengono ereditati da tutte le altre classi di Java, e possono essere usate quindi in qualsiasi oggetto definito in Java, tra cui9 clone(), che crea una copia dell'oggetto identica a quella di cui stato invocato il metodo. In particolare da notare che il programma Java stesso un Oggetto, quindi si possono creare un numero ar*itrario di programmi tutti identici. 8ffinch possa essere invocato il metodo clone&' di un oggetto, questo deve implementare l'interfaccia +lonea*le . getClass(), restituisce un Oggetto di tipo +lass, che rappresenta la classe di appartenenza dell'oggetto di cui stato invocato il metodo. toString(), trasforma l'oggetto in una stringa, questo metodo deve essere sovrascritto negli oggetti creati dall'utente, ma molto utile. :i pensi alla scrittura :tring sommaLG:ommandoG,<@,G e G,<<,G ottengo G,&<@,<<'M :i crea una stringa usando delle stringhe e degli int, automaticamente Java in questo caso ne invoca il metodo to:tring&' della classe involucro corrispondente. .uesto accade in ogni espressione che coinvolge stringhe e oggetti del tipo G:tringaG,Oggetto. %'altra classe del pac$age nominata sopra +lass, questa rappresenta le classi del linguaggio, essa molto importante perch ha pi) di trenta metodi che servono per gertire le classi a runtime, cosa impensa*ile negli altri linguaggi di programmazione. Oggetti di questo tipo, detti descrittori di classe, anche se sono anche descrittori di interfacce, vengono automaticamente creati e associati agli oggetti a cui si riferiscono. Oggetti di tipo +lass, O*>ect e altri tipi, sono molto importanti a runtime, perch permettono di gestire il programma che in esecuzione come se fosse una collezione di dati su cui possi*ile lavorare. Java un linguaggio dalle potenzialit impressionanti, si pensi che stesso in >ava.lang, c' una classe chaimata +ompiler, la quale contiene metodi per compilare sorgenti Java, vi sono altre classi, come +lass%oader, Buntime, che permettono di caricare nuove classi a runtime, di eseguirle, e di modificare il programma stesso mentre eseguito, potenzialmente in Java possi*ile scrivere del codice che si automodifica &che si evolve'. 8 questo punto termino la trattazione del >ava.lang, anche perch vederlo in dettaglio troppo complicato ed sicuramente fuori dagli scopi del nostro corso, a noi *asta sapere che esiste e che fa delle cose che per gli altri linguaggi di programmazione pura fantasia, o almeno impossi*ile o difficilissimo fare ad alto livello. Drima di terminare descrivo *revemente la classe >ava.lang.#ath &diversa dalla classe >ava.math'. .uesta classe serve per fare calcoli matematici, essa ha due attri*uti9 static double G ( X la e di Gulero static double *I( X la *I Hreca I metodi sono ovviamente tutte le funzioni matematiche calcola*ili, tra cui9 <. =. C. ?. A. I valori assoluti di valori dou*le, float, int e long9 static dou*le a*s&dou*le a' static float a*s&float a' static int a*s&int a' static long a*s&long a'
%e funzioni trigonometriche <. static dou*le acos&dou*le a' P arcocoseno =. static dou*le asin&dou*le a' P arcoseno C. static dou*le atan&dou*le a' P arcotangente
:::...
?. static dou*le cos&dou*le a' P coseno A. static dou*le sin&dou*le a' P seno E. static dou*le tan&dou*le a' P tangente !rasformazioni di angoli
:::...
<. static dou*le to(egrees&dou*le angrad' P converte radianti in gradi =. static dou*le toBadians&dou*le angdeg' P converte gradi in radianti C. static dou*le atan=&dou*le a, dou*le *' P converte coordinate cartesiane &*,a' in coordinate polari &r,theta' Runzioni esponenziali e logaritmiche <. static dou*le e"p&dou*le a' P e elevato alla a. =. static dou*le log&dou*le a' P logaritmo in *ase e di a #assimi e minimi tra valori dou*le, float, int e long <. =. C. ?. A. E. V. Q. static dou*le ma"&dou*le a, dou*le *' static float ma"&float a, float *' static int ma"&int a, int *' static long ma"&long a, long *' static dou*le min&dou*le a, dou*le *' static float min&float a, float *' static int min&int a, int *' static long min&long a, long *'
Dotenze e radici <. static dou*le pow&dou*le a, dou*le *' P calcola a elevato alla *, da notare che se * \<, questa =. una radice &<4*'Pesima di a C. static dou*le sqrt&dou*le a' P calcola la radice quadrata di a. 6umeri pseudocasuali <. static dou*le random&' P spara un numero casuale tra @ e < 8rrotondamenti <. static dou*le rint&dou*le a' P parte intera *assa di a, un intero =. static long round&dou*le a' P a arrotondato, un long C. static int round&float a' P a arrotondato, un intero /isto che a**iamo nominato il pac$age >ava.math, diciamo che questo contiene due classi, -igInteger e -ig(ecimal. %a prima classe serve per trattare numeri interi di grandezza ar*itraria, si pensi ad esempio al calcolo del fattoriale di un numero molto grande, questo sar un numero spaventosamente grande. -ig(ecimal fa lo stesso per numeri particolari.
LEZIONE 1":
*rima di cominciare =uesta lezione de9o 5are una piccola nota& Abbiamo 9isto come programmare in Da9a( ma mi sono accorto c#e le tastiere italiane non #anno le parentesi gra55e( mentre sulle tastiere c#e uso io ci sono& Ruindi de9o dir9i come 5are uscire le parentesi& *er 5are apparire { bisogna premere il tasto A/2( e tenendolo premuto bisogna battere sul tastierino numericoalla destra della tastiera il numeri +14 (A/2E+14)& *er 5are apparire } si de9e premere in9ece A/2E+10& *er gli altri simboli utili in Da9aL A/2 Hr E X ci da la B e A/2 Hr E E da C& I tasti sono sottolineati per non con5onderli con il E c#e indica $premere insieme$& A/2 Hr X l)A/2 c#e si tro9a alla destra del tasto S*AOI>( mentre A/2 si tro9a alla sinistra (guardando la tastiera)& Ruesto pacAage X molto utile( esso mette a disposizione 4. classi e +4 inter5acce c#e implementano alcune tra le strutture dati piV comuni( alcune operazioni su date e sul calendario( e altre cose& Inoltre il pacAage ;a9a&util include altri sottopacAages c#e sonoL ;a9a&util&mime(;a9a&util&zip e ;a9a&util&;ar c#e ser9ono rispetti9amente per trattare 5iles di tipo MIMG( di tipo OI* e di tipo Da9a Arc#i9e (DA?)( c#e 9edremo in seguito in =uesto capitolo& *er struttura dati( in in5ormatica si intende una struttura logica atta a contenere un certo numero di dati( nella =uale X possibile inserire dati( toglierli( cercarli( a limite ordinarli& Fna semplice struttura dati c#e abbiamo gia 9isto X l)arra<( esso contiene un cero numero di dati c#e possono essere =ualsiasi cosa( da b<te ad oggetti complessi( su =uesta si possono 5are inserzioni ricerc#e e cancellazioni( 9olendo un arra< pu] anc#e essere ordinato&
Il package java.util
:::...
:::...
*er 9edere se in un arra< grande % X presente un dato M( io de9o 9isitare tutto l)arra< e 5are dei con5ronti con ogni elemento dell)arra<( =uindi =uesta X una operazione abbastanza complessa& Gsistono delle strutture dati c#e =uesta ricerca la 5anno impiegando un solo accesso alla struttura( =ueste sono ad esempio le gi citate tabelle #as#& /a scelta delle strutture dati da usare in un programma X una scelta abbastanza complicata( in5atti si sceglie una struttura anzic#` un)altra in base all)uso c#e de9e esserne 5atto nel programma( ad esempio X di55icile c#e in un database molto grande in cui si 5anno continue ricerc#e si usi un arra< come struttura dati( perc#` ogni ricerca coster tanto in termini di tempo (il computer X 9eloce( ma #a anc#)esso i suoi limiti( se pensiamo ad un database di un miliardo di elementi( il computer per 9isitarlo tutto pu] impiegare tanto)( in =uesto caso X 5orse meglio usare una tabella #as# opportunamente grande& Da9a =uindi ci mette a disposizione tutta una gamma di strutture dati( le gestisce lui( e a noi non resta solo c#e usarle& *er la scelta della struttura dati piV consona al nostro scopo( useremo il buon senso( perc#` per sceglierla in modo rigoroso occorrono delle conoscenze molto speci5ic#e( tra cui i dettagli realizzati9i delle strutture( studiate in corsi uni9ersitari =uali Algoritmi e Strutture @ati ( e Fondamenti di Complessit& Io =uando descri9er] le classi di Da9a addette all)implementazione di =ueste strutture( accenner] a loro( e discuter] dei tempi di inserzioni( ricerc#e( ecceteraQ( ma sempre in5ormalmente& 3ediamo cosa contiene il pacAage ;a9a&util Interfacce Collection Comparator Gnumeration G9ent/istener Iterator /ist /istIterator Map Map&Gntr< >bser9er Set SortedMap SortedSet Rueste inter5acce stabiliscono alcune propriet delle nostre strutture dati( esse 9engono implementate in alcune delle seguenti classi& Classi AbstractCollection Abstract/ist AbstractMap AbstractSe=uential/ist AbstractSet Arra</ist Arra<s :itSet Calendar Collections @ate @ictionar< G9ent>b;ect HregorianCalendar Uas#Map Uas#Set Uas#table /inAed/ist /ist?esource:undle /ocale >bser9able *roperties *ropert<*ermission *ropert<?esource:undle ?andom ?esource:undle Simple2imeOone
:::...
StacA String2oAenizer 2imer 2imer2asA 2imeOone 2reeMap 2reeSet 3ector PeaAUas#Map Eccezioni ConcurrentModi5icationG8ception Gmpt<StacAG8ception Missing?esourceG8ception %oSuc#GlementG8ception 2ooMan</istenersG8ception
:::...
Iniziamo a 9edere =ualc#e struttura( 9ediamo :itSet( o in italiano Insieme di :it& Ruesta classe 5ornisce un modo per creare e gestire insiemi bit (+(') o meglio 9alori true( 5alse& /)insieme X in e55etti un 9ettore di bit( per] c#e cresce dinamicamente& All)inizio i bit #anno 9alore 5alse( e il 9ettore X lungo 1Z41-+ ((due alla trentadue) meno uno)& /a classe #a due costruttoriL :itSet()( per creare un :itSet di dimensioni standard( e :itSet(int nbits)( per creare un :itSet c#e contiene nbits bit& /e operazioni c#e si possono e55ettuare sono le seguentiL 9oid and(:itSet set)( restituisce l)and tra la :itSet e l)altra :itSet indi9iduate da set& 9oid and%ot(:itSet set)( cancella tutti i bit della :itSet c#e #anno il corrispondente bit settato nella :itSet set& 9oid or(:itSet set)( restituisce l)or inclusi9otra la :itSet e l)altra :itSet indi9iduate da set& 9oid 8or(:itSet set) ( restituisce l)or esclusi9o tra la :itSet e l)altra :itSet indi9iduate da set& 9oid clear(int bitInde8)( setta il bit speci5icato a 5alse& 9oid set(int bitInde8)( setta il bit speci5icato a true& >b;ect clone()( :itSet X dic#iarato Cloneable( =uesto metodo ne crea una copia uguale& boolean e=uals(>b;ect ob;)( con5ronta l)oggetto con un altro oggetto& boolean get(int bitInde8)( da il 9alore del bit numero bitInde8& int #as#Code()( da un codice #as# per =uesto bitset& int lengt#()( da la grandezza logica del bit set( o99ero il bit piV alto settato a true( piV uno& int size()( da il numero di bit attuali della bitset( X il bit piV alto c#e pu] essere posto a uno senza ampliare la bit set& String toString()( tras5orma la bitset in una stringa *ro9iamo la bit set con il seguente programma CaratteriFsati( da editare in un 5ile c#iamato CaratteriFsati&;a9a( il =uale prende una stringa in ingresso e 9ede =uali caratteri sono stati usati& import ;a9a&util&:itSet; public class CaratteriFsati { public static 9oid main (StringBC a) { String tmp; tr< {tmp aB'C;} catc# (Arra<Inde8>ut>5:oundsG8ception e) {errore();} elabora(aB'C); } public static 9oid errore() { S<stem&out&println($G??>?G( #o bisogno di una stringaL$);
:::...
S<stem&out&println($Jt:attereL$); S<stem&out&println($JtJt;a9a CaratteriFsati S2?I%HA&$); S<stem&e8it('); } public static 9oid elabora (String a) { String tmp a;
:::...
:itSet usati ne! :itSet(); 5or (int i '; i [ tmp&lengt#() ; iEE) usati&set(tmp&c#arAt(i)); String out $B$; int dim usati&size(); 5or (int i '; i [ dim; iEE) { i5 (usati&get(i)) outE (c#ar )i; }; outE $C$; S<stem&out&println(out); S<stem&out&println($*er l)elaborazione #o usato una bit set di $Eusati&size()E$ bit$); S<stem&out&println ($JtJtJt*ietro $); } } 3ediamo un)altra classe di ;a9a&util( la classe 3ector& Ruesta classe implementa degli arra< di >b;ect& /a cosa interessante rispetto agli arra< del linguaggio( X c#e si pu] modi5icare la lung#ezza del 9ettore a tempo di esecuzione& In 3ector a9remo =uindi oltre ai costruttori tre tipi di metodi( metodi per modi5icare il 9ettore( metodi per ottenere i 9alori presenti nel 9ettore e metodi per gestire la crescita del 9ettore& Uo =uattro costruttoriL 3ector()( c#e costruisce un 9ettore grande +'( e con possibilit di incremento pari a zero& 3ector(Collection c)( costruisce un 9ettore contenente gli elementi della collezione speci5icata( nello stesso ordine in cui appaiono nella collezione& 3ector(int initialCapacit<)( costruisce un 9ettore grande =uando initialCapacit<( con possibilit di Incremento pari a zero& 3ector(int initialCapacit<( int capacit<Increment)( costruisce un 9ettore grande initialCapacit<( con la possibilit di incremento pari a capacit<Increment& Alcuni metodi della classe sono i seguentiL 9oid add(int inde8( >b;ect element)( aggiunge un elemanto al 9ettore nella posizione indicata& boolean add(>b;ect o)( aggiunge un elementio alla 5ine del 9ettore& boolean addAll(Collection c)( aggiunge alla 5ine del 9ettore gli elementi della collezione speci5icata( nello stesso ordine in cui appaiono nella collezione& boolean addAll(int inde8( Collection c)( aggiunge gli elementi della collezione nel 9ettore iniziando dall)indice speci5icato& Ruesti tre metodi ritornano true se gli elementi sono stati aggiunti( 5alse se non c)entrano& 9oid addGlement(>b;ect ob;)( aggiunge l)elemento al 9ettore( e ne incrementa la capacit di uno& int capacit< ()( da) la capacit attuale del 9ettore&
:::...
:::...
9oid clear()( rimuo9e tutti gli elementi presenti nel 9ettore& >b;ect clone()( solito metodo usato per clonare l)oggetto 3ector( c#e X c#iaramente cloneable& boolean contains(>b;ect elem)( controlla se l)elemento speci5icato X presente nel 9ettore& boolean containsAll(Collection c)( controlla se l)intera collezione speci5icata X presente nel 9ettore& 9oid cop<Into(>b;ectBC anArra<)( copia il contenuto dell)oggeto di tipo 3ector in un arra< di oggetti del linguaggio& >b;ect elementAt(int inde8)( restituisce l)elemento del 9ettore c#e si tro9a nella posizione speci5icata& boolean e=uals(>b;ect o)( controlla l)uguaglianza tra il 9ettore e l)oggetto speci5icato& >b;ect 5irstGlement()( da il primo elemento del 9ettore( =uello in posizione '& >b;ect get(int inde8)( da l)elemento del 9ettore c#e si tro9a nella posizione speci5icata( e lo cancella dal 9ettore& int #as#Code()( da il codice #as# del 9ettore& int inde8>5(>b;ect elem)( cerca la prima occorrenza del dato elemento nel 9ettore( e ne restituisce l)indice& *er prima occorrenza intendo o99iamente =uella di indice piV basso& int inde8>5(>b;ect elem( int inde8)( cerca la prima occorrenza del dato elemento nel 9ettore iniziando dall)indice speci5icato( e ne restituisce l)indice 9oid insertGlementAt(>b;ect ob;( int inde8)( inserisce l)oggetto speci5icato nella posizione 9oluta del 9ettore& boolean isGmpt<()( controlla se il 9ettore X 9uoto& >b;ect lastGlement()( da l)ultimo componente del 9ettore& int lastInde8>5(>b;ect elem)( da l)indice dell)ultima occorrenza dell)oggetto speci5icato nel 9ettore& int lastInde8>5(>b;ect elem( int inde8)( come prima iniziando dall)indice speci5icato e procedendo all)indietro& >b;ect remo9e(int inde8)( cancella l)elemento c#e si tro9a nella posizione indicata nel 9ettore& boolean remo9e(>b;ect o)( cancella la prima occorrenza nel 9ettore dell)oggetto speci5icato& boolean remo9eAll(Collection c)( cancella dal 9ettore tutti gli elementi contenuti nella collezione speci5icata& 9oid remo9eAllGlements()( cancella tutti gli elementi del 9ettore& boolean remo9eGlement(>b;ect ob;)( cancella la prima occorrenza dell)oggetto speci5icato nel 9ettore& 9oid remo9eGlementAt(int inde8)( cancella l)elemento nella posizione speci5icata& boolean retainAll(Collection c)( cancella tutti gli elementi del 9ettore c#e non sono contenuti nella collezione speci5icata& >b;ect set(int inde8( >b;ect element)( rimpiazza l)elemento nella posizione speci5icata del 9ettore con l)elemento passatogli come parametro (mette element all)indirizzo inde8)& 9oid setGlementAt(>b;ect ob;( int inde8)( mette l)oggetto speci5icato nella posizione 9oluta& 9oid setSize(int ne!Size)( setta la nuo9a dimensione del 9ettore& int size()( da il numero di posizioni nel 9ettore& /ist sub/ist(int 5romInde8( int toInde8)( crea una lista con gli elementi del 9ettore c#e si tro9ano dalla posizione speci5icata come inizio a =uella come 5ine& /ist X un)altra struttura dati molto importante( c#e Da9a #a gi implementata& >b;ectBC toArra<() e >b;ectBC toArra<(>b;ectBC a)( creano un arra< del linguaggio con gli elementi contenuti nel 9ettore& toString()( da) una rappresentazione sotto 5orma di stringa del 9ettore( contenente le rappresentazioni sotto 5orma di stringa di tutti gli oggetti contenuti nel 9ettore( in pratica in9oca il toString di tutti gli oggetti& C#i X abituato a programmare in altri linguaggi di programmazione potr apprezzare tutte le 5unzionalit dei 9ettori( 5unzionalit c#e spesso il programmatore de9e implementarsi da solo( e c#e spesso lo 5a in modo sommario& Ruello c#e personalmente apprezzo io( da programmatore( X oltre alla dinamicit della struttura 3ector( c#e X stata sempre per de5inizione statica( la possibilit di creare 9ettori con elementi eterogenei( in5atti =uesti sono 9ettori di oggetti( e si sa c#e gli oggetti di Da9a possono essere =ualsiasi cosa( anc#e programmi& Ad esempio X possibile creare un 9ettore contenente numeri interi( 9alori booleani e string#e( cosa c#e non X possibile 5are con gli arra< del linguaggio& *er 5armi capire meglio 5accio un esempio& *ensate al seguente 9ettoreL pippo { true ( +' ( $Ciao$};
@i c#e tipo sar pippo\ intBC\ booleanBC\ > StringBC\ %essuno dei tre( in Da9a X impossibile creare un arra< cos_ 5atto( usando per] le 5amose classi in9olucro( c#e 5in)ora ci sembra9ano abbastanza inutili( possiamo creare un arra< cos_ 5atto( scri9eremo =ualcosa del tipo& >b;ectBC pippo {ne! :oolean(true)( ne! Integer(+')( ne! String($Ciao$) }; Se inoltre usiamo la classe 3ector( abbiamo anc#e parecc#i metodi per gestire =uesto 9ettore di elementi eterogenei&
:::...
:::...
Facciamo un piccolo esempio c#e usa i 9ettori( de5iniamo uno spazio geometrico tridimensionale di punti( linee e 5acce( cos_ de5initiL class punto { String nome; int 8(<(z; public punto(String n( int M(int N(int O) { 8 M; < N; 8 O; nome n; } public String toString() { return $Jn$EnomeE$ $E8E$($E<E$($EzE$Jn$; } } class linea { String nome; punto inizio; punto 5ine; public linea(String n( punto i(punto 5) { inizio i; 5ine 5; nome n; } public String toString() { return $Jn$EnomeE$ ($Einizio&toString()E$($E5ine&toString()E$)Jn$; } } class 5accia { String nome; punto 8+; punto 81; punto 84; linea l+; linea l1; linea l4; public 5accia(String n( punto M+(punto M1(punto M4) {
:::...
8+ M+; 81 M1; 84 M4; l+ ne! linea(nE$-linea+$(8+(81); l1 ne! linea(nE$-linea1$(84(81); l4 ne! linea(nE$-linea4$(8+(84); nome n; } public String toString() { return $Jn$EnomeE$ {$ El+&toString()E $($ El1&toString()E $($ El4&toString()E$}Jn$; } }
:::...
@a notare c#e le classi contengono dei metodi toString()( c#e so9rascri9ono i metodi standard( =uesto per creare l)output su 5ile del programma& Rueste classi le metteremo in un 5ile c#iamato Heometria&;a9a( o9e metteremo anc#e le import necessarie al programma e la classe Heometria contenente il main sotto de5initeL import ;a9a&util&6; import ;a9a&io&6; "" @e5inizione della class punto "" @e5inizione della class linea "" @e5inizione della class 5accia public class Heometria { public static int %FMG?> 4''';
public static 9oid main(StringBC arg) { 3ector spazio ne! 3ector(+(+); S<stem&out&println($Heometria nello spazioL$); int pti %FMG?>;
S<stem&out&println(); S<stem&out&println($Henero $EptiE$ oggetti a caso per ogni specie$); S<stem&out&println($Cambiare la costante %FMG?> in Heometria per generarne un numero di9erso&$); int lin %FMG?>; int 5ac; 5ac %FMG?>; S<stem&out&println(); int d+ spazio&capacit<(); S<stem&out&println ($Capacit del 9ettoreL$Espazio&capacit<());
:::...
S<stem&out&println($Henero i punti&&&$); int i '; 5or ( i { ';i
:::...
5loat a (5loat ) Mat#&random(); 5loat b (5loat ) Mat#&random(); 5loat c (5loat ) Mat#&random(); int 8 Mat#&round(a6+'''); int < Mat#&round(b6+'''); int z Mat#&round(c6+'''); String nome $*unto$E(iE+); punto tmp* ne! punto(nome(8(<(z); spazio&addGlement(tmp*); }; S<stem&out&println ($Capacit del 9ettoreL$Espazio&capacit<()); int d1 spazio&capacit<(); S<stem&out&println($Henero le linee&&&$); 5or ( i { ';i
5loat a (5loat ) Mat#&random(); 5loat b (5loat ) Mat#&random(); 5loat c (5loat ) Mat#&random(); 5loat d (5loat ) Mat#&random(); 5loat e (5loat ) Mat#&random(); 5loat 5 (5loat ) Mat#&random(); int 8 Mat#&round(a6+'''); int < Mat#&round(b6+'''); int z Mat#&round(c6+'''); int 8+ Mat#&round(d6+'''); int <+ Mat#&round(e6+'''); int z+ Mat#&round(56+'''); String nome $/inea$E(iE+); punto *+ ne! punto ($*unto + della $Enome(8(<(z);
:::...
punto *1 ne! punto ($*unto 1 della $Enome(8+(<+(z+); linea tmp/ ne! linea(nome(*+(*1); spazio&addGlement(tmp/); }; S<stem&out&println ($Capacit del 9ettoreL$Espazio&capacit<()); int d4 spazio&capacit<(); S<stem&out&println($Henero le 5acce&&&$); 5or ( i { ';i
:::...
5loat a (5loat ) Mat#&random(); 5loat b (5loat ) Mat#&random(); 5loat c (5loat ) Mat#&random(); 5loat d (5loat ) Mat#&random(); 5loat e (5loat ) Mat#&random(); 5loat 5 (5loat ) Mat#&random(); 5loat g (5loat ) Mat#&random(); 5loat # (5loat ) Mat#&random(); 5loat ; (5loat ) Mat#&random(); int 8 Mat#&round(a6+'''); int < Mat#&round(b6+'''); int z Mat#&round(c6+'''); int 8+ Mat#&round(d6+'''); int <+ Mat#&round(e6+'''); int z+ Mat#&round(d6+'''); int 81 Mat#&round(g6+'''); int <1 Mat#&round(#6+'''); int z1 Mat#&round(;6+'''); String nome $Faccia$E(iE+); punto *+ ne! punto ($*unto + della $Enome(8(<(z); punto *1 ne! punto ($*unto 1 della $Enome(8+(<+(z+); punto *4 ne! punto ($*unto + della $Enome(81(<1(z1); 5accia tmpF ne! 5accia(nome(*+(*1(*4); spazio&addGlement(tmpF);
:::...
}; S<stem&out&println ($Capacit 5inale del 9ettoreL$Espazio&capacit<()); int d. spazio&capacit<(); File File>ut ne! File($Heometria&t8t$); FilePriter >utput; tr< {>utput ne! FilePriter(File>ut);} catc# (I>G8ception e) {>utput null;}; tr< { >utput&!rite($Heometria&t8tJnnumero oggetti $E46%FMG?>E$Jn$);
:::...
>utput&!rite($@imensioni del 3ectorLJnall)inizioL$Ed+E$Jn dopo l)inserzione dei puntiL$Ed1); >utput&!rite($Jndopo l)inserzione delle lineeL$Ed4E$Jndopo l)inserzione delle 5acceL$Ed.); >utput&!rite($JnJnContenutoLJn$); >utput&!rite(spazio&toString()); >utput&!rite($JnJnJnJtJt*ietro Castellucci$); >utput&5lus#(); } catc# (I>G8ception e) {}; S<stem&out&println($JnHuarda il 5ile Heometria&t8t&Jn$); }; } Se mandiamo in esecuzione il programma 9ediamo come il 3ector spazio cresce dinamicamente( con gli oggetti eterogenei punto( linea e 5accia& Alla 5ine a9remo un 5ile c#iamato Heometria&t8t c#e conterr la descrizione del 9ettore( il 5ile con soli 0 elementi per ogni specie sar =ualcosa del tipoL Heometria&t8t numero oggetti +0 @imensioni del 3ectorL all)inizioL+ dopo l)inserzione dei puntiL0 dopo l)inserzione delle lineeL+' dopo l)inserzione delle 5acceL+0 ContenutoL B *unto+ S04(,41(' ( *unto1 +''(1-4(' ( *unto4 T00(1+'(' ( *unto. 40+(-'1(' ( *unto0 +TT(,,S(' (
:::...
/inea+ ( *unto + della /inea+ ST'(.0.(' ( *unto 1 della /inea+ S,(+S(' ) ( /inea1 ( *unto + della /inea1 ++S(S0+(' ( *unto 1 della /inea1 4-+(+0(' ) ( /inea4 ( *unto + della /inea4 ,.-(440(' ( *unto 1 della /inea4 .--(1+.(' ) ( /inea. ( *unto + della /inea. 4,+(S-+(' ( *unto 1 della /inea. S,1(-10(' ) ( /inea0 ( *unto + della /inea0 -S1(1T4(' ( *unto 1 della /inea0 0T1(+,1(' ) ( Faccia+ { Faccia+-linea+ ( *unto + della Faccia+ T1S(140(' ( *unto 1 della Faccia+ +4(4-T(' ) ( Faccia+-linea1 ( *unto + della Faccia+ +1(,0'(' ( *unto 1 della Faccia+ +4(4-T(' ) ( Faccia+-linea4 ( *unto + della Faccia+ T1S(140(' ( *unto + della Faccia+ +1(,0'(' ) } ( Faccia1 { Faccia1-linea+ ( *unto + della Faccia1 4T1(4'(' ( *unto 1 della Faccia1 11.(0,-(' ) ( Faccia1-linea1 ( *unto + della Faccia1 1--(4S+(' ( *unto 1 della Faccia1 11.(0,-(' ) ( Faccia1-linea4 ( *unto + della Faccia1 4T1(4'('
:::...
:::...
( *unto + della Faccia1 ) } ( Faccia4 { Faccia4-linea+ ( *unto + della Faccia4 ( *unto 1 della Faccia4 ) ( Faccia4-linea1 ( *unto + della Faccia4 ( *unto 1 della Faccia4 ) ( Faccia4-linea4 ( *unto + della Faccia4 ( *unto + della Faccia4 ) } ( Faccia. { Faccia.-linea+ ( *unto + della Faccia. ( *unto 1 della Faccia. ) ( Faccia.-linea1 ( *unto + della Faccia. ( *unto 1 della Faccia. ) ( Faccia.-linea4 ( *unto + della Faccia. ( *unto + della Faccia. ) } ( Faccia0 { Faccia0-linea+ ( *unto + della Faccia0 ( *unto 1 della Faccia0 ) ( Faccia0-linea1 ( *unto + della Faccia0 ( *unto 1 della Faccia0 ) ( Faccia0-linea4 ( *unto + della Faccia0 ( *unto + della Faccia0 ) } C 1--(4S+('
:::...
+4,(T'1(' TT'(,40('
S.4(,1+(' TT'(,40('
+4,(T'1(' S.4(,1+('
0+S(S+.(' .1,(1+'('
,-,(TS'(' .1,(1+'('
0+S(S+.(' ,-,(TS'('
+01(SS4(' T1T(+'+('
S0+(-S+(' T1T(+'+('
+01(SS4(' S0+(-S+('
:::...
:::...
*ietro Castellucci *ro9ate a mettere la costante %FMG?> a .''' e ad eseguire il programma& Come a9ete 9isto abbiamo tante strutture dati in ;a9a&util( descri9erle tutte sarebbe un la9oraccio& /a cosa c#e 9i de9e interessare X c#e tutte bene o male #anno metodi per inserire( togliere( recuperare e metodi per gestire la struttura stessa& /e strutture dati implementate sono tabelle #as#( liste( pile( code( alberi eccQ e a seconda della 9ostra esigenza ne userete una o l)altra( per i dettagli per] 9i consiglio di 9edere la documentazione del Da9a @e9elopment ait( do9e sono descritte tutte =ueste classi& *er ora 9i basti sapere c#e le tabelle #as# sono 9elocissime nella ricerca di un oggetto( tipicamente basta un solo accesso alla struttura dati per beccare l)oggetto cercato& /e liste sono come i 9ettori( gli oggetti sono legati tra di loro( e da un oggetto X possibile raggiungere il seguente( o il precedente o tutti e due( a seconda della realizzazione della lista& /e *ile sono selle liste particolari( do9e gli oggetti 9engono inseriti sempre in testa alla struttura( e da =ui 9engono prele9ati( =uindi nella pila l)ultimo oggetto entrato X il primo ad uscire( immaginate gli oggetti come delle pratic#e da sbrigare da un u55icio( esse 9engono poste in ordine di come arri9ano sulla scri9ania dell)addetto( una sull)altra& /)addetto alle pratic#e prende sempre la pratica in testa alla pila e la elabora& Ruesta pu] sembrare una struttura dati stupida( ma 9i assicuro c#e X la struttura dati piV importante di tutte( essa X utilizzata da tutti i linguaggi di programmazione per la c#iamata di 5unzioni e di procedure (anc#e Da9a la usa per l)in9ocazione di dei metodi)( per il passaggio dei parametri e il recupero dei risultati( e senza di =uesta struttura sarebbe impossibile programmare in modo ricorsi9o( il =uale X un modo di programmare molto potente& /e code 5unzionano in9ece al contrario( sono paragonabili alle code in banca( gli oggetti sono le persone c#e 5anno la 5ila allo sportello( esse arri9ano e si mettono alla 5ine della 5ila( intanto l)operatore ser9e le persone c#e sono in testa alla 5ila( anc#e =uesta struttura X importantissima( essa e alcune sue 9arianti (le code a priorit( do9e gli oggetti entrano con una priorit( ed in base a =uesta 9engono ser9iti( o99ero saltano la 5ila) sono molto usate nei sistemi operati9i come Pindo!s( /inu8( Fni8( eccetera( ad esempio per gestire le ric#ieste di stampa 9erso una sola stampante da parte di tutti gli utenti del sistema& *rima di passare al prossimo pacAage per] 9oglio 5ar9i 9edere un piccolo paragone sulla ricerca di un oggetto tra tanti oggetti( racc#iusi in strutture di9erse( in particolare in strutture di tipo 9ettore e di tipo tabelle #as#& 3edremo come le per5ormances della ricerca cambiano in modo e9idente al crescere delle dimensioni delle strutture& Immaginiamo degli oggetti 5atti cos_L class > { String nome ne! String(); int 9alore; public >(String a( int 9) { nome a; 9alore 9; } } Creiamo un 9ettore di +''''' di =uesti elementi( ne cerc#iamo uno e 9ediamo =uanto tempo impieg#iamoL import ;a9a&util&6; class > { String nome ne! String(); int 9alore; public >(String a( int 9) { nome a; 9alore 9; } }
:::...
:::...
public class ?9ettore { public static int %FMG?> +''''';
public static 9oid main (StringBC s) { 3ector 3 ne! 3ector(%FMG?>);
int numnome +1T-0S; > >K4'''' null; S<stem&out&println($Henero il 9ettore( inserisco $E%FMG?>E$ oggetti di tipo > con 9alori scorrelati rispetto all)indice&$); S<stem&out&print($InizioL >K$Enumnome); 5or (int i '; i[ %FMG?>;iEE) { > tmp ne! >($>K$Enumnome(numnome); 4'''') >K4'''' tmp;
i5 (numnome numnome--; 3&add(i(tmp);
}; S<stem&out&println($ FineL >K$Enumnome); S<stem&out&println($Inizio la ricerca di >K4''''$); long Inizio S<stem&current2imeMillis(); int inde8 3&inde8>5(>K4''''); > tmp (> ) 3&get(inde8); long Fine S<stem&current2imeMillis(); S<stem&out&println($>ggetto >K4'''' tro9ato in $E(Fine-Inizio)E$ millisec& all)indice $Einde8); S<stem&out&println($Gsso 9aleLJn%omeL$Etmp&nomeE$Jn3aloreL$Etmp&9aloreE$Jn$); } } Il programma cerc#er l)oggetto >K4''''( l)output del programma XL Henero il 9ettore( inserisco +''''' oggetti di tipo > con 9alori scorrelati rispetto all)indice& InizioL >K+1T-0S FineL >K1T-0S Inizio la ricerca di >K4'''' >ggetto >K4'''' tro9ato in 0' millisec& Q&& Adesso 5accio la stessa cosa( usando per] come struttura una tabella #as#L import ;a9a&util&6; class >
:::...
{ String nome ne! String(); int 9alore; public >(String a( int 9) { nome a; 9alore 9; } }
:::...
public class ?#as# { public static int %FMG?> +''''';
public static 9oid main (StringBC s) { Uas#table U ne! Uas#table(%FMG?>E+);
int numnome +1T-0S; > >K4'''' null; S<stem&out&println($Henero la tabella( inserisco $E%FMG?>E$ oggetti di tipo >&$); S<stem&out&print($InizioL >K$Enumnome); 5or (int i '; i[ %FMG?>;iEE) { > tmp ne! >($>K$Enumnome(numnome); 4'''') >K4'''' tmp;
i5 (numnome numnome--;
U&put(tmp(tmp); }; S<stem&out&println($ Fine >K$Enumnome); S<stem&out&println($Inizio la ricerca di >K4''''$); long Inizio S<stem&current2imeMillis(); > tmp (> ) U&get(>K4''''); long Fine S<stem&current2imeMillis(); S<stem&out&println($>ggetto >K4'''' tro9ato in $E(Fine-Inizio)E$ millisec& $); S<stem&out&println($Gsso 9aleLJn%omeL$Etmp&nomeE$Jn3aloreL$Etmp&9aloreE$Jn$); } }
:::...
:::...
Ancora una 9olta il programma cerc#er l)oggetto >K4''''( l)output del programma =uesta 9olta XL Henero il 9ettore( inserisco +''''' oggetti di tipo >& InizioL >K+1T-0S FineL >K1T-0S Inizio la ricerca di >K4'''' >ggetto >K4'''' tro9ato in ' millisec& Q&& Il pacAage ;a9a&util non comprende solo =ueste utilissime strutture dati( esso comprende anc#e delle classi per 5acilitare la gestione di date e orari( per l)interazionalizzazione( ed altre classi di utilit( come lo string toAenizer( c#e prende da una stringa tutte le parole( e dei generatori di numeri casuali&
LEZIONE 13:
In =uesta lezione 9edremo la parte di ;a9a&util c#e tratta gli utilissimi 5ile &zip e i &;ar Iniziamo a 9eder ;a9a&util&zip I 5ile &zip sono degli arc#i9i c#e contengono dei 5ile compressi( essi sono molto usati per scambiare dati in internet perc#` ne riducono anc#e note9olmante le dimensioni& Gsistono 9ari tipi di 5ile compressi( e 9ari programmi per comprimere e decomprimere i dati( si pensi agli arc#i9i ?A?( ai CA: di Pindo!s( agli A?D& Ruesto pacAage ci da la possibilit di trattare dati compressi secondo gli standard OI* e HOI*( c#e usano l)algoritmo di compressione c#iamato @GF/A2G( in =uesto pacAage tro9iamo anc#e utilit< per controllare i codici c#ecAsum C?C-41 e Adler-41 di un arbitrario stream di ingresso& *erc#` usare =uesto pacAage( i moti9i sono tanti( innanzitutto i programmi Da9a c#e includono immagini( animazioni e suoni possono essere 9eramente molto grandi( ed X possibile creare un 5ile &OI* con tutti i 5ile necessari al 5unzionamento del programma( in modo da ridurne le dimensioni( per] cos_ 5acendo per essere utilizzati dal programma de9ono essere prima scompattati( =uesto pacAage da =uesta possibilit& Fn ) altro semplice moti9o per usare =uesto pacAage X c#e la compressione di dati in in5ormatica X un problema abbastanza complesso( 9engono usati degli algoritmi c#e si basano sull)algebra dei gruppi( materia non molto conosciuta al di 5uori delle uni9ersit scienti5ic#e( sono =uindi degli algoritmi abbastanza incomprensibili a c#i non X $del mestiere$( =uesto pacAage da la possibilit a c#iun=ue di comprimere e decomprimere =uesti dati& 3ediamo =uindi cosa contiene il pacAage ;a9a&util&zip Interfacce C#ecAsum( X un inter5accia c#e rappresenta il codice c#ecAsum dei dati& Classi C#ecAedInputStream( X uno stream di ingresso c#e tratta anc#e il c#ecAsum dei dati in ingresso& C#ecAed>utputStream( X uno stream di uscita c#e tratta anc#e il c#ecAsum dei dati in uscita& C?C41( classe usata per calcolare il codice c#ecAsum di tipo C?C-41 di uno stream di dati& @e5later( classe c#e si occupa della compressionedei dati usando la compressione secondo la libreria O/I:& @e5later>utputStream( stream di uscita c#e comprime i dati usando l)algoritmo @e5late& HOI*InputStream( 5iltro per lo stream di ingresso per leggere dati compressi secondo il 5ormato HOI*& HOI*>utputStream( 5iltro per lo stream di uscita per scri9ere dati zippati usando HOI*& In5later( supporto per la compressione di tipo O/I:& In5laterInputStream( 5iltro per stream di ingresso( per decomprimere dati compressi secondo l)algoritmo @e5late& OipGntr<( usata per rappresentare un 5ile di ingresso di tipo OI*& OipFile( usata per leggere il contenuto di un 5ile OI*& OipInputStream( usata per leggere i 5ile contenuti in un arc#i9io OI*& Oip>utputStream( usata per scri9ere dati compressi in 5ormato OI*& Eccezioni @ataFormatG8ception( errore di 5ormato dei dati& OipG8ception >gnuna di =ueste classi a9r i suoi metodi( per conoscerli tutti 9i rimando alla documentazione del D@a( noi ne 9ediamo alcuni in un piccolo esempio& Il seguente programma apre la director< in cui si tro9a e cerca tutti i 5ile &zip( per ogni 5ile tro9ato ne 9a 9edere il contenuto&
Il package java.util
:::...
import ;a9a&util&6; import ;a9a&util&zip&6; import ;a9a&io&6; public class ?eadOip { public static 9oid main(String BC a) { File dir ne! File($&$); S<stem&out&println($Apro la director< $Edir&getAbsolute*at#()); FileBC cont dir&listFiles(); int MAM cont&lengt#; 5or (int i '; i { String tmp contBiC&get%ame(); i5 ((tmp&endsPit#($&zip$))II(tmp&endsPit#($&OI*$))) { "" X un 5ile &zip S<stem&out&println($Uo tro9ato $Etmp); controllaOip(contBiC); }; } } public static 9oid controllaOip(File 5) { S<stem&out&println($Contenuto del 5ile $E5&get%ame()); OipFile O5; tr< {O5 ne! OipFile(5);} catc# (OipG8ception e){O5 null;} catc# (I>G8ception e+){O5 null;} ; Gnumeration 5iles O5&entries(); !#ile(5iles&#asMoreGlements()) S<stem&out&println(5iles&ne8tGlement()); } }
:::...
*ossiamo anc#e decomprimere =uesti 5iles(il seguente programma prende tutti i &zip della director< do9e 9iene eseguito e li decomprime& import ;a9a&util&6; import ;a9a&util&zip&6; import ;a9a&io&6;
:::...
:::...
public class @ecomp { public static 9oid main(String BC a) { File dir ne! File($&$); S<stem&out&println($Apro la director< $Edir&getAbsolute*at#()); FileBC cont dir&listFiles(); int MAM cont&lengt#; 5or (int i '; i[MAM; iEE) { String tmp contBiC&get%ame(); i5 ((tmp&endsPit#($&zip$))II(tmp&endsPit#($&OI*$))) { "" X un 5ile &zip S<stem&out&println($Uo tro9ato $Etmp); tr< {controllaOip(contBiC);} catc# (I>G8ception e){}; }; } } public static 9oid controllaOip(File 5) t#ro!s I>G8ception { S<stem&out&println($@ecompressione del 5ile $E5&get%ame()E$L$); OipFile O5; tr< {O5 ne! OipFile(5);} catc# (OipG8ception e){O5 null;} catc# (I>G8ception e+){O5 null;} ; Gnumeration 5iles O5&entries(); !#ile(5iles&#asMoreGlements()) { OipGntr< tmpFile (OipGntr< ) 5iles&ne8tGlement(); S<stem&out&println($decomprimo il 5ile $EtmpFile&get%ame()); S<stem&out&println($dimensione compresso $E tmpFile&getCompressedSize()E$ dimensione non compresso $E tmpFile&getSize()E$ C?C $EtmpFile&getCrc()); S<stem&out&println($modi5icato $EtmpFile&get2ime()); InputStream in O5&getInputStream(tmpFile); File>utputStream out ne! File>utputStream(tmpFile&get%ame()); 5or (int c# in&read();c#W -+;c# in&read()) out&!rite(c#);
:::...
:::...
out&close(); in&close(); } } } Il pacAage ;a9a&util&;ar mette a disposizione del programmatore delle classi e inter5acce per trattare i 5ile di tipo Da9a Arc#i9e (DA?)( in particolare X possibile leggerli( e scri9erli& I 5ile DA? sono basati sullo standard OI*( con un 5ile opzionale detto mani5est & Il contenuto del pacAage X il seguenteL Classi Attributes Attributes&%ame DarGntr< DarFile DarInputStream Dar>utputStream Mani5est Eccezioni DarG8ception ?imando alla documentazione del D@a per ulteriori in5ormazioni&
LEZIONE 14:
Il Package java.net
Il package java.net
Da9a( come gi detto in precedenza X nato come linguaggio per la rete( solo successi9amente X di9enuto un 9ero e proprio linguaggio di programmazione& Il suo ruolo di leader per la programmazione di rete X comun=ue indiscusso( come tale esso mette a disposizione del programmatore tutto 9ari pacAage per e55ettuare tale programmazione& 3isto c#e lo scopo 5inale del corso X =uello di programmare Applet( una in5arinatura del pacAage la dobbiamo a9ere& Il pacAage X molto ampio( il suo contenuto X il seguenteL Interfacce ContentUandlerFactor< File%ameMap SocAetImplFactor< SocAet>ptions F?/StreamUandlerFactor< Classi Aut#enticator ContentUandler @atagram*acAet @atagramSocAet @atagramSocAetImpl UttpF?/Connection InetAddress DarF?/Connection MulticastSocAet %et*ermission *ass!ordAut#entication Ser9erSocAet SocAet SocAetImpl
:::...
SocAet*ermission F?/ F?/Class/oader F?/Connection F?/@ecoder F?/Gncoder F?/StreamUandler Eccezioni :indG8ception ConnectG8ception Mal5ormedF?/G8ception %o?oute2oUostG8ception *rotocolG8ception SocAetG8ception FnAno!nUostG8ception FnAno!nSer9iceG8ception
:::...
@i =ueste noi ne 9edremo solo alcune( iniziamo intanto a 9edere cosa succede nella rete& I computer in Internet comunicano scambiandosi pacc#etti di dati( c#iamati pacc#etti I* (Internet *rotocol)( =uesti pacc#etti partono da un computer( attra9ersano 9ari nodi della rete (Ser9er di rete) e arri9ano a destinazione( per stabilire il percorso intermedio tra i due computer c#e 9ogliono comunicare si esegue un algoritmo di routing (ne esistono di 9ari tipi( a seconda delle esigenze e a seconda del tipo di rete)& *er stabilire il mittente di una comunicazione( i destinatari( i nodi intermedi occorre c#e ogni computer collegato in rete abbia un nome c#e lo identi5ica uni9ocamente( =uesto nome( X un numero( e si c#iama indirizzo I*& /)indirizzo I* X un numero di 41 bit( c#e pu] essere scritto in 9ari 5ormati( ma il piV usato X il 5ormato decimale separato da punti( un indirizzo I* X ad esempio 0,.& 1.&++.&.S1 (Il numero X un numero a caso)& Siccome i computer ricordano bene i numeri( ma noi umani no( sono stati in9entati i @%S (@omain %ame S<stem) c#e associano dei nomi a =uesti indirizzi I*& /a prima classe c#e 9ediamo del pacAage X la classe InetAddres( la =uale gestisce =uesti indirizzi I*& /a classe #a 9ai metodi( tra i =uali uno c#e restituisce gli indirizzi Ip del computer sul =uale si la9ora( uno c#e dato un nome di dominio ne da l)indirizzo I*& Il seguente esempio ne mostra l)uso& import ;a9a&net&6; public class IndirizziI* { public static 9oid main(String BC a) { String dom $de9eloper&;a9a&sun&com$; tr< { InetAddress loc InetAddress&get:<%ame(dom); S<stem&out&println($I* di $EdomE$ L $Eloc&getUostAddress()); } catc# (FnAno!nUostG8ception e) {S<stem&out&println($%on esiste il dominio $Edom);}; tr< { InetAddress loc InetAddress&get/ocalUost(); S<stem&out&println($I* localeL $Eloc&getUostAddress()); S<stem&out&println($%ome locale$Eloc&getUost%ame()); } catc# (FnAno!nUostG8ception e) {}; } } Come esercizio pro9are a 5ar prendere come nome di dominio il primo argomento del programma( ad esempio ;a9a IndirizziI* #tml&it
:::...
:::...
Il pacAage 5ornisce utili classi per trattare i socAet 5ondamentali basati su 2C* e su F@*( i =uali sono i protocolli impiegati nella maggior parte delle applicazioni Internet& %oi =ueste non le 9edremo( ma passiamo direttamente a classi c#e gestiscono applicazioni Peb di li9ello piV alto& 3ediamo la classe F?/& C#e cos)X un F?/\ Fn F?/( o Fni5orm ?esource /ocator( X un puntatore ad una risorsa !eb& Fn arisorsa !eb pu] essere =ualsiasi cosa( una director<( un 5ile( un oggetto in rete come ad esempio una inter5accia per 5are delle =uer< ad un database remoto( o per un motore di ricerca& Hli F?/ sono s9ariati( ognuno con un protocollo di9erso( ma i piV usati sono =uelli c#e usano protocolli U22* (U<per2e8t 2rans5er *rotocol) e F2* (File 2rans5er *rotocol)& /a classe F?/ incapsula degli oggetti !eb( accedendo9i tramite il loro indirzzo F?/& A 9oi c#e siete utenti di Utml&it non sto a stressar9i con c#iacc#iere sul 5ormato degli indirizzi F?/ del tipo #ttpL""!!!&cli&di&unipi&it"ccastellu"inde8&#tml e c#e l)inde8&#tml X 5acoltati9o( o99ero l)indirizzo url #ttpL""!!!&cli&di&unipi&it"ccastellu X e=ui9alente al precedente( c#e ccastellu X una director< c#e si tro9a sul ser9er( e c#e l)indirizzo del ser9er X identi5icato da #ttpL""!!!&cli&di&unipi&it & *er] 9i dico c#e a di55erenza dei !eb bro!ser( l)#ttpL"" da9anti all)indirizzo X indispensabile( perc#` indi9idua il protocollo dell)F?/( protocollo c#e il %a9igator e l)G8plorer intuiscono anc#e se omesso& Ruando programmeremo gli applet useremo solo gli F?/ per accedere anc#e ai 5ile locali( 9edendoli come risorse di rete& Ruesto lo 5aremo perc#` negli applet X 9ietato usare i 5ile( per moti9i di sicurezza di rete( =uindi per leggere un 5ile bisogna 9ederlo come una risorsa di rete& /e ultime 9ersioni di Da9a stanno eliminando =uesta limitazione del linguaggio( usando delle 5irme( c#e rendono la lettura e la scrittura di 5ile controllata anc#e sulla rete( =uindi in 5uturo sar possibile usare anc#e i 5ile negli applet( a patto c#e ci si assuma =ualc#e responsabilit& 3ediamo alcuni costruttori di oggetti F?/L F?/(String spec) ( crea ul oggetto F?/ in base alla rappresentazione a stringa( ad esempio $#tml&it$ F?/(String protocol( String #ost( int port( String 5ile)( crea un oggetto F?/( speci5icando tutto( anc#e la porta& F?/(String protocol( String #ost( int port( String 5ile( F?/StreamUandler #andler)( come il precedente( solo c#e speci5ica anc#e l)F?/StreamUandler( il =uale X la superclasse comune per tutti i protocolli (U22*(F2*(Hop#er)& F?/(String protocol( String #ost( String 5ile)( crea un oggetto F?/ speci5icando protocollo( #ost e File sul ser9er #ost( ad esempioL F?/($#ttp$($!!!&cli&di&unipi&it$($ccastellu"inde8&#tml$)& @iscutiamo ora alcuni metodi della classe boolean e=uals(>b;ect ob;)( con5ronta due oggetti F?/& >b;ect getContent()( da il contenuto dell)oggetto F?/& String getFile()( da il 5ilename dell)F?/& String getUost()( l)#ost int get*ort()( il numero della porta String get*rotocol()( il nome del protocollo& String get?e5()( da il puntatore all)F?/& int #as#Code()( da il codica #as# dell)oggetto& F?/Connection openConnection()( apre una connessione con l)oggetto remoto indicato dall)F?/& InputStream openStream()( apre una connessione con l)oggetto !eb indicato dall)url sotto 5orma di stream in lettura& String toG8ternalForm()( da una stringa rappresentante l)F?/& String toString()( da una rappresentazione dell)oggetto F?/& Gcco di seguito un piccolo esempio sull)uso della classe F?/& import ;a9a&net&6; import ;a9a&io&6; public class get*age { public static 9oid main(StringBC arg) { String un; tr< {un argB'C;} catc# (Arra<Inde8>ut>5:oundsG8ception e) { un $#ttpL""!!!&#tml&it"inde8&asp$; S<stem&out&println($%essun F?/ de5inito( prendo $Eun);
:::...
}; S<stem&out&println($F?/L$Eun); F?/ url; boolean pippo 5alse; tr< {url ne! F?/(un);} catc# (Mal5ormedF?/G8ception e) { S<stem&out&println($F?/ errato( prendo #ttpL""!!!&#tml&it"inde8&asp $); url null;
:::...
pippo true; }; i5 (pippo) tr< {url ne! F?/ ($#ttpL""!!!&#tml&it"inde8&asp $);} catc# (Mal5ormedF?/G8ception e){}; :u55ered?eader stream; tr< {stream ne! :u55ered?eader (ne! InputStream?eader (url&openStream()));} catc# (I>G8ception e){ S<stem&out&println($Grrore di apertura del 5ile$); stream null; S<stem&e8it('); }; File out ne! File($&JJ$Eurl&getFile()); FilePriter >utput; tr< {>utput ne! FilePriter(out);} catc# (I>G8ception e) {>utput null;}; String l; tr< { !#ile ((l stream&read/ine())W null) { >utput&!rite(l); }; >utput&5lus#(); >utput&close(); } catc# (I>G8ception e){S<stem&out&println($Grrore di lettura&$);}; } } Il programma prende un url dai parametri d)ingresso( se non X 9alido o non ci sono parametri apre per de5ault l)url #ttpL""#tml&it"inde8&asp ( prele9a la pagina letta e la sal9a su disco& Come 9edete =uesto X una specie di !eb bro!ser( basterebbe un po di gra5ica e si potrebbe anc#e 9isualizzare la pagina& *ro9ate ad eseguire il programma mettendo i seguenti indirizziL
:::...
;a9a get*age #ttpL""!!!&cli&di&unipi&it"ccastellu"inde8&#tm ;a9a get*age #ttpL""!!!&cli&di&unipi&it"ccastellu"pietro+&#tm ;a9a get*age #ttpL""!!!&cli&di&unipi&it"ccastellu"c#isono&#tm e semplicemente ;a9a get*age( e 9edete i risultati&
:::...
LEZIONE 15:
In =uesto capitolo abbiamo 9isto alcuni pacAage contenenti le A*I del linguaggio Da9a( ma ce ne sono degli altriL ;a9a&applet ( c#e 9edremo nel prossimo capitolo( il =uale ser9e per creare dei programmi c#e girano sui !eb bro!sers( c#iamati applet& ;a9a&a!t ( =uesto pacAage e i suoi sottopacAages implementano le classi per implementare i controlli HFI( per implementare inter5acce gra5ic#e( oltre agli strumenti per il disegno( manipolazione di immagini( stampa e altre 5unzionalit& Inizieremo a 9ederlo nel prossimo capitolo ;a9a&beans( pacAage c#e permette di de5inire componenti Da9a e di utilizzarli in altri programmi& ;a9a&rmi( pacAage per l)in9ocazione di metodi remoti( o99ero di metodi di oggetti c#e si tro9ano o9un=ue sulla rete( per costruire delle applicazioni distribuite& ;a9a&securit<( ci sono classi c#e implementano le 5unzioni di sicurezza( come ad esempio classi utilizzate per crttogra5are documenti prima di mandarli in rete& ;a9a&s=l( inter5accia tra il linguaggio Da9a e il linguaggio per basi di dati SR/& ;a9a&te8t( classi molto utili per l)interazionalizzazione& ;a9a8&accessibilit<( classi c#e supportano tecnologie a sostegno degli utenti disabili& ;a9a8&s!ing( X un estensione di ;a9a&a!t( per costruire applets e applicazioni gra5ic#e X un portento& org&omg&C>?:A( permette di inter5acciare il linguaggio Da9a con il linguaggio C>?:A& Ancora una 9olta 9i in9ito per saperne di piV a controllare la documantazione del D@a( disponibile >n line( sia per essere scaricata c#e per essere consultata presso il sito della Sun Micros<stem !!!&sun&com & Ruesti sono i pacAage standard del linguaggio Da9a( a =uesti si aggiungono le estensioni standard del linguaggio& /e estensioni standard sono dei pacAage c#e nelle prossime 9ersioni di ;a9a di9enteranno pacAage standard( e c#e per ora sono 9ersioni beta& S!ing X stata una estensione 5ino all)uscita di Da9a1( ora di 5atto X piV utilizzata delle 9ecc#ie a!t& API Servlet( X destinata alla programmazione di applicazioni ser9er in Da9a& Ruesta A*I X costituita dai pacAages ;a9a8&ser9let e ;a9a8&ser9let&#ttp& Java 3D( gestisce il disegno tridimensionale( X come la 9ersione Da9a di >penH/ (Da9aH/)( la 5amosissima libreria della SHI (alcuni la conoscono come Hlide( o99ero la libreria >penH/ per le 4@58) e @irectM della Microso5t& Si pu] scaricare al sitoL #ttpL"";a9a&sun&com"products";a9a-media"4@"inde8&#tml Java Media Frame ork( gestisce all)interno dei programmi Da9a 9ari 5ormati audio( 9ideo e multimediali( i 5ile supportati sono i seguentiL &mo9( &a9i( &9i9( &au( &ai55( &!a9( &midi( &rm5( &gsm( &mpg( &mp1( &rtp& Se non tutta( almenu una parte di9err standard con Da9a +&4( la =uale X in uscita (5ine Aprile)& Si scarica al sitoL #ttpL""!!!&;a9aso5t&com"products";a9a-media";5m"inde8&#tml S!eec"( 5unzioni di riconoscimento 9ocale( non solo per i comandi( ma X possibile anc#e editare interi 5ile& Ruesto pacAage 5a anc#e l)output 9ocale& Si pu] scaricare al sitoL #ttpL"";a9a&sun&com"products";a9a-media"speec#"inde8&#tml #ele!"on$( 5unzioni di tele5onia( 5a8& JavaMail( classi per gestire la posta elettronica& Java %aming and Director$ Services( per accedere ai ser9izi di nomi e director< usando protocolli come /@A*& Ruesto pacAages X di9entato standard in D@a +&4 Java Management( per la gestione di reti locali&
conclusioni sui package
:::...
JavaS!aces( ulteriori classi per la creazione di applicazioni distribuite& JavaCommerce( per il commercio elettronico&
:::...
*ersonalmente non 9edo l)ora c#e di9entino standard le A*I Da9a 4@( Da9a Media Frame!orA( Da9aSpeec# e Da9a 2elep#on<( parc#X le 5unzionalit promesse da =ueste A*I sono 9eramente eccezionali& Fsarle adesso X possibile( ma a proprio risc#io e pericolo( in5atti esse sono ancora delle 9ersioni beta( e =uindi piene di errori( inoltre se si 9ogliono scri9ere degli applet usando =ueste nuo9e 5unzionalit X possibile( ma per mandarle in esecuzione occorre l)applet9ie!er del D@a( perc#` sicuramente il Da9a implementato nei !eb bro!ser ancora non le supporta& Si pensi c#e S!ing X di9enuto un pacAage standard del linguaggio( ma ancora esistono dei bro!ser c#e non lo supportano&
LEZIONE 16:
Gccoci 5inalmente arri9ati alla programmazione di inter5acce gra5ic#e( =uindi alla creazione di applet e di applicazioni a 5inestre& Cerc#iamo innanzittutto di stabilire cosa X una inter5accia( e cosa signi5ica 5arla gra5ica& Innanzitutto ogni programma( come gi detto( pu] essere 9isto come un oggetto c#e calcola una 5unzione( =uindi c#e prende dei dati dall)esterno e restituisce dei risultati& Si pensi ad esempio ad un semplice programma c#e 5a la somma tra due numeri& Il programma in =uestione prender in input due numeri e restituir come output un un numero( c#e rappresenta la somma dei primi due& Ruanto detto X 9alido in generale per tutte le applicazioni( e non X un caso particolare dell)esempio precedente& Si pensi ad un 9ideogioco( l)input sar dato dal ;o<sticA( e l)output sar la gra5ica sullo sc#ermo( =uindi concettualmente sia il 9ideogioco( c#e il programma somma( c#e =ualsiasi altro programma un programmatore possa in9entarsi( sono delle 5unzioni calcolate su dei dati in ingresso c#e restituiscono dei risultati& /)inter5accia del programma 9erso l)utente c#e lo usa X il modo in cui il programma prende i dati dall)utente e gli restituisce i risultati& Fino ad ora abbiamo 9isto delle inter5acce testuali( o99ero nel caso della somma dei due numeri( i dati 9eni9ano presi sallo standard input( con una S<stem&in&read() e i risultati 9eni9ano stampati sullo standard output con una S<stem&out&print()& /e S<stem&in e out rappresentano una inter5accia del programma 9erso l)esterno( in =uesto caso 9erso l)utente& Altre inter5acce con l)esterno c#e abbiamo gi esaminato sono i 5iles( essi rappresentano delle inter5acce di ingresso o di uscita 9erso utenti o altri programmi& Facendo un piccolo paragone( neanc#e tanto impossibile( tra un programma e l)uomo( possiamo dire c#e l)inter5accia in ingresso della mente X rappresentata dalla 9ista( il tatto( il gusto( l)udito e l)ol5atto( mentre l)inter5accia in uscita X rappresentata dalla parola e dal mo9imento dei muscoli& @a notare c#e =uesta non X una cosa stranissima( in5atti i robot( anc#e se non #anno gli stessi canali di ingresso degli uomini (#anno 9ista( una specie di tatto( =ualcosa c#e segnala la prossimit) e di uscita (spesso non parlano( al posto dei muscoli #anno motori elettrici collegati a bracci meccanici( pinze( ecc&&&)( #anno lo stesso 5unzionamento dell)uomo( o99ero compiono delle azioni (danno un output) in conseguenza a degli stimoli (segnali di input)( anc#e se l)uomo X molto piV complesso grazie alla capacit di pensiero( c#e ancora l)intelligenza arti5iciale non riesce a replicare in pieno (in5atti un robot non X capace di prendere una decisione senza conoscere solo delle in5ormazioni parziali di un problema( come X in grado di 5are l)uomo( in base a supposizioni( a 9olte coscienza( eccQ)& Ruindi l)inter5accia X composta da tutti =uei canali da cui un programma prende in5ormazioni e 9erso le =uali sputa 5uori dei risultati& Alcuni dati di ingresso ser9ono a 5are cambiare solo stato al programma( altri in9ece inducono immediatamente un output& %oi li cosideriamo tutti dati su cui 9engono calcolate 5unzioni( in5atti una 5unzione 9iene calcolata anc#e in base allo stato di un programma( e =uindi anc#e lo stato( e di conseguenza l)input c#e lo #a causato( X un input della 5unzione& C#iarisco =uesto discorso con un esempio& *ensiamo ad un programma c#e calcola due 5unzioni( una di somma e una di sottrazione tra due numeri( e pensiamo ad un input c#e prende un numero per scegliere uno stato (+ o 1)( e poi due numeri& A =uesti due numeri 9iene applicata la 5unzione somma o la 5unzione sottrazione a seconda dello stato del programma& Ad esempioL I%*F2L [+(+'(+'7 >F2*F2L 1' I%*F2L[1(+'(+'7 >F2*F2L '
Interfacce grafiche ed eventi
:::...
:::...
3edete nell)esempio( come anc#e l)input sullo stato 9iene in de5initi9a usato per calcolare l)output& Ruello c#e interessa a noi X l)inter5accia utente( abbiamo 9isto in5atti come i programmi possono inter5acciarsi con altri programmi o con peri5eric#e (in9iando ad esempio comandi ad una stampante)( a noi =uesto non interessa( ma ci interessa 9edere tutto =uello c#e ser9e al programma per dialogare con l)utente( o99ero la cosiddetta inter5accia utente& In particolare ci interessa 9edere l)inter5accia gra5ica del programma( o99ero =uell)inter5accia c#e rende molto grade9ole il programma all)utente( al posto della grigia inter5accia a caratteri c#e abbiamo 9isto& /)inter5accia gra5ica del programma X composta dai cosiddetti componenti HFI (Hrap#ics Fser Inter5ace)( essi sono dei componenti c#e ser9ono per l)input o per l)output( ed #anno un aspetto gra5ico& Sono ad esempio dei componenti HFI di un programma tutti i menV( i bottoni( le label( ecceteraQdi =uesto& 2utte =ueste HFI saranno o99iamente collegate ad una struttura c#e le contiene( le due strutture c#e 9edremo( e c#e sono le piV importanti( sono gli applet e le 5inestre& >gni HFI X =uindi un pezzettino di inter5accia gra5ica( essi rice9ono degli e9enti e in base a =uesti danno dei risultati& Si pensi ad un bottone( esso pu] essere cliccato e rilasciato( =uando un utente programma una inter5accia gra5ica c#e contiene un bottone do9r gestire anc#e gli e9enti associati a =uesto( o99ero do9r dire cosa succede =uando il bottone 9iene cliccato( =uando 9iene rilasciato( =uando ci si passa con il mouse sopra( eccetera& >gni di55erente HFI a9r un tipo di e9ento associato( alcuni sono automaticamente gestiti dalla classe c#e 9iene estesa per inserire il HFI nella 5inestra (ad esempio la modi5ica gra5ica del bottone cliccato c#e di9iene e9idenziato )( altri possono essere de5initi dall)utente (come il clicA di un bottone( se non c)X il gestore non succede niente) e altri ancora de9ono essere de5initi dall)utente (come tutti gli e9enti della tastiera =uando si 9uole ascoltare almeno uno di =uesti( ad esempio ci interessa il rilascio di un tasto( dobbiamo gestire anc#e la pressione( eccQ)& Ad ogni tipo di e9ento( per ogni tipo di componente HFI( de9e essere dic#iarato un ascoltatore dell)e9ento( esso X un programma c#e attende il 9eri5icarsi dell)e9ento sul componente( e =uando =uesto si 9eri5ica lo gestisce& /a programmazione di inter5acce gra5ic#e X =uindi di9ersa dalla usuale programmazione( in5atti =ui si disegnano le inter5acce( e poi si gestiscono gli e9enti c#e arri9ano( mentre nelle usuali applicazioni c)era un main( c#e rappresenta9a l)intero programma& /a gestione degli e9enti in Da9a X cambiata dalla 9ersione +( a Da9a 1 (D@a +&1 in sV)( noi 9edremo la nuo9a gestione degli e9enti( =uella di Da9a 1( perc#` la prima X stata cambiata in =uanto a 9olte capita9a c#e non si capi9a un e9ento a =uale componente era associato& %ella nostra 9isita ai componenti HFI 9edremo =uindi come de5inirli( inizializzarli( inserirli in una 5inestra o in un applet( e =uindi come gestirne gli e9enti& Come gi detto Da9a 1( #a due collezioni di pacAages per le inter5acce gra5ic#e( ;a9a&a!t( gi presente in Da9a +( e ;a9a8&s!ing( uscita con Da9a 1( costruita sulle AP2( c#e amplia alla grande le possibilit per le inter5acce gra5ic#e&
LEZIONE 17:
/)applicazione a 5inestre X l)applicazione c#e piV spesso usiamo =uando la9oriamo al computer( essa X una applicazione c#e 9iene eseguita in locale( c#e come inter5accia utente utilizza le tecnologia delle 5inestre( tipica dei sistemi operati9i Mac >S (su cui X nata)( Pindo!s (tutte le sue 9ariantiL Pindo!s 4&+( Pindo!s ,0( ,0->S?1( ,T( %2( 1''' e il 5uturo Millenium)( MPindo!s (il ser9er gra5ico per /inu8 e Fni8)& Ruasi tutti i programmi c#e 9engono usati attualmente sono applicazioni a 5inestre ad esempio lo sonoL Pord( %etscape( G8plorer( Dbuilder( 3isual Studio( PinOip( *aint( M3( eccQ (tutti prodotti appartenenti alle relati9e case produttrici)& 3ediamo =uindi come si crea una Finestra usando il pacAage AP2& Al solito creiamo una applicazione con il solito main( come abbiamo gi 5atto in precedenza& /a classe creata per]( =uesta 9olta( estender la classe ;a9a&a!t&Frame( la =uale rappresenta la 5inestra completa( comprendente il titolo( i bottoncini di riduci a icona( massimizza e c#iudi& /a classe Frame #a 9ari metodi e costruttori( c#e 9erdremo tra poco( per ora creiamo la nostra prima 5inestra con titolo *rima Finestra e c#e non contiene niente( la editiamo in Finestra&;a9a& import ;a9a&a!t&6; public class Finestra e8tends Frame { public Finestra() {
Cosa una applicazione a Finestre
:::...
super($*rima Finestra$); set/ocation(+''(+''); setSize(1''(+''); s#o!(); }
:::...
public static 9oid main(StringBC arg) { ne! Finestra(); S<stem&out&println($Uo creato la 5inestra$); } } All)inizio( come per ogni applicazione 9iene in9ocato il main( il =uale crea un nuo9o oggetto di tipo Finestra (il main e la 5inestra pote9ano stare in due 5ile separati( uno c#e gesti9a il main( e uno c#e gesti9a la 5inestra)& %el costruttore dell)oggetto 5inestra( 9iene in9ocato il costruttore della superclasse( o99ero di Frame( con la stringa $*rima Finestra$ (X il titolo)( 9iene in9ocato il metodo set/ocation c#e dic#iara la posizione dell)angolo destro in alto della 5inestra sul desAtop( in =uesto caso [+''( +''7 (Sono la 8 e la < rispetti9amente( la 8 si misura dal lato sinistro dello sc#ermo e cresce andando a destra( la < si misura dal lato in alto dello sc#ermo( e cresce andando 9erso il basso)& *oi si c#iama il metodo setSize( c#e permette di speci5icare larg#ezza e altezza della 5inestra( la nostra X larga 1'' e alta +''( e alla 5ine 9iene in9ocato il metodo s#o!()( c#e 5a apparire la 5inestra sullo sc#ermo&
%e coordinate dello schermo non sono coerenti con le usuali coordinate cartesiane, in effetti la esattamente l'opposta, cresce verso il *asso e diminuisce verso l'alto. .uesto un pro*lema che non solo Java ha, ma tutti i linguaggi di programmazione e tutte le li*rerie per la grafica Baster, dovuto a motivi credo storici, legati a come vengono disegnati i pi"el sullo schermo a livello hardware. -isogna a*ituarcisi, le prime volte per3 mi rendo conto che qualche pro*lema si incontra nel ragionare in questi termini. Drovate a compilare e ad eseguire il programma, e vedrete la vostra prima finestra prendere vita, provate poi ad eliminare a turno i metodi set%ocation, set:ize e show, provate anche a mettere la finestra in posizioni diverse e valutate i cam*iamenti. 6ell'esempio si vedono degli esempi di eventi gestiti automaticamente dal sistema, questi sono Ir Besize della finestra, e la pressione dei *ottoni riduci ad icona e massimizza &minimizza', i quali sono gestiti nella classe Rrame. 6on gestito invece l'evento chiudi della finestra &il *ottone con la "', se esso viene premuto non succede niente, per terminare l'esecuzione del programma *isogna andare sun prompt del dos dal quale stata lanciata l'applicazione e premere +!B%,+ &l'e"it per tutti i programmi (O:'. Infine, credo sia chiaro, l'applicazione non funziona in am*ienti non grafici, ovvero in (O: e in %inu", occorre 2indows &e il dos caricato in una finestra, ovvero prompt di msPdos' o 1windows con una shell aperta. (a notare che non vero che ad una applicazione associata una sola finestra, Java un linguaggio che
:::...
:::...
supporta la multiprogrammazione, ogni finestra un programma a se stante che gira in parallelo agli altri, quindi posso creare per la stessa applicazione pi) finestre Rrame, come nell'esempio che segue. import ;a9a&a!t&6; public class Finestre e8tends Frame { public Finestre(String %ome( int 8( int <) { super(%ome); set/ocation(8(<); setSize(1''(+''); s#o!(); }
public static 9oid main(StringBC arg) { S<stem&out&println($Creo . 5inestre so9rapposte$); 5or (int i +;i[0;iEE) ne! Finestre($Finestra $Ei(+'E(i6+')( +'E(i6+')); S<stem&out&println($Creo . 5inestre a scacc#iera$); 5or (int i 0;i[,;iEE) ne! Finestre($Finestra $Ei((i-0)61''( +''E(i-0)); S<stem&out&println($Uo creato le otto 5inestre$); } } /e stesse cose si pote9ano 5are estendendo la classe DFrame del pacAage ;a9a8&s!ing& import ;a9a8&s!ing&6; public class FinestraS!ing e8tends DFrame { public FinestraS!ing() { super($*rima Finestra$); set/ocation(+''(+''); setSize(1''(+''); s#o!(); }
public static 9oid main(StringBC arg) { ne! FinestraS!ing();
:::...
S<stem&out&println($Uo creato la 5inestra$); } }
:::...
.uesto programma come Rinestra.>ava. solo che estende JRrame di swing, le uniche differenze sono il contenuto della finestra, questa volta grigio, prima *ianco e il *ottone chiudi, che questa volta chiude la finestra &solo la finestra per3, non l'applicazione intera' In effetti l'utilizzo di swing e di awt molto simile, solo che swing pi) completo, esso mette a disposizione molte classi in pi), da la possi*ilit di cam*iare il loo$ delle finestre a runtime, e altro. Durtroppo non tutti i we* *rowser le supportano, noi quindi vedremo le awt, e poi discuteremo delle swing, fermo restando che chi vuole fare un applet per la propria pagina html (7/7 per ora usare le awt, tra non molto, quando l'1#% diverr uno standard di fatto, e quindi si dovranno cam*iare i *rowser, si potr utilizzare tranquillamente swing anche per gli applet. /ediamo quindi cosa contiene la classe Rrame, innanzitutto i costruttori sono due9 Frame() , che crea un Rrame senza nessun titolo, inizialmente invisi*ile. Frame(String 2), che crea un Rrame con titolo !, anch'esso inizialmente invisi*ile. =li attri'uti della cla!!e !ono: static int I+O6IRI7( static int 6OB#8% per indicare lo stato della finestra, e static int +BO::H8IBN+5B:OB static int (7R85%!N+5B:OB static int 7NB7:I`7N+5B:OB static int H86(N+5B:OB static int #O/7N+5B:OB static int 6NB7:I`7N+5B:OB static int 67NB7:I`7N+5B:OB static int 62NB7:I`7N+5B:OB static int :NB7:I`7N+5B:OB static int :7NB7:I`7N+5B:OB static int :2NB7:I`7N+5B:OB static int !71!N+5B:OB static int 2NB7:I`7N+5B:OB static int 28I!N+5B:OB tutti dichiarati deprecated, per i cursori, rimpiazzati dalla classe +ursor. 7redita gli allineamenti dei componenti da +omponent. I metodi sono9 9oid add%oti5<(), collega il frame ad una risorsa schermo, e lo rende visualizza*ile. int getCursor2<pe(), dichiarato (eprecated. 7' della versione <.< delle J(; static FrameBC getFrames(), da un arra contenente tutti i Rrames creati dall'applicazione. Image getIconImage(), da l'icona del Rrame, essa un oggetto di tipo Icon, che vedremo in seguito. Menu:ar getMenu:ar(), restituisce la *arra dei menu del frame, un oggetto di tipo #enu-ar, che vedremo tra non molto. int getState(), da lo stato del frame. String get2itle(), da il titolo del frame boolean is?esizable(), da true se il frame pu3 essere allargato e ristretto con il mouse. protected String paramString() , da la stringa contenente i parametri del Rrame. 9oid remo9e(MenuComponent m), toglie la #enu-ar specificata dal frame. 9oid remo9e%oti5<(), toglie la connessione tra il frame e la risorsa che rappresenta lo schermo, rendendolo invisualizza*ile. 9oid setCursor(int cursor2<pe), settava il cursore in J(;<.<, dichiarato deprecated. 9oid setIconImage(Image image), setta l'icona del Rrame. 9oid setMenu:ar(Menu:ar mb), assegna una #enu-ar al frame. 9oid set?esizable(boolean resizable), setta il Rrame ridimensiona*ile oppure no, per default lo . 9oid setState(int state), setta lo stato del frame
:::...
9oid set2itle(String title), setta il titolo del frame.
:::...
Rrame una classe che estende >ava.awt.2indow, e quindi ne eredita metodi e attri*uti. In effetti Rrame una 2indow con in pi) un *ordo e una #enu-ar. I metodi ereditati da window sono9 addPindo!/istener( appl<?esource:undle( appl<?esource:undle( dispose( getFocus>!ner( getInputConte8t( get/ocale( get>!nedPindo!s( get>!ner( get2oolAit( getParningString( isS#o!ing( pacA( postG9ent( processG9ent( processPindo!G9ent( remo9ePindo!/istener( s#o!( to:acA( toFront& Pindo! estende ;a9a&a!t&Container, esso un contenitore di oggetti 82!, un componente che pu3 contenere altri componenti., quindi per transitivit Rrame ne eredita metodi e attri*uti, i metodi sono9 add( add( add( add( add( addContainer/istener( addImpl( countComponents( deli9erG9ent( do/a<out( 5indComponentAt( 5indComponentAt( getAlignmentM( getAlignmentN( getComponent( getComponentAt( getComponentAt( getComponentCount( getComponents( getInsets( get/a<out( getMa8imumSize( getMinimumSize( get*re5erredSize( insets( in9alidate( isAncestor>5( la<out( list( list( locate( minimumSize( paint( paintComponents( pre5erredSize( print( printComponents( processContainerG9ent( remo9e( remo9e( remo9eAll( remo9eContainer/istener( setFont( set/a<out( update( 9alidate( 9alidate2ree +ontainer estende >ava.awt.+omponent, un +omponent un oggetto che ha una rappresentazione grafica, ad esempio un *ottone sar una estensione di questa classe, la quale estende a sua volta >ava.lang.O*>ect 0li attri*uti ereditati da +omponent sono9 :>22>MKA/IH%MG%2( CG%2G?KA/IH%MG%2( /GF2KA/IH%MG%2( ?IHU2KA/IH%MG%2( 2>*KA/IH%MG%2 mentre i metodi ereditati da +omponent sono9 action( add( addComponent/istener( addFocus/istener( addInputMet#od/istener( addae</istener( addMouse/istener( addMouseMotion/istener( add*ropert<C#ange/istener( add*ropert<C#ange/istener( bounds( c#ecAImage( c#ecAImage( coalesceG9ents( contains( contains( createImage( createImage( disable( disableG9ents( dispatc#G9ent( enable( enable( enableG9ents( enableInputMet#ods( 5ire*ropert<C#ange( get:acAground( get:ounds( get:ounds( getColorModel( getComponent>rientation( getCursor( get@rop2arget( getFont( getFontMetrics( getForeground( getHrap#ics( getUeig#t( getInputMet#od?e=uests( get/ocation( get/ocation( get/ocation>nScreen( get%ame( get*arent( get*eer( getSize( getSize( get2ree/ocA( getPidt#( getM( getN( gotFocus( #andleG9ent( #asFocus( #ide( imageFpdate( inside( is@ispla<able( is@ouble:u55ered( isGnabled( isFocus2ra9ersable( is/ig#t!eig#t( is>pa=ue( is3alid( is3isible( Ae<@o!n( Ae<Fp( list( list( list( location( lostFocus( mouse@o!n( mouse@rag( mouseGnter( mouseG8it( mouseMo9e( mouseFp( mo9e( ne8tFocus( paintAll( prepareImage( prepareImage( printAll( processComponentG9ent( processFocusG9ent( processInputMet#odG9ent( processae<G9ent( processMouseG9ent( processMouseMotionG9ent( remo9eComponent/istener( remo9eFocus/istener( remo9eInputMet#od/istener( remo9eae</istener( remo9eMouse/istener( remo9eMouseMotion/istener( remo9e*ropert<C#ange/istener( remo9e*ropert<C#ange/istener( repaint( repaint( repaint( repaint( re=uestFocus( res#ape( resize( resize( set:acAground( set:ounds( set:ounds( setComponent>rientation( setCursor( set@rop2arget( setGnabled( setForeground( set/ocale( set/ocation( set/ocation( set%ame( setSize( setSize( set3isible( s#o!( size( toString( trans5erFocus #entre da O*>ect vengono ereditati i soliti metodi9 clone( e=uals( 5inalize( getClass( #as#Code( noti5<( noti5<All( !ait( !ait( !ait 8lcuni di questi li vedremo, per gli altri vi consiglio di consultare la (ocumentazione del J(;, che li descrive tutti in dettaglio. Il diagramma delle estensioni di Rrame il seguente9
:::...
:::...
8 questo punto si capisce come importante l'estensione delle classi in Java, infatti in Rrame possono essere invocati tutti i metodi di sopra. #entre quello di JRrame di swing 9
.uindi Jframe eredita tutti i metodi di Rrame essendo derivato da essa, in pi) ne definisce altri.
LEZIONE 18:
Fn) applet non X altro c#e una applicazione Da9a c#e gira su !eb& /)applet presenta =ualc#e di55erenza con le applicazioni( in5atti essi non #anno nessun main( sono delle classi( c#iamate come il 5ile c#e le contiene( c#e estendono la classe Applet del pacAage ;a9a&applet& Anc#e per gli applet esiste la 9ersione DApplet di s!ing( c#e 9iene usata per inserire componenti S!ing in9ece c#e componenti AP2& Fn applet #a bisogno di un 5ile #tml c#e la ric#iama( ad esempio sia *rimoApplet&;a9a l)applet c#e 9ogliamo eseguire( lo compiliamo e il compilatore ci genera *rimoApplet&class( per eseguirlo abbiamo bisogno di un 5ile #tml c#e al suo interno contenga il 2AHL [applet code $*rimoApplet&class$ 7["applet7 Supponiamo c#e =uesto 5ile si c#iami pippo&#tml( a =uesto punto abbiamo due modi di eseguire l)applet( il primo in 5ase di debug X usando il programma applet9ie!er di D@a( e scri9eremo in =uesto caso dal prompt del dosL applet9ie!er pippo&#tml il secondo( X usando un !eb bro!ser( come G8plorer o %etscape ric#iamando il 5ile pippo&#tml& Come si 9ede( si lancia sempre il 5ile #tml( e non come accade9a per le applicazioni il 5ile &class( X il 5ile #tml c#e ric#iama l)applicazione &;a9a& *er maggiori dettagli sulle pagine #tml 9i consiglio di consultare sul sito U2M/&I2 le sezioni riguardanti l)argomento( noi 5aremo delle pagine scarne c#e ser9iranno solo a caricare i nostri applet( ad esempio per l)applet *rimoApplet&class di prima( il 5ile pippo&#tml sar =ualcosa del tipoL [#tml7 [#ead7 [title7Applet *rimoApplet ["#ead7 [bod<7 Il seguente X l)applet *rimoApplet&class
Cosa un applet
:::...
:::...
[applet code $*rimoApplet&class$ !idt# +'' #eig#t +''7Il tuo bro!ser X 9ecc#io( cambialoW["A**/G27 ["bod<7 ["#tml7 Abbiamo 9isto come mandare in esecuzione l)applet( adesso creiamolo& Innanzitutto dobbiamo creare una classe c#iamata *rimoApplet( c#e estende la classe ;a9a&applet&Applet( e dobbiamo de5inire alcuni metodi c#e il sistema (applet9ie!er o il bro!ser) in9oc#er automaticamente& Fno di =uesti metodi si c#iama paint (Hrap#ics >)( e Hrap#ics X un oggetto c#e rappresenta lo sc#ermo dell)applet( noi lo ride5iniremo in modo da 5are uscire sullo sc#ermo =uello c#e pre5eriamo& Fseremo il metodo dra!String della classe Hrap#ics per stampare una stringa su sc#ermo& Il programma *rimoApplet&;a9a X il seguente import ;a9a&applet&6; import ;a9a&a!t&6; public class *rimoApplet e8tends Applet { public 9oid paint (Hrap#ics g) { g&dra!String($Ciao( io sono il primo applet&$('(0'); } } Il pacAage applet contiene tre inter5acce ed una classeL Inter5acce AppletConte8t( =uesta inter5accia corrisponde all)ambiente dell)applet( o99ero al documento c#e lo contiene e agli altri applets contenuti nello stesso documento& AppletStub( riguarda l)ambiente di esecuzione dell)applet( sia esso il bro!ser c#e l)applet9ie!er& AudioClip( l)inter5accia X una semplice astrazione per suonare degli audio& Classe Applet Analizziamo la classe Applet piV in dettaglio& Il cosruttore X unico( senza argomenti& Applet() 3i sono alcuni metodi c#iamati dal bro!ser o dall)applet9ie!er automaticamente( essi sonoL 9oid init()( =uesto metodo 9iene in9ocato appena l)applet 9iene completamente caricato nel sistema& Gsso tipicamente 9iene utilizzato per inizializzare l)applet& 9oid start()( c#iamato =uando il sistema manda in esecuzione l)applet( lo in5orma di =uesto a99enimento& 9oid stop()( c#iamato =uando il sistema stoppa l)esecuzione dell)applet( lo in5orma dell)e9ento( c#iamato =uando si preme il bottone S2>* dell)applet9ie!er( si cambia pagina nel bro!ser& 9oid destro<()( c#iamato =uando l)applet 9iene distrutto( o99ero =uando si cambia esce dal bro!ser o dall)applet9ie!er Ruindi il ciclo di 9ita di un)applet X il seguenteL <. /iene caricato, e quindi viene chiamato init&'M =. /iene mandato in esecuzione, viene chiamato start&', esso invoca il metodo paint&' della superclasse +ontainerM C. /iene stoppato premendo lo stop del *rowser oppure quando la finestra che lo contiene non pi) in primo piano, e viene chiamato stop&', mentre quando ripassa in primo piano ne viene richimato lo start&'M ?. /iene infine distrutto quando si esce dal *rowser che lo ha mandato in esecuzione, innanzitutto viene invocato lo stop&' e poi il destro &'M 6ell'esempio successivo vengono visualizzate le precedenti fasi, per vedere i risultati con un *rowser, visto che l'output sono delle : stem.out.print&', selezionare in strumenti &tool', show >ava consolle &o simili', con l'appletviewer invece l'output viene scritto nella finestra dal quale viene invocato l'html che invoca l'applet. %o editiamo nel file :tadi.>ava9
:::...
import ;a9a&applet&6; public class Stadi e8tends Applet { public Stadi() { S<stem&out&println($In9ocato il costruttore di Stadi$); } public 9oid init() { super&init(); S<stem&out&println($Gseguito public 9oid init()$); } public 9oid start() { super&start(); S<stem&out&println($Gseguito public 9oid start()$); } public 9oid stop() { super&stop(); S<stem&out&println($Gseguito public 9oid stop()$); } public 9oid destro<() { super&destro<(); S<stem&out&println($Gseguito public 9oid destro<()$); } } %o compiliamo con9 >avac :tadi.>ava Der caricarlo creeremo il file :tadi.html che conterr9
:::...
[#tml7 [#ead7 [title7Stadi&#tml carica Stadi&class["title7 ["#ead7 [bod<7 Il seguente X l)applet Stadi( c#e 5a 9edere gli stadi attra9ersati dall)applet& [:?7 [applet code $Stadi&class$ !idt# 1'' #eig#t +''7Il tuo bro!ser X 9ecc#io( cambialoW["A**/G27 ["bod<7 ["#tml7 Der eseguirlo *atteremo 9 appleviewer :tadi.html, oppure faremo apri sul file :tadi.html con il nostro *rowser preferito. 0li altri metodi della classe 8pplet sono9 AppletConte8t getAppletConte8t(), da l'8pplet+onte"t associato all'applet, ovvero il documento che lo ha mandato in esecuzione e gli altri applet invocati da questo. String getAppletIn5o(), da informazioni sull'applet, deve essere sovrascritta, la normale da null.
:::...
:::...
AudioClip getAudioClip(F?/ url), da l'oggetto di tipo 8udio+lip associato all'5B% inserito. Bicordo che l'5B% una risorsa del we*. AudioClip getAudioClip(F?/ url( String name), da l'oggetto di tipo 8udio+lip associato all'5B% e al nome. F?/ getCode:ase(), da l'url associato all'applet. F?/ get@ocument:ase(), da l'url del documento html che ha invocato l'applet. Image getImage(F?/ url), da l' oggetto di tipo Image associata all'url inserito, essa pu3 essere stampata sullo schermo. Image getImage(F?/ url( String name), da l'oggetto di tipo Image associato all'url e al nome. /ocale get/ocale(), da l'oggetto di tipo %ocale associato all'applet, esso si cura dell'internazionalizzazione, si trova nel pac$age >ava.util. String get*arameter(String name), da il valore del parametro chiamato name preso dalla pagina html che invoca l'applet. %'applet infatti pu3 essere invocato con dei valori di ingresso, come l'args del main, questo metodo li preleva. 8d esempio se invoco l'applet +loc$.class cosH9 [applet code $ClocA$ !idt# 0' #eig#t 0'7 [param name Color 9alue $blue$7 ["applet7 :e nel codice dell'applet scriver3 getDarameter&G+olorG' il risultato che otterr3 sar G*lueG. StringBCBC get*arameterIn5o(), da un arra che contiene informazioni sui parametri dell'applet. boolean isActi9e (), dice se l'applet attivo. static AudioClip ne!AudioClip(F?/ url), prende un 8udio+lip da un dato url. 9oid pla<(F?/ url), suona l'audio clip preso dall'url assoluto. 9oid pla<(F?/ url( String name), suona il +lip dato dall'url e dal nome specificato. 9oid resize(@imension d) o 9oid resize(int !idt#( int #eig#t), richiede all'applet di modificare le proprie dimensioni. (imension un oggetto awt che una dimensione, ovvero un altezza e una larghezza. 9oid setStub(AppletStub stub), setta l'8pplet:tu* dell'applet con il nuovo stu*. 9oid s#o!Status(String msg), Bichiede all'applet che la stringa venga stampata nella finestra di stato dell'applet. 5n applet una estensione di Danel, il quale un semplice contenitore, da questo eredita il metodo9 add6otif *anel estende Container da cui eredita( e 5a ereditare ad Applet i metodiL add( add( add( add( add( addContainer/istener( addImpl( countComponents( deli9erG9ent( do/a<out( 5indComponentAt( 5indComponentAt( getAlignmentM( getAlignmentN( getComponent( getComponentAt( getComponentAt( getComponentCount( getComponents( getInsets( get/a<out( getMa8imumSize( getMinimumSize( get*re5erredSize( insets( in9alidate( isAncestor>5( la<out( list( list( locate( minimumSize( paint( paintComponents( paramString( pre5erredSize( print( printComponents( processContainerG9ent( processG9ent( remo9e( remo9e( remo9eAll( remo9eContainer/istener( remo9e%oti5<( setFont( set/a<out( update( 9alidate( 9alidate2ree 8 sua volta +ontainer estende +omponent, e quindi vi sono gli attri*uti :>22>MKA/IH%MG%2( CG%2G?KA/IH%MG%2( /GF2KA/IH%MG%2( ?IHU2KA/IH%MG%2( 2>*KA/IH%MG%2 e i metodi9 action( add( addComponent/istener( addFocus/istener( addInputMet#od/istener( addae</istener( addMouse/istener( addMouseMotion/istener( add*ropert<C#ange/istener( add*ropert<C#ange/istener( bounds( c#ecAImage( c#ecAImage( coalesceG9ents( contains( contains( createImage( createImage( disable( disableG9ents( dispatc#G9ent( enable( enable( enableG9ents( enableInputMet#ods( 5ire*ropert<C#ange( get:acAground( get:ounds( get:ounds( getColorModel( getComponent>rientation( getCursor( get@rop2arget( getFont( getFontMetrics( getForeground( getHrap#ics( getUeig#t( getInputMet#od?e=uests( get/ocation( get/ocation( get/ocation>nScreen( get%ame( get*arent( get*eer( getSize( getSize( get2ree/ocA( getPidt#( getM( getN( gotFocus( #andleG9ent( #asFocus( #ide( imageFpdate( inside( is@ispla<able( is@ouble:u55ered( isGnabled( isFocus2ra9ersable( is/ig#t!eig#t( is>pa=ue( is3alid( is3isible( Ae<@o!n( Ae<Fp( list( list( list( location( lostFocus( mouse@o!n( mouse@rag( mouseGnter( mouseG8it( mouseMo9e( mouseFp( mo9e( ne8tFocus( paintAll( prepareImage( prepareImage( printAll( processComponentG9ent( processFocusG9ent( processInputMet#odG9ent( processae<G9ent( processMouseG9ent( processMouseMotionG9ent( remo9eComponent/istener( remo9eFocus/istener( remo9eInputMet#od/istener( remo9eae</istener( remo9eMouse/istener( remo9eMouseMotion/istener(
:::...
:::...
remo9e*ropert<C#ange/istener( remo9e*ropert<C#ange/istener( repaint( repaint( repaint( repaint( re=uestFocus( res#ape( resize( resize( set:acAground( set:ounds( set:ounds( setComponent>rientation( setCursor( set@rop2arget( setGnabled( setForeground( set/ocale( set/ocation( set/ocation( set%ame( setSize( setSize( set3isible( s#o!( size( toString( trans5erFocus 7 quindi quelli di O*>ect9 clone, equals, finalize, get+lass, hash+ode, notif , notif 8ll, wait, wait, wait %a gerarchia 9
Racciamo un altro piccolo applet chiamati Info.>ava import ;a9a&applet&6; import ;a9a&a!t&6; import ;a9a&a!t&image&6; public class In5o e8tends Applet implements Image>bser9er { public In5o() { } public 9oid init() { super&init(); set:acAground(Color&<ello!); resize(.''(1''); } public 9oid start() { super&start(); } public 9oid stop() { super&stop(); } public 9oid destro<() { super&destro<(); } public 9oid paint (Hrap#ics g) { g&setColor(Color&darAHra<); String p getAppletIn5o();
:::...
i5 (pW null) g&dra!String(p(+'(+'); g&dra!String($C>@GL$EgetCode:ase()&toString()(+'(1'); g&dra!String($@>CL$Eget@ocument:ase()&toString()(+'(4'); Image io getImage(getCode:ase()($me&D*H$);
:::...
"" *er 9isualizzare =uesta imagine #o bisogno c#e In5o implementi l)inter5accia Image>bser9er& "" g&dra!Image(Image(8(<(Image>bser9er); g&dra!Image(io(+'(.'(t#is); g&dra!String($Ruesto sono io$(T'(T'); String nome get*arameter($parametro4$); String cognome get*arameter($parametro1$); String eta get*arameter($parametro+$); g&dra!String($Gsegue il programma$(+'(+0'); g&dra!String(nome(+'(+S'); g&dra!String(cognome(+'(+-'); g&dra!String($di $EetaE$ anni$(+'(+T'); } public String getAppletIn5o() { return $Applet di *ietro Castellucci$; } public StringBCBC get*arameterIn5o() { StringBCBC r { {$parametro+$($intero$($2ua et$}( {$parametro1$($Stringa$( $2uo Cognome$}( {$parametro4$($Stringa$($2uo %ome$} }; return r; } } Der caricare l'applet creeremo un file chiamato Info.html, che conterr9 \html[ \head[ \title[Info.html carica Info.class\4title[ \4head[ \*od [ Il seguente l'applet Info. \-B[ \applet codeLGInfo.classG widthL?@@ heightL=@@[ \param nameLparametro< valueLG7!8' (I +HI 7:7057 I% DBO0B8##8G[ \param nameLparametro= valueLG +O06O#7 (I +HI 7:7057 I% DBO0B8##8 G[ \param nameLparametroC valueLG 6O#7 (I +HI 7:7057 I% DBO0B8##8 G[ Il tuo *rowser vecchio, cam*ialo] \48DD%7![ \4*od [ \4html[
:::...
:::...
#i raccomando di specificare i parametri parametro<, parametro= e parametroC, perch nell'applet non si fa nessun controllo sulla loro definizione, quindi l'applet fa una eccezione non catturata, inoltre nella director dove mettete l'applet, ci deve essere un file chiamato me.JD0, che un'immagine EV"QQ pi"el.
LEZIONE 19:
8 questo punto, dopo avere visto cosa sono i Rrame e cosa sono gli 8pplet, ci viene in mente una domanda, ma sar possi*ile com*inare le due tecniche, se le vogliamo chamare cosH, per creare delle applicazioni mistea %a risposta ovviamente si. Dossiamo fare dei programmi Java che sono dei misti tra applicazione e applets. In effetti data la modularit del linguaggio possiamo creare delle appliczioni Java che usano altre applicazioni Java, cosa che non accade nei normali linguaggi di programmazione, ove solo possi*ile invocare da un programma altri programmi. :upponiamo ad esempio di avere creato un programma Java chiamato +alcolatrice.>ava, con il suo main e i suoi metodi, tra cui uno che prende due interi e ne restituisce la somma. :upponiamo a questo punto di averlo compilato in +alcolatrice.class e di averlo anche eseguito. Infine facciamo un altro programma di qualunque genere, in questo noi possiamo usare il programma +alcolatrice.class, ovvero la classe +alcolatrice, e tutte le sue funzioni pu**liche, tra cui quella della somma. !ornando al discorso degli applet che chiamano dei frame, quardate questo esempio9 import ;a9a&a!t&6; import ;a9a&applet&6; public class Mista e8tends Applet { Frame F; public 9oid init() { F ne! Frame($Ciao( =uesto X un Frame$);
Applicazioni miste
F&setSize(+''(0'); F&s#o!(); } public 9oid paint(Hrap#ics g) { g&dra!String($Io sono un)applet$(+'(1'); ne! p(); } public 9oid destro<() { String BC param {$$}; Finestra&main(param); } }
:::...
class p e8tends Frame { p() { set2itle($Fn)altro Frame lanciato dall)applet$); setSize(10'(+''); set/ocation(1''(4''); s#o!(); ne! @ialog(t#is($Ruesta X una dialog$); } public 9oid paint(Hrap#ics g) { g&dra!String($*otrei essere un banner pubblicitario$(+'(.');
:::...
} } lo metterete in un file chiamato #ista.>ava, e lo lancerede creando un file #ista.html contenente9 [#tml7 [#ead7 [title7mista["title7 ["#ead7 [bod<7 Il seguente X un appletL[:?7 [applet code $Mista&class$ !idt# 1'' #eig#t +''7Il tuo bro!ser X 9ecc#io( cambialoW["A**/G27 ["bod<7 ["#tml7 %anciatelo e vedete cosa succede, ogni volta che l'applet passa in secondo piano, ovvero ci piazzate un'altra finestra sopra, e poi ritorna in promo piano.
LEZIONE "0:
Drima di cominciare questo che sar uno dei capitoli pi) interessanti del corso, introduciamo il pac$age awt e cosa un componente 05I. /edremo anche dei componenti che sono contenitori per altri componenti. Il pac$age 8*stract 2indow !ool$it, mette a disposizione del programmatore una serie di classi e Interfacce per la gestione di interfacce grafiche. Il pac$age >ava.awt ha anche dei sottopac$age, essi sono9 ;a9a&a!t&color ;a9a&a!t&datatrans5er ;a9a&a!t&dnd ;a9a&a!t&e9ent ;a9a&a!t&5ont ;a9a&a!t&geom ;a9a&a!t&im ;a9a&a!t&image ;a9a&a!t&image&renderable ;a9a&a!t&print
Inter acce gra ic!e" #$I e A%T
:::...
:::...
(i cui vedremo alcune funzionalit. :ulle classi awt sono state costruite le classi del pac$age swing, che attualmente il pac$age pi) utilizzato per costruire delle interfacce grafiche, e che vedremo tra non molto. /ediamo cosa contiene awt9 Inter-acce Acti9eG9ent, interfaccia per eventi che sanno come sono stati attivati. Ad;ustable, interfaccia per oggetti che hanno un valore numerico compreso in un range di valori. Composite, interfaccia che serve per comporre le primitive grafiche di awt. CompositeConte8t, am*iente ottimizzato per le operazioni di composizione di primitive. ItemSelectable, interfaccia per oggetti che contengono un insieme di item, di cui possono essere selezionati anche zero o pi) di uno&(i solito si pu3 selezionare almeno e al massimo un item, questa interfaccia elimina questa limitazione'. /a<outManager, interfaccia per le classi che conterranno dei gestori di la out. /a<outManager1, come quello di sopra. MenuContainer, superclasse di tutti i menu. *aint, questa interfaccia definisce i colori da usare per le operazioni grafiche usando 0raphics=(. *aintConte8t, am*iente ottimizzato per le operazioni di composizione di primitive grafiche usando 0raphics=(. *rintHrap#ics, definisce il contesto per stampare. S#ape, definizioni per costruire una forma geometrica. StroAe, ulteriori decorazioni per le forme. 2ransparenc<, definisce i pi) comuni tipi di trasparenza. %la!!i Alp#aComposite, classe che implementa le composizioni del fattore alfa dei colori trattando il *lending e la trasparenza di grafica e immagini. AP2G9ent, root degli eventi di 82!. AP2G9entMulticaster, dispatcher per eventi 82!, efficiente e multiprogramma*ile, effettua il multicast di eventi a vari componenti. AP2*ermission, per i permessi 82!. :asicStroAe, attri*uti per le linee esterne delle primitive grafiche. :order/a<out, il primo gestore di la out, questi gestori, che vedremo tra pochissimo, servono a disporre gli elementi &i componenti' nei contenitori. .uesto divide il contenitore in A regioni9 nord, sud, est, ovest e centro. :utton, classe dei *ottoni. Can9as, area in cui una applicazione pu3 disegnare. +ard%a out, altro gestore di la out. C#ecAbo8, +hec$*o"0roup, +hec$*o"#enuItem esse gestiscono i *ottoni di tipo *ooleano &premuto non premuto' C#oice, presenta un menu a tendina per delle scelte. Color, colori in B0- o in altri ar*itrari spazi di colori. Component, +lasse da cui derivano tutti i componenti 05I &*ottoni, la*el,S' Component>rientation, orientamento dei componenti Container, contenitore di componenti. Cursor, cursori. @ialog, finestre di dialogo, sono quelle che segnalano errori e non solo. @imension, casse che gestisce le dimensioni dei componenti, altezza e larghezza. G9ent, classe che gestisce gli eventi secondo il veccio modello di gestone degli eventi &Java <.@', rimasto per fare girare ancora le vecchie applicazioni e applet Java, ma dichiarato deprecated. In effetti questo modello stato cam*iato perch in situazioni complesse, ovvero con molti componenti messi uno sull'altro, non si riusciva a capire quale componente stesse ricevendo l'evento. G9entRueue, coda di eventi. File@ialog, dialog speciale che gestisce l'input e l'output dei file. 7' molto comoda. Flo!/a<out, altro gestore di la out. Font, fonts per il testo. FontMetrics, attri*uti per le font. Frame, classe gi vista che implementa le finestre, con titolo e *ordo. Hradient*aint, riempie le figure con colori lineari con gradiente. Hrap#ics, contesto grafico in cui si pu3 disegnare. Hrap#ics1@, nuovo contesto grafico, inserito con Java =, che da altre sofisticate possi*ilit al disegno. Hrap#icsCon5iguration, descrive le caratteristiche della desitnazione della grafica che pu3 essere il monitor o la stampante. Hrap#icsCon5ig2emplate, usata per ottenere una 0raphics+onfiguration valida. Hrap#icsGn9ironment, descrive gli am*ienti grafici e i font utilizza*ili in ogni specifica piattaforma da Java. Hrap#ics@e9ice, descrive il 0raphic(evice utilizza*ile in un particolare am*iente. Hrid:agConstraints, 0rid-ag%a out, 0rid%a out, gestori di la out. Image, superclasse per tutte le classi che rappresentano una immagine grafica.
:::...
Insets, rappresenta il *ordo di un contenitore. /abel, etichetta. /ist( lista Media2racAer, classe di utilit per gestire oggetti multimediali. Menu, menu di tipo pullPdown &a discesa'. Menu:ar, *arra dei menu. MenuComponent, superclasse di tutti i componenti dei menu,. MenuItem, /oce di menu. MenuS#ortcut, serve a rappresentare l'acceleratore per una voce di menu. *anel, contenitore. *oint, punto nelle coordinate ", . *ol<gon, poligono. *opupMenu, menu di tipo a scomparsa. *rintDob, serve ad inizializzare e ad eseguire le stampe. ?ectangle, rettangolo. ?enderingUints, contiene aiuti per il rendering usati da 0raphics=(. ?enderingUints&ae<, definisce i tasti usati per controllare i vari aspetti del rendering. Scrollbar, *arra di scorrimento. Scroll*ane, pannello con due *arre di scorrimento. S<stemColor, rappresenta i colori sim*olici di un oggetto 05I in un sistema. 2e8tComponent, superclasse di tutti i componenti che contengono testo. 2e8tArea, area di testo. 2e8tField, singola linea di testo. 2e8ture*aint, come riempire una figura con una te"ture. 2oolAit, superclasse dell' 8*stract 2indow !ool$it. Pindo!, finestra &senza *ordo e *arra di menu'. Eccezioni AP2G8ception IllegalComponentStateG8ception Errori AP2Grror
:::...
/ista questa panoramica sul pac$age cerchiamo di capire a cosa servono queste classi. !ra tutte le classi, distinguiamo alcune classi nel pac$age per quello che fanno. Innanzitutto a**iamo visto delle classi Rrame, (ialog e 2indows, le quali rappresentano delle finestre, queste finestre conterranno dei menu &le prime due' e dei componenti 05I. Der contenerli (evono avere dei contenitori, di questa specie a**iamo visto +ontainer e Danel. Ogni +ontenitore pu3 contenere un %a out #anager, che gestisce il posizionamento di pi) componenti nello stesso contenitore, e pu3 contenere anche altri contenitori, in modo da creare strutture anche complesse. Infine a**iamo visto i componenti 05I veri e propri che vanno aggiunti ai contenitori, ad esempio %a*el. 6ell'esempio che segue attacchiamo una la*el al contenitore di un Rrame. import >ava.awt.KM public class Gtic#etta e8tends Frame { /abel et ne! /abel(); public Gtic#etta(String etic#etta) { et&set2e8t(etic#etta); set2itle($Gtic#etta $Eetic#etta); add(et); pacA(); s#o!(); } public static 9oid main (StringBC a) { tr<
:::...
{ne! Gtic#etta(aB'C);} catc# (Arra<Inde8>ut>5:oundsG8ception e) {S<stem&out&println($G??>?GL battere ;a9a Gtic#etta S2?I%HA$);}; } }
:::...
+ome a**iamo gi detto, i 05I vanno sia su Rrame che su 8pplet, quindi si pu3 pensare alla versione applet del programma precedente. import ;a9a&applet&6; import ;a9a&a!t&6; public class ApplGtic#etta e8tends Applet { /abel et ne! /abel(); public 9oid init () { et&set2e8t($Ciao$); add(et); } } +he sar messo in un file chiamato 8ppl7tichetta.>ava e sar chiamato da un file html contenente9 [#tml7 [#ead7 [title7 ["title7 ["#ead7 [bod<7 [A**/G2 code $ApplGtic#etta&class$ !idt# 1'' #eig#t +''7 ["A**/G27 ["bod<7 ["#tml7 6el pac$age swing tutto molto simile, anche se la gestione dei contenitori leggermente differente.
LEZIONE "1:
Iniziamo la panoramica sui 05I, per usare nella stessa finestra pi) componenti a**iamo *isogno di uno o pi) contenitori, questi li vedremo in seguito, per3 in alcuni casi di questo paragrafo dovr3 usarli senza averli spiegati, perch mi necessiteranno pi) di un componente 05I nella finestra. :ono sicuro che non avrete pro*lemi nel comprendere lo stesso i programmi, perch user3 in modo semplice sia i %a out che i +ontainer, per3 mi scuso lo stesso se questo vi arrecher anche un minimo disagio. In particolare user3 i Danel e user3 delle costanti della classe -order%a out, la quale divide il +ontainer, in questo caso il Danel, in cinque zone, 6OB!H, :O5!H, 27:!, 78:! e +76!7B. In questa lezione esamineremo due componenti, i pi) semplici, le %a*el e i -ottoni. %e prime non hanno nessun evento associato mentre i secondi, a seconda del tipo di *ottone hanno due tipi di eventi associati. Etichette Iniziamo la nostra panoramica sui componenti vedendo il primo semplice elemento, l'etichetta, che tra l'altro a**iamo gi usato. %'etichetta un contenitore per un testo, essa fa apparire sullo schermo una singola linea di testo non edita*ile dall'utente, che per3 pu3 essere cam*iata dall'applicazione. %'etichetta, chiamata in Java %a*el, si trova nel pac$age >ava.awt, quindi per essere usata il nostro
Le etic!ette ed i bottoni
:::...
:::...
programma dovr cominciare con una import >ava.awt.%a*el &per inglo*are solo la classe %a*el del pac$age', oppure import >ava.awt.K &per inglo*are tutte le classi del pac$age'. 8ll'interno del programma che la vuole usare *isogner quindi dichiarare un oggetto di tipo %a*el nel seguente modo9 /abel etic#etta ne! /abel();
oppure, se non stato importato il pac$age >ava.awt9 ;a9a&a!t&/abel etic#etta ne! /abel();
%a %a*el ha tre costruttori9 /abel() , che costruisce un'etichetta vuota. /abel(String te8t), che costruisce un'etichetta con testo te"t, giustificata a sinistra. /abel(String te8t( int alignment) , che costruisce un'etichetta con testo te"t, giustificata secondo alignment. I valori possi*ili di alignment sono9 %a*el.%7R!, %a*el.BI0H!, e %a*el.+76!7B. 8lcuni metodi dell'oggetto sono9 int getAlignment(), da la giustificazione attuale dell'oggetto. String get2e8t() , da il testo contenuto nella la*el. 9oid setAlignment(int alignment), cam*ia la giustificazione della %a*el con alignment. 9oid set2e8t(String te8t), setta il testo della %a*el. Doi c' il metoto 8ccessi*le+onte"t get8ccessi*le+onte"t&', che vedremo quando vedremo i contenitori, infatti la %a*el in effetti un contenitore di testo. %a*el proviene dalla seguente gerarchia9
.uindi eredita i soliti metodi di O*>ect e quelli di >ava.awt.+omponent. !utti i componenti 05I sono ereditati da +omponent, quindi alla fine della panoramica dei 05I parleremo di +omponent, la quale contiene metodi molto utili per la gestione di questi componenti, come ad esempio metodi per settare e ottenere informazioni su dimensioni, colori dello sfondo, colori del testo, *ordi, eccS del componente. 8 parte i metodi di +omponent, siamo pronti ad usare le %a*el nei nostri programmi. Der ora non faccio nessun esempio dell'uso delle %a*el, le vedremo ne prossimo paragrafo quando parleremo dei *ottoni. Il pac$age swing mette a disposizione un'naloga classe denominata J%a*el, essa una estensione di %a*el, e mette a disposizione una vasta gamma di funzionalit supplementari, ad esempio possi*ile creare J%a*el che hanno sia un testo che un'immagine. $ottoni 5n altro componente molto usato, e di semplice realizzazione il *ottone, esso leggermente pi) complicato della %a*el, in quanto pu3 ricevere degli eventi &+lic$ sul *ottone'. I *ottoni sono di tre tipi, i *ottoni normali, le +hec$*o" e i radio*utton, iniziamo a vedere i primi. %a classe che definisce i *ottoni -utton di >ava.awt, essa mette a disposiozione tutti i metodi per gestire l'aspetto del *ottone. I costruttori della classe sono due9 :utton(), costruisce un *ottone senza etichettaM :utton(String t8t), costruisce un *ottone con etichetta t"t. 8lcuni metodi della classe sono9 9oid addAction/istener(Action/istener l), aggiunge il *ottone ad un oggetto chiamato Action/istener, il quale un ascoltatore di eventi. .uando il *ottone verr cliccato, l'evento verr gestito dall'8ction%istener. AccessibleConte8t getAccessibleConte8t(), come per le %a*el, i *ottoni sono anch'essi dei contenitori. String getActionCommand(), ogni *ottone ha associato un comando, questo ne restituisce quello attuale. String get/abel(), restituisce l'etichetta associata al *ottone. G9ent/istenerBC get/isteners(Class listener2<pe), da un arra contenente tutti gli ascoltatori di aventi definiti per questo *ottone. addMMM/istener(), aggiunge un ascoltatore di eventi, l'ascoltatore di eventi di tipo 111. In Java esistono vari
:::...
:::...
tipi di eventi, li vedremo tra poco, uno di questi l'evento di tipo action, in questo caso il metodo addAction/istener( ) 9oid remo9eAction/istener(Action/istener l), elimina l'ascoltatore di eventi l precedentemente associato al *ottone. 9oid setActionCommand(String command), setta il comando associato al *ottone, inizialmente il comando la la*el. 9oid set/abel(String label), setta la %a*el &etichetta' del *ottone. :iamo pronti per definire il nostro primo *ottone, do**iamo solo riuscire a capire come catturarne l'evento scaturito dalla pressione dello stesso. +ome gi detto in precedenza io parler3 dellagestione degli eventi secondo Java =, perch il vecchio modello di gestione degli eventi di Java < o*soleto e non funzionale. :econdo Java =, definito un *ottone, visto che l'evento principale del *ottone il clic$, che un evento appartenente alla famiglia degli eventi 8ction, *isogna associare un 8ction%istener allo stesso *ottone, usando il metodo add8ction%istaner&8ction%istener l'M .uello che do**iamo fare noi creare un 8ctin%istener specializzato per il nostro *ottone &o per i nostri *ottoni'. 8ction%istener definito nel pac$age >ava.awt.event &da includere nel programma' esso una interfaccia, quindi deve essere implementata, all'interno della classe in cui definita. 8d esempio, sto facendo un Rrame chiamato Dippo, contenente un *ottone, di cui voglio ascoltare il clic$, lo voglio ascoltare con un 8ction%istener specializzato da me chiamato 8scoltaDippo, dovr3 scrivere qualcosa del tipo9 import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class *ippo e8tends Frame { :utton bottone ne! :utton($CIA>$); Q metodi di *ippo( tra cui il costruttore( c#e conterr un bottone&addAction/istener(ne! Ascolta*ippo()); public class Ascolta*ippo implements Action/istener() { "" Hestione dell)e9ento } "" Fine classe Ascolta*ippo interna a *ippo }""Fine classe *ippo In 8scoltaDippo dovr3 specializzare tutti i metodi dell'interfaccia che sto estendendo, 8ction%istener ha un solo metodo9 void actionDerformed&8ction7vent e' quindi in 8scoltaDippo dovr3 definire il metodo pu*lic void actionDerformed&8ction7vent e', questo il metodo che verr invocato quando cliccher3 il *ottone. %'8ction7vent che mi arriva nel metodo come parametro conterr tutte le informazioni riguardanti l'evento, tra cui il comando. 8scoltaDippo pu3 essere associato anche a pi) *ottoni, la sua actionDerformed verr invocata al clic$ di ognuno di questi *ottoni. +hiariamo su*ito il concetto, che forse un pochino pi) difficile delle altre cose che a**iamo fatto con un piccolo esempio, vi assicuro per3 che una volta assimilato il concetto, la gestione degli eventi di Java molto semplice. +reiamo un Rrame che ha un *ottone e una %a*el, ogni volta che il *ottone viene cliccato la la*el da un messaggio. import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class :ottone e8tends Frame { "" Costruttore classe :ottone :utton cliccami ne! :utton($Cliccami$); /abel cliccato ne! /abel($%on mi #ai cliccato nemmeno una 9olta$); public :ottone() { cliccami&addAction/istener(ne! Ascoltatore()); "" setup comando cliccami&setActionCommand($C/ICa$); "" Aggiungo il bottone e la label al Frame& "" %on badate alle seguenti istruzioni(
:::...
"" la add ser9e ad aggiungere un componente ad "" un contenitore( e il secondo parametro della "" add( o99ero :order/a<out( X un gestore di /a<out( "" c#e ser9e a stabilire il modo in cui gli oggetti "" HFI 9engono posti nel contenitore& add(cliccami(:order/a<out&%>?2U); add(cliccato(:order/a<out&S>F2U); "" metodi di Frame pacA(); s#o!(); } "" main public static 9oid main (String BC arg) { ne! :ottone(); } "" Ascoltatore di e9enti Action int 3olte 1; public class Ascoltatore implements Action/istener { public 9oid action*er5ormed (ActionG9ent e) { String Comando e&getActionCommand(); i5 (Comando&compare2o($C/ICa$) { cliccato&set2e8t($Mi #ai cliccato$); cliccami&set/abel($?icliccami$); cliccami&setActionCommand($?GC/ICa$); }; i5 (Comando&compare2o($?GC/ICa$) ') cliccato&set2e8t($Mi #ai cliccato $E(3olteEE)E$ 9olte&$); } }"" Fine Ascoltatore }"" Fine :ottone Il risultato la seguente finestra9 ')
:::...
:::...
:::...
+ome si vede in 8scoltatore, vengono gestiti due comandi differenti associati allo stesso *ottone, ed il *ottone quando viene cliccato la prima volta cam*ia il comando associato all'evento clic$. Drovate a modificarlo cam*iando il comando per sta*ilire con certezza le prime dieci volte che viene cliccato e stampando nella la*el GHai cliccato nove volte il *ottoneG &la nona volta'. Bicapitolando, in una interfaccia grafica innanzitutto si programma l'aspetto grafico, ovvero si inseriscono i *ottoni, i menu ecc, poi si creano e aggiungono gli ascoltatori di eventi, i quali a seconda dell'evento che si verificato chiamano uno o l'altro metodo di gestione del programma &aggiorna l'interfaccia, calcola le funzioni del programma di cui interfaccia grafica'. .uesto un principio generale della programmazione di Interfacce 0rafiche, ovvero della programmazione ad eventi, ogni programma che usate funziona cosH, ed ogni programma che scriverete funzioner cosH. Il tipo di programmazione leggermente differente da quella a cui un programmatore su piattaforma non grafiche &tipo (os, %inu" senza 1P2in' sono a*ituati, e all'inizio pu3 risultare non molto semplice, ma ci si deve solo a*ituare, che poi lo stesso. Il secondo tipo di *ottoni che vediamo sono i +hec$*o", ovvero quei *ottoni di tipo *ooleano, che trattengono lo stato. :i usano per fare delle scelte, tra di loro non esclusive o esclusive &in questo caso sono dei radio*utton', a esempio se si devono scegliere alcuni tra gli ho** preferiti. .uesti *ottoni una volta cliccati rimangono tali, e *isogna ricliccarli per farli tornare nella situazione di partenza. Der creare una +hec$*o" *isogna creare un oggetto appartenente alla classe +hec$*o" di >ava.awt, i costruttori possi*ili sono i seguenti9 C#ecAbo8(), crea una +hec$*o" senza etichetta. C#ecAbo8(String label), crea una +hec$*o" con etichetta la*el. C#ecAbo8(String label( boolean state), crea una +hec$*o" con etichetta la*el, e cliccata o meno a seconda del valore *ooleano state. Invece per le radio*utton9 C#ecAbo8(String label( boolean state( C#ecAbo8Hroup group), crea una +hec$*o" con etichetta la*el inserita in una specifica C#ecAbo8Hroup, che un contenitore di +hec$*o". C#ecAbo8(String label( C#ecAbo8Hroup group( boolean state) crea una +hec$*o" con etichetta la*el inserita in una specifica C#ecAbo8Hroup, e settata a seconda del valore di state. In pratica tra tutti i *ottoni inseriti nel +hec$*o"0roup, solo uno pu3 essere cliccato, gli altri devono essere non cliccati. %e +hec$*o" del primo tipo come ho detto vengono usate per effettuere delle scelte non esclusive, come ad esempio la scelta degli interessi tra una lista di interessi possi*ili, mentre le +hec$*o" del secondo tipo, ovvero i radio*uttons servono per fare delle scelte esclusive, ad esempio la scelta del reddito di una persona tra tante possi*ili fasce. !ra i metodi della classe +hec$*o" alcuni pi) interessanti sono9 9oid addItem/istener(Item/istener l) , associa un Item%istener alla +hec$*o", l'Item%istener gestisce gli eventi dei +hec$*o" e non solo, sono un secondo tipo di eventi che impareremo a gestire, comunque somigliano agli 8ction%istener, solo che sono associati ad oggetti che hanno uno stato. C#ecAbo8Hroup getC#ecAbo8Hroup(), da l'eventuale gruppo in cui inserita la +hec$*o". %e solite String get/abel() e G9ent/istenerBC get/isteners(Class listener2<pe) boolean getState(), questo metodo dice se la +hec$*o" cliccataoppure no. 9oid remo9eItem/istener(Item/istener l), toglie l'attuale ascoltatore di eventi Item. 9oid setC#ecAbo8Hroup(C#ecAbo8Hroup g), setta un gruppo per la +hec$*o". 9oid set/abel(String label), setta l'etichetta 9oid setState(boolean state), setta lo stato.
:::...
:::...
/ediamo anche cosa contiene un +hec$*o"0roup. Il costruttore uno senza parametri, e i metodi non dichiarati (eprecated sono tre9 C#ecAbo8 getSelectedC#ecAbo8(), da la +hec$*o" selezionata nel gruppo. 9oid setSelectedC#ecAbo8(C#ecAbo8 bo8), setta la +hec$*o" del gruppo indicata. String toString(), da una stringa rappresentante l'oggetto. Droviamo quindi a fare un esempietto che usa sia +hec$*o" che Badio-utton. import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class C#ecA e8tends Frame { "" Costruttore classe :ottone /abel r ne! /abel($?eddito annuo$); /abel i ne! /abel($Interessi$); :utton c#iudi ne! :utton($C#iudi Applicazione$); C#ecAbo8Hroup reddito ne! C#ecAbo8Hroup(); C#ecAbo8 r+ C#ecAbo8 r1 C#ecAbo8 r4 C#ecAbo8 r. C#ecAbo8 r0 C#ecAbo8 rS C#ecAbo8 rC#ecAbo8 i+ C#ecAbo8 i1 C#ecAbo8 i4 C#ecAbo8 i. C#ecAbo8 i0 C#ecAbo8 iS C#ecAbo8 iC#ecAbo8 iT C#ecAbo8 i, ne! C#ecAbo8($@a ' ai +'$); ne! C#ecAbo8($@agli ++ ai 4'$); ne! C#ecAbo8($@ai 4+ ai -'$); ne! C#ecAbo8($@ai -+ ai +''$); ne! C#ecAbo8($@ai +'+ a 1''$); ne! C#ecAbo8($@ai 1'+ a 0''$); ne! C#ecAbo8($Sono ricco s5ondato$); ne! C#ecAbo8($Sport$); ne! C#ecAbo8($In5ormatica$); ne! C#ecAbo8($/ettura$); ne! C#ecAbo8($Cinema$); ne! C#ecAbo8($Animali$); ne! C#ecAbo8($Fumetti$); ne! C#ecAbo8($/otterie$); ne! C#ecAbo8($@onne nude$); ne! C#ecAbo8($Fomini nudi$);
public C#ecA() { c#iudi&addAction/istener(ne! Ascoltatore()); *anel p+ ne! *anel(); *anel p1 ne! *anel(); p+&add(r); p+&add(r+); p+&add(r1); p+&add(r4); p+&add(r.); p+&add(r0); p+&add(rS); p+&add(r-); r+&setC#ecAbo8Hroup(reddito); r1&setC#ecAbo8Hroup(reddito); r4&setC#ecAbo8Hroup(reddito); r.&setC#ecAbo8Hroup(reddito);
:::...
r0&setC#ecAbo8Hroup(reddito); rS&setC#ecAbo8Hroup(reddito); r-&setC#ecAbo8Hroup(reddito);
:::...
add(p+(:order/a<out&%>?2U); p1&add(i); p1&add(i+); p1&add(i1); p1&add(i4); p1&add(i.); p1&add(i0); p1&add(iS); p1&add(i-); p1&add(iT); p1&add(i,);
add(p1(:order/a<out&CG%2G?); add(c#iudi(:order/a<out&S>F2U); "" metodi di Frame pacA(); s#o!(); } "" main public static 9oid main (String BC arg) { ne! C#ecA1(); } "" Ascoltatore di e9enti Action public class Ascoltatore implements Action/istener { public 9oid action*er5ormed (ActionG9ent e) { S<stem&out&println($Iscrizione al sito MMMMMMM&it$); S<stem&out&print($Huadagno annuo $); i5 (r+&getState()) S<stem&out&println(r+&get/abel()); else i5 (r1&getState()) S<stem&out&println(r1&get/abel()); else i5 (r4&getState()) S<stem&out&println(r4&get/abel()); else i5 (r.&getState()) S<stem&out&println(r.&get/abel()); else i5 (r0&getState()) S<stem&out&println(r0&get/abel()); else i5 (rS&getState()) S<stem&out&println(rS&get/abel()); else i5 (r-&getState()) S<stem&out&println(r-&get/abel()E$ (:eato teW)$); else S<stem&out&println($%>% @ICUIA?A2>$); S<stem&out&println($Interessi dic#iaratiL$); i5 (i+&getState()) S<stem&out&println($Jt$Ei+&get/abel());
:::...
i5 (i1&getState()) S<stem&out&println($Jt$Ei1&get/abel()); i5 (i4&getState()) S<stem&out&println($Jt$Ei4&get/abel()); i5 (i.&getState()) S<stem&out&println($Jt$Ei.&get/abel()); i5 (i0&getState()) S<stem&out&println($Jt$Ei0&get/abel()); i5 (iS&getState()) S<stem&out&println($Jt$EiS&get/abel()); i5 (i-&getState()) S<stem&out&println($Jt$Ei-&get/abel()); i5 (iT&getState()) S<stem&out&println($Jt$EiT&get/abel()); i5 (i,&getState()) S<stem&out&println($Jt$Ei,&get/abel()); S<stem&e8it('); } }"" Fine Ascoltatore }"" Fine :ottone Fig .L Finestra del programma
:::...
Ho dovuto di nuovo usere i la out e anche i Danel, me ne scuso perch ancora non ne parliamo, ma l'unico modo per inserire pi) 05I nella stessa finestra, per esempio provate a togliere i Danel e quindi ad aggiungere tutto direttamente alla finestra, senza usare i %a out, vedrete cosa succede. 6ell'applicazione c' un *ottone che serve a chiudere la finestra, questo perch ancora non siamo in grado di gestire gli eventi della finestra, come il close, che se lo provate vedrete che non va. !ra qualche tempo saremo in grado di gestire anche quelli. 6ell'applicazione non ho gestito gli eventi delle +hec$*o", questo perch non ne ho avuto *isogno, esistono situazioni in cui si devono gestire, e sono quelle in cui oltre allo stato del *ottone cam*ia qualcosa, ad esempio lo stato di qualche 05I, come nell'esempio seguente. import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class C#ecA1 e8tends Frame { "" Costruttore classe :ottone :utton c#iudi ne! :utton($C#iudi Applicazione$); C#ecAbo8 i+ ne! C#ecAbo8($primi 4$); C#ecAbo8 i1 ne! C#ecAbo8($secondi .$); C#ecAbo8 ii+ C#ecAbo8 ii1 C#ecAbo8 ii4 C#ecAbo8 ii. C#ecAbo8 ii0 C#ecAbo8 iiS C#ecAbo8 iine! C#ecAbo8($uno$); ne! C#ecAbo8($due$); ne! C#ecAbo8($tre$); ne! C#ecAbo8($=uattro$); ne! C#ecAbo8($cin=ue$); ne! C#ecAbo8($sei$); ne! C#ecAbo8($sette$);
public C#ecA1() { c#iudi&addAction/istener(ne! Ascoltatore()); *anel p+ ne! *anel(); *anel p1 ne! *anel(); p+&add(ii+); p+&add(ii1); p+&add(ii4); p+&add(ii.);
:::...
p+&add(ii0); p+&add(iiS); p+&add(ii-); ii+&addItem/istener(ne! AItem+()); ii1&addItem/istener(ne! AItem+()); ii4&addItem/istener(ne! AItem+()); ii.&addItem/istener(ne! AItem+()); ii0&addItem/istener(ne! AItem+()); iiS&addItem/istener(ne! AItem+()); ii-&addItem/istener(ne! AItem+()); i+&addItem/istener(ne! AItem1()); i1&addItem/istener(ne! AItem1()); add(p+(:order/a<out&%>?2U); p1&add(i+); p1&add(i1);
:::...
add(p1(:order/a<out&CG%2G?); add(c#iudi(:order/a<out&S>F2U); "" metodi di Frame pacA(); s#o!(); } "" main public static 9oid main (String BC arg) { ne! C#ecA(); } "" Ascoltatore di e9enti Action public class Ascoltatore implements Action/istener { public 9oid action*er5ormed (ActionG9ent e) {S<stem&e8it(');} }"" Fine Ascoltatore "" Ascoltatori di e9enti Item public class AItem+ implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) { i+&setState(ii+&getState()YY ii1&getState()YY ii4&getState());
:::...
i1&setState(ii.&getState()YY ii0&getState()YY iiS&getState()YY ii-&getState()); } }""Fine AItem+ public class AItem1 implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) { ii+&setState(i+&getState()); ii1&setState(i+&getState()); ii4&setState(i+&getState()); ii.&setState(i1&getState()); ii0&setState(i1&getState()); iiS&setState(i1&getState()); ii-&setState(i1&getState()); } }""Fine AItem1 }"" Fine :ottone
:::...
LEZIONE "":
%ella lezione precedente abbiamo 9isto come inserire nelle nostre applicazioni e nei nostri applets delle etic#ette e dei bottoni& *er 5are =uesto abbiamo usato dei contenitori e dei la<out( senza sapere come 5unzionassero& In =uesta lezione 9edremo il loro 5unzionamento( e come s5ruttarli per rendere migliori le nostre inter5acce& Iniziamo a descri9ere la classe Container del pacAage ;a9a&a!t( esso X una estensione della classe Component( dalla =uale pro9engono tutti i componenti HFI( ed in e55etti anc)esso X un componente HFI&
Contenitori e Gestione dei Layout
5n +ontainer un contenitore per oggetti 05I, e quindi anche per altri container. 7sso se usato insieme ad un %a out #anager permette di contenere anche pi) di un 05I &e +ontenitori', permettendo di fare apparire pi) oggetti nelle nostre interfacce. /ediamo cosa contiene la classe. +ontainer&' , l'unico costruttore della classe. 8lcuni metodi9 Component add(Component comp), aggiunge il componente alla fine del contenitore. Component add(Component comp( int inde8), aggiunge il componente nella posizione indicata del contenitore. 9oid add(Component comp( >b;ect constraints) e 9oid add(Component comp( >b;ect constraints( int inde8) , come prima, solo che si specificano delle costanti per il componente inserito. Component add(String name( Component comp), aggiunge al contenitore il componente e gli da un nome. 9oid addContainer/istener(Container/istener l), setta il +ontainer%istener che ascolter gli eventi occorsi al contenitore. 9oid do/a<out(), causa la disposizione dei componenti nel contenitore. Component 5indComponentAt(int 8( int <), restituisce il componente che si trova nella posizione specificata del contenitore &posizione grafica'. Component 5indComponentAt(*oint p) , restituisce il componente che si trova nella posizione specificata del contenitore &posizione grafica'. 5loat getAlignmentM(), restituisce l'allineamento lungo l'asse 1 del contenitore. 5loat getAlignmentN(), restituisce l'allineamento lungo l'asse W del contenitore. Component getComponent(int n), restituisce l'ennesimo componente contenuto nel contenitore. Component getComponentAt(int 8( int <), restituisce il componente che si trova nella posizione specificata del
:::...
:::...
contenitore &posizione grafica'. Component getComponentAt(*oint p), restituisce il componente che si trova nella posizione specificata del contenitore &posizione grafica'. int getComponentCount() , da il numero di componenti conteinuti nel contenitore. ComponentBC getComponents(), da tutti i componenti contenuti nel contenitore. Insets getInsets(), da un'oggetto Insets per il contenitore, questo oggetto rappresenta le dimensioni &grafiche' del contenitore. /a<outManager get/a<out(), restituisce il %a uot#anager associato al contenitore. G9ent/istenerBC get/isteners(Class listener2<pe), restituisce tutti gli ascoltatori di eventi associati al contenitore. @imension getMa8imumSize(), restituisce la dimensione massima che pu3 assumere il contenitore. @imension getMinimumSize(), restituisce la dimensione minima che pu3 assumere il contenitore. @imension get*re5erredSize(), restituisce la dimensione preferita per il contenitore. 9oid list(*rintStream out( int indent), stampa la lista dei componenti contenuti nel contenitore, su uno stream di output. 9oid list(*rintPriter out( int indent), :tampa su una stampante i componenti contenuti nel contenitore. 9oid paint(Hrap#ics g), disegna il contenitore. %a paint una funzione molto importante, vedremo come ridefinirla per disegnare sulla finestra. 9oid paintComponents(Hrap#ics g). disegna tutti i componenti del contenitore. 9oid print(Hrap#ics g), stampa il contenitore &l'aspetto grafico'. 9oid printComponents(Hrap#ics g), stampa tutti i componenti contenuti nel contenitore &il loro aspetto grafico'. 9oid remo9e(Component comp), elimina il componente specificato dal contenitore. 9oid remo9e(int inde8), rimuove il componente che si trova nella posizione specificata nel contenitore. 9oid remo9eAll(), rimuove tutti i componenti contenuti nel contenitore. 9oid remo9eContainer/istener(Container/istener l), elimina l'ascoltatore di eventi per containers da questo container. 9oid setFont(Font 5), setta le Ront usate per il testo nel contenitore. 9oid set/a<out(/a<outManager mgr), associa al contenitore un gestore di la out. 9oid update(Hrap#ics g), ridisegna il contenitore. 9oid 9alidate(), invalida il contenitore e i suoi componenti. Inserendo componenti nel contenitore, come sel successivo esempio, ci accorgiamo che solo l'ultimo viene visualizzato, questo perch non vi a**iamo dato un gestore di %a out, nel caso di applet invece, il %a out#anager di default il Rlow%a out. import ;a9a&a!t&6; public class Contenitore e8tends Frame { /abel l+ /abel l1 /abel l4 /abel l. /abel l0 ne! /abel($Gtic#etta+$); ne! /abel($Gtic#etta1$); ne! /abel($Gtic#etta4$); ne! /abel($Gtic#etta.$); ne! /abel($Gtic#etta0$);
public Contenitore() { "" uso add( perc#X il Frame X una estensione di Pindo!( c#e a sua "" 9otla estende Container& add(l+); add(l1); add(l4); add(l.); add(l0); do/a<out(); pacA(); s#o!(); } public static 9oid main(String BC arg) {
:::...
ne! Contenitore(); } }
:::...
.uindi vediamo come inserire un gestore di %a out nel contenitore, il metodo della classe container che lo permette void set%a out&%a out#anager mgr', *isogna solo vedere come l'oggetto di tipo %a out#anager. %a out#anager una interfaccia, tra le calssi che la implementano vedremo 0rid%a out, Rlow%a out. 7siste un'altra interfaccia denominata %a out#anager=, che estende questa, e che ha altre classi che la implementano, di queste vedremo9 +ard%a out, -order%a out, 0rid-ag%a out, -o"%a out, Overla %a out. .uindi nel metodo set%a out &S' possiamo usare come parametro un'oggetto di queste classi. 8 questo punto do**iamo capire qual la differenza tra i vari la out manager. Il Rlow%a out permette di disporre i componenti di un contenitore da sinistra verso destra su un'unica linea.
Der usare il %a out#anager Rlow%a out nell'esempio precedente *asta invocare il metodo set%a out con parametro new Rlow%a out&', e poi i componenti vengono automaticamente inseriti dalla add da destra verso sinistra sulla stessa linea. import ;a9a&a!t&6; public class ContGF/ e8tends Frame { /abel l+ /abel l1 /abel l4 /abel l. /abel l0 ne! /abel($Gtic#etta+$); ne! /abel($Gtic#etta1$); ne! /abel($Gtic#etta4$); ne! /abel($Gtic#etta.$); ne! /abel($Gtic#etta0$);
public ContGF/() { "" uso add( perc#X il Frame X una estensione di Pindo!( c#e a sua "" 9otla estende Container& set/a<out(ne! Flo!/a<out()); add(l+); add(l1); add(l4); add(l.); add(l0); pacA(); s#o!(); } public static 9oid main(String BC arg) { ne! ContGF/();
:::...
} } %a finestra risultante 9
:::...
Il 0rid%a out permette di disporre i componenti in un contenitore come se fossero disposti su una griglia.
!utti i componenti assumeranno a stessa dimensione. %a classe ha tre costruttori, uno senza parametri che crea una griglia di < riga, praticamente un Rlow%a out, e altri due che permettono di specificare la dimensione della griglia. %'esempio precedente cam*ia cosH9 import ;a9a&a!t&6; public class ContGH/ e8tends Frame { /abel l+ /abel l1 /abel l4 /abel l. /abel l0 ne! /abel($Gtic#etta+$); ne! /abel($Gtic#etta1$); ne! /abel($Gtic#etta4$); ne! /abel($Gtic#etta.$); ne! /abel($Gtic#etta0$);
public ContGH/() { "" uso add( perc#X il Frame X una estensione di Pindo!( c#e a sua "" 9otla estende Container& set/a<out(ne! Hrid/a<out(1(4)); add(l+); add(l1); add(l4); add(l.); add(l0); pacA(); s#o!(); }
:::...
public static 9oid main(String BC arg) { ne! ContGH/(); } } Il risultato la seguente finestra9
:::...
Il %a out#anager +ard%a out permette di visualizzare componenti diversi in tempi diversi, ovvero esso visualizza solo un componente alla volta, ma il componente visualizzato pu3 essere cam*iato. 7cco un esempio dell'uso di +ard%a out import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class ContGC/ e8tends Frame { /abel l+ /abel l1 /abel l4 /abel l. /abel l0 ne! /abel($Gtic#etta+$); ne! /abel($Gtic#etta1$); ne! /abel($Gtic#etta4$); ne! /abel($Gtic#etta.$); ne! /abel($Gtic#etta0$);
*anel p ne! *anel(ne! Hrid/a<out(1(+)); Card/a<out C/ ne! Card/a<out(+.(+.); *anel p+ ne! *anel(C/); *anel %*: ne! *anel(ne! Flo!/a<out()); public ContGC/() {
p&add(%*:); p&add(p+); :utton % ne! :utton($*rossimo$); :utton * ne! :utton($*recedente$); %*:&add(*); %*:&add(%); *&addAction/istener(ne! Action/istener() { public 9oid action*er5ormed(ActionG9ent e) { C/&pre9ious(p+); } } ); %&addAction/istener(ne! Action/istener()
:::...
{ public 9oid action*er5ormed(ActionG9ent e) { C/&ne8t(p+); } } ); p+&add($uno$(l+); p+&add($due$(l1); p+&add($tre$(l4); p+&add($=uattro$(l.); p+&add($cin=ue$(l0); add(p); pacA(); s#o!(); } public static 9oid main(String BC arg) { ne! ContGC/(); } } Il risultato dell' esempietto sono le seguenti finestre9
:::...
:::...
:::...
+he mostrano come le cinque etichette vengono mostrate nella stessa posizione in tempi differenti. (a notare nell'esempio che sono stati usati anche altri gestori di %a out, questo per inserire i *ottoni Drossimo e Drecedente. -order%a out uno dei gestori di %a out pi) usati, esso permette di inserire in un contenitore cinque componenti, uno a 6ord del contenitore, uno a :ud, uno a 7st , uno ad Ovest, ed uno al centro. %a dimensione del contenitre verr data dal componente centrale, le cinque posizioni sono indicate dalle costanti della classe9 :order/a<out&%>?2U :order/a<out&S>F2U :order/a<out&GAS2 :order/a<out&PGS2 :order/a<out&CG%2G? 7cco un'esempio di uso di -order%a out. 6ell'esempio ho cam*iato i colori di sfondo delle etichette per far vedere il componente intero. import ;a9a&a!t&6; public class ContG:/ e8tends Frame { /abel l+ /abel l1 /abel l4 /abel l. /abel l0 ne! /abel($Gtic#etta a %ord$(/abel&CG%2G?); ne! /abel($Gtic#etta a Sud$(/abel&CG%2G?); ne! /abel($Gtic#etta a Gst$(/abel&CG%2G?); ne! /abel($Gtic#etta a >9est$(/abel&CG%2G?); ne! /abel($Gtic#etta al Centro$(/abel&CG%2G?);
public ContG:/() { "" uso add( perc#X il Frame X una estensione di Pindo!( c#e a sua "" 9otla estende Container& l+&set:acAground(Color&pinA); l1&set:acAground(Color&lig#tHra<); l4&set:acAground(Color&green); l.&set:acAground(Color&<ello!); l0&set:acAground(Color&orange); set/a<out(ne! :order/a<out()); add(l+(:order/a<out&%>?2U); add(l1(:order/a<out&S>F2U); add(l4(:order/a<out&GAS2); add(l.(:order/a<out&PGS2); add(l0(:order/a<out&CG%2G?); pacA(); s#o!(); } public static 9oid main(String BC arg)
:::...
{ ne! ContG:/(); } } Il risultato 9
:::...
7sistono anche altri gestori di %a out, che non vedremo, che per3 potete studiare insieme a questi nella documentazione ufficiale delle Java (evelopment ;it.
LEZIONE "3:
5n menu in una applicazione non altro che una #enu-ar in cui vi sono vari menu. :i pensi ad un programma qualsiasi con le voci di menu Rile 7dit ed Help, queste tre voci In Java sono degli oggetti della classe #enu, e vanno aggiunte ad un oggetto della classe #enu-ar il quale va attaccato alla finestra. Ogni menu ha varie voci, ad esempio il menu Rile avr le voci9 8pri, +hiudi, :alva e 7sci, questi in Java sono degli oggetti della classe #enuItem &o anche #enu se conterranno altri sottomenu'.
&enu
.uindi se ad una applicazione vogliamo aggiungere un men) do**iamo in qualche ordine fare le seguenti cose9

+reare gli oggetti #enuItem +reare gli oggetti menu ed attaccarvi i #enuItem +reare una #enu-ar e attaccare i #enu 7 poi *isogna al solito scrivere dei gestori per gli eventi provenienti dai menu ed associarli ai menu. /ediamo in pratica come si costruisce un menu, iniziamo dai #enuItem9 0li eventi dei #enuItem sono quelli che devono essere gestiti da noi, a differenza degli eventi dei menu che li gestisce il sistema, infatti mentre i secondi servono a fare apparire e scomparire le voci di menu, i primi sono i clic$ sul comando corrispondente all'Item. .uindi per questi dovremo scrivere degli 8ction%istener, come per i *ottoni, infatti essi non sono altro che dei *ottoni speciali. I costruttori sono tre9 MenuItem() , che costruisce un #enuItem senza etichetta. MenuItem(String label), che costruisce un #enuItem con etichetta la*el. MenuItem(String label( MenuS#ortcut s), che costruisce un #enuItem con etichetta la*el e accelleratore &tasto di scelta rapida' definito in #enu:hortcut s. 8lcuni metodi sono9 addAction/istener(Action/istener l), associa un 8ction%istener al #enuItem per sentirne gli eventi di tipo
:::...
:::...
8ction7vent &il clic$'. 9oid deleteS#ortcut(), cancella il tasto di scelta rapida per il menuitem. String getActionCommand(), da l'azione associata al #enuItem, l'azione quella passata alll'action%istener del *ottone per identificare il *ottone stesso, infatti pi) item possono avere lo stesso gestore di eventi, il quale potr distinguere il *ottone cliccato in *ase al comandoo che gli arriva. String get/abel(), restituisce l'etichetta del #enuItem G9ent/istenerBCget/isteners(Class listener2<pe) , restituisce tutti gli ascoltatori di eventi associati al #enuItem, deltipo listener! pe. MenuS#ortcut getS#ortcut(), restituisce la definizione dell'acceleratore per il #enuItem. boolean isGnabled(), dice se il menu a*ilitato o meno, se disa*ilitato verr visualizzato ingrigito. 9oid remo9eAction/istener(Action/istener l), elimina l'ascoltatore associato. 9oid setActionCommand(String command), setta il comando associato al #enuItem, se non specificato, il comando l'etichetta del #enuItem. 9oid setGnabled(boolean b), a*ilita e disa*ilita il #enuItem. 9oid set/abel(String label), setta l'etichetta per il #enuItem. 9oid setS#ortcut(MenuS#ortcut s), definisce l'acceleratore per il menu. .uindi per creare gli Item del menu Rile descritto prima dovremo scrivere9 MenuItem apri ne! MenuItem($Apri$); MenuItem c#iudi ne! MenuItem($C#iudi$); MenuItem sal9a ne! MenuItem($Sal9a$); MenuItem esci ne! MenuItem($Gsci$); +reiamo quindi l'oggetto #enu per attaccare i #enuItem. (ue costruttori dell'oggetto sono9 Menu(), costruisce un #enu senza etichetta Menu(String label), costruisce un menu con etichetta la*el. !ra i metodi ci sono9 MenuItem add(MenuItem mi), che aggiunge un #enuItem al #enu. 9oid add(String label), cheaggiunge un'etichetta al #enu &tipo separatore'. 9oid addSeparator(), aggiunge un vero e proprio separatore al menu, ovvero una linea. 8ggiungendo oggetti ad un men) in questo modo, essi verranno posizionati nello stesso ordine in cui vengono aggiunti. Der specificare invece la posizione in cui si vogliono inserire *isogna usare i metodi9 9oid insert(MenuItem menuitem( int inde8) 9oid insert(String label( int inde8) 9oid insertSeparator(int inde8) I metodi #enuItem getItem&int inde"' e int getItem+ount&' servono per prendere un item data una posizione e per sapere il numero di #enuItem inseriti in un menu. Der rimuovere gli Item dal menu invece si usano i metodi9 9oid remo9e(int inde8) 9oid remo9e(MenuComponent item) e 9oid remo9eAll() Ruindi per creare il nostro menV File scri9eremoL Menu 5ile ne! Menu($File$); 5ile&add(apri); 5ile&add(sal9a); 5ile&add(c#iudi); 5ile&addSeparator(); 5ile&add(esci); 8 questo punto supponendo di avere creato anche 7dit ed Help, do*iamo aggiungerli ad una #enu-ar, la quale si crea usando il costruttore #enu-ar&'. In questa ci sono i metodi remove e remove8ll come per i menu, e c' la add9 Menu add(Menu m);
:::...
.uindi la nostra #enu-ar sar creata nel seguente modo9 Menu:ar barra ne! Menu:ar(); barra&add(5ile); barra&add(edit); barra& setUelpMenu(#elp); .uest'ultimo metodo un metodo speciale per aggiungere un menu di aiuto.
:::...
Infine non rimane che associare la *arra di menu alla nostra finestra, questo semplicissimo, perch la nostra finestra sar una estensione di Rrame, e in Rrame c' il metodo9 setMenu:ar(Menu:ar mb); 6el nostro caso sar set#enu-ar &*arra'M 8!!76`IO679 con awt non possi*ile inserire menu in (ialog e in 8pplet &quelle che si vedono in giro sono dei finti menu, ovvero sono programmati disegnando dei menu, oppure non sono solo awt', mentre con swing si. (i seguito c' il listato di una applicazione che definisce un menu e ne sente gli eventi9 import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class Finestramenu e8tends Frame { MenuItem apri ne! MenuItem($Apri$); MenuItem c#iudi ne! MenuItem($C#iudi$); MenuItem sal9a ne! MenuItem($Sal9a$); MenuItem esci ne! MenuItem($Gsci$); MenuItem taglia ne! MenuItem($2aglia$); MenuItem copia ne! MenuItem($Copia$); MenuItem incolla ne! MenuItem($Incolla$); MenuItem cancella ne! MenuItem($Cancella$); MenuItem cerca ne! MenuItem($Cerca$); MenuItem rimpiazza ne! MenuItem($?impiazza$); MenuItem aiuto ne! MenuItem($Indice$); Menu 5ile ne! Menu($File$); Menu edit ne! Menu($Gdit$); Menu #elp ne! Menu($Uelp$); Menu:ar barra ne! Menu:ar();
/abel risultato ne! /abel($%essuna 9oce di menu cliccata$); public Finestramenu() { setupG9enti(); 5ile&add(apri); 5ile&add(sal9a); 5ile&add(c#iudi); 5ile&addSeparator(); 5ile&add($Menu Fscita$); 5ile&addSeparator(); 5ile&add(esci); edit&add(taglia); edit&add(copia);
:::...
edit&add(incolla); edit&add(cancella); edit&addSeparator(); edit&add(cerca); edit&add(rimpiazza); #elp&add(aiuto); barra&add(5ile); barra&add(edit); barra&setUelpMenu(#elp); setMenu:ar(barra); add(risultato); pacA(); s#o!(); addPindo!/istener(ne! FinestramenuPindo!/istener()); } 9oid setupG9enti() { apri&addAction/istener(ne! AscoltatoreMenu()); sal9a&addAction/istener(ne! AscoltatoreMenu()); c#iudi&addAction/istener(ne! AscoltatoreMenu()); esci&addAction/istener(ne! AscoltatoreMenu()); taglia&addAction/istener(ne! AscoltatoreMenu()); copia&addAction/istener(ne! AscoltatoreMenu()); incolla&addAction/istener(ne! AscoltatoreMenu()); cancella&addAction/istener(ne! AscoltatoreMenu()); cerca&addAction/istener(ne! AscoltatoreMenu()); rimpiazza&addAction/istener(ne! AscoltatoreMenu()); aiuto&addAction/istener(ne! AscoltatoreMenu()); } public static 9oid main(StringBC arg) { ne! Finestramenu(); } class AscoltatoreMenu implements Action/istener { public 9oid action*er5ormed (ActionG9ent e) { risultato&set2e8t($ Cliccato $Ee&getActionCommand()); i5 (e&getActionCommand()&compare2o($Gsci$) ') S<stem&e8it('); } } class FinestramenuPindo!/istener implements Pindo!/istener { public 9oid !indo!Acti9ated(Pindo!G9ent e)
:::...
:::...
{ S<stem&out&println($Sentito un Pindo! Acti9ated$); } public 9oid !indo!Closed(Pindo!G9ent e) { S<stem&out&println($Sentito un Pindo! Closed$); } public 9oid !indo!Closing(Pindo!G9ent e) { S<stem&out&println($Sentito un Pindo! Closing$); S<stem&e8it('); } public 9oid !indo!@eacti9ated(Pindo!G9ent e) { S<stem&out&println($Sentito un Pindo! @eacti9aded$); } public 9oid !indo!@eiconi5ied(Pindo!G9ent e) { S<stem&out&println($Sentito un Pindo! @eiconi5ied$); } public 9oid !indo!Iconi5ied(Pindo!G9ent e) { S<stem&out&println($Sentito un Pindo! Iconi5ied$); } public 9oid !indo!>pened(Pindo!G9ent e) { S<stem&out&println($Sentito un Pindo! >pened$); } } }
:::...
+ome si vede, nell'esempio c' un altro ascoltatore di eventi. .uesto sente eventi di tipo 2indow7vent, e serve per ascoltare eventi della finestra. Der associarlo alla finestra si usa il metodo add2indow%istener&2indow%istener l'M dove 2indow%istener l'ascoltatore di eventi. Der definire un ascoltatore di eventi *isogna quindi implementare l'interfaccia 2indow%istener e ridefinirne tutti i metodi9 class MI>ASC>/2A2>?G implements Pindo!/istener I metodi da ridefinire sono9 public 9oid !indo!Acti9ated(Pindo!G9ent e) public 9oid !indo!Closed(Pindo!G9ent e) public 9oid !indo!Closing(Pindo!G9ent e) public 9oid !indo!@eacti9ated(Pindo!G9ent e) public 9oid !indo!@eiconi5ied(Pindo!G9ent e) public 9oid !indo!Iconi5ied(Pindo!G9ent e) public 9oid !indo!>pened(Pindo!G9ent e) -isogna ridefinirli tutti. :e si manda in esecuzione l'esempio si vede, grazie alle : stem.out.println messe nei metodi ridefiniti, a quale tipo di evento sulla finestra sono associati i vari metodi, come ad esempio window+losed invocato quando si preme la 1 della finestra. Der esercizio provare a scrivere dei 2indow%istener per ascoltare l'evento chiudi Rinestra per tutti i Rrame definiti negli esempi di questo capitolo &li ho lasciati volutamente senza'.
:::...
:::...
I menu visti non sono gli unici menu implementa*ili in Java, un altro tipo di men) il menu di tipo Dopup, ovvero quel menu che si associa ad un componente o ad una posizione. 5n esempio di menu popup il menu che viene fuori sul des$top del sistema operativo 2indows quando si preme il *ottone destro del mouse &Rigura sotto'.
Der creare un menu popup *isogna creare un oggetto appartenente alla classe Dopup#enu, usando uno dei cosrtuttori9 Dopup#enu&', Dopup#enu&:tring la*el', che creano rispettivamente un menu senza e con etichetta. Dopup#enu una estensione di #enu, quindi ne eredita i metodi e anche quelli per aggiungere ed eliminare dei #enuItem. !ra i suoi metodi invece ce n' uno per visualizzare il menu in una data posizione dello schermo rispetto ad un dato componente9 show&+omponent origin, int ", int '
LEZIONE "4:
:pesso nelle interfacce dei nostri 8pplet ci capita di dover fare effettuare all'utente una o pi) scelte tra varie possi*ilit. Der fare questo do**iamo elencare le possi*ilit e poi leggere la scelta. Der fare questo possiamo usare le liste, che rapresentano una serie di oggetti e danno la possi*ilit di sceglierne alcuni. Densiamo ad esempio ad un' applet che gestisce le prenotazioni di visite guidate ad alcune localit, e che faccia scegliere tra tutte quelle che si vogliono visitare. Oltre alle solite form per il 6ome, +ognome ecc.. avremo la lista delle localit, vediamo come possiamo implementarla. Der costruire la lista useremo uno dei tre costruttori9 /ist() , crea una nuova lista /ist(int ro!s), crea una nuova lista con rows linee /ist(int ro!s, *oolean multiple#ode', crea una nuova lista con rows linee, e le dice che a seconda del valore *ooleano multiple#ode si potranno scegliere uno o pi) elementi della lista. 6el nostro caso useremo la terza forma di costruttore. /ist lista ne! /ist('(true); 8lcuni metodi che possiamo usare sulle liste sono i seguenti9 9oid add(String item) e 9oid add(String item( int inde8), per appendere alla fine della lista, oppure in una data posizione un nuovo componente. 9oid addAction/istener(Action/istener l), per associare un 8ction%istener alla lista. 9oid addItem/istener(Item/istener l), per associare un Item%istener alla lista. String getItem(int inde8), per avere l'elemento in posizione indicata. int getItemCount() , per avere il numero di elementi. StringBC getItems(), per avere tutti gli elementi. G9ent/istenerBC get/isteners(Class listener2<pe) , per avere gli ascoltatori associati alla lista del tipo voluto. @imension getMinimumSize(), da la dimensione minima della lista. @imension get*re5erredSize(), da la dimensione preferita per la lista. int get?o!s() , dice il numero di linee attualmente visi*ili nella lista. Int getSelectedInde8(), da l'indice dell'elemento selezionato. intBC getSelectedInde8es(), da gli indici degli elementi selezionati. String getSelectedItem(), da l'oggetto selezionato. StringBCgetSelectedItems(), da gli oggetti selezionati. >b;ectBC getSelected>b;ects(), da la lista degli elementi selezionati in un vettore di oggetti. boolean isInde8Selected(int inde8), dice se l'indice selezionato. boolean isMultipleMode(), dice se nella lista si possono selezionare pi) elementi. 9oid maAe3isible(int inde8), visualizza l'item in posizione indicata. 9oid remo9e(int position), void remove&:tring item', eliminano gli elementi indicati dall'indice o dall'etichetta.
Liste e scelte
:::...
:::...
9oid remo9eAll(), elimina tutti gli elementi della lista. 9oid remo9eAction/istener(Action/istener l) e 9oid remo9eItem/istener(Item/istener l), eliminano gli ascoltatori di eventi definiti per la lista. 9oid replaceItem(String ne!3alue( int inde8), modifica l'elemento specificato. 9oid select(int inde8), seleziona l'elemento indicato nella lista. 9oid setMultipleMode(boolean b), dice alla lista se possi*ile selezionare solo un'elemento o pi) di uno. /ediamo l'esempio sull'uso delle liste. import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; public class liste e8tends Frame { /ist lista ne! /ist('(true); /abel te8t ne! /abel($:ellezze c#e possono essere 9isitate nella localit scelta$); public liste() { super($Scelta itinerario$); lista&add($:ene9ento$); lista&add($Foiano di 3al Fortore$); lista&add($:aselice$); lista&add($San :artolomeo in Haldo$); lista&add($San Marco dei Ca9oti$); lista&add($Monte5alcone in 3al Fortore$); lista&add($*esco Sannita$); lista&add($Colle Sannita$); lista&add($Castel9etere in 3al Fortore$); lista&add($Castel5ranco in Miscano$); lista&add($Hinestra degli Sc#ia9oni$); lista&add($San Hiorgio la Molara$); lista&add($Molinara$); lista&add($*ietrelcina$); lista&add($Fragneto Mon5orte$); lista&add($Circello$); lista&add($Campolattaro$); add(lista(:order/a<out&CG%2G?); add(te8t(:order/a<out&S>F2U); addPindo!/istener(ne! listePindo!/istener()); lista&addItem/istener(ne! ascolta/ista()); setSize(40'(+''); set?esizable(5alse); s#o!(); } public static 9oid main(String BC arg) { ne! liste(); } class listePindo!/istener implements Pindo!/istener {
:::...
public 9oid !indo!Acti9ated(Pindo!G9ent e) {} public 9oid !indo!Closed(Pindo!G9ent e) {} public 9oid !indo!Closing(Pindo!G9ent e) { StringBC s lista&getSelectedItems(); int i '; S<stem&out&println($Itinerario selezionato$); tr< { !#ile (true) { S<stem&out&println(sBiEEC); } } catc# (Arra<Inde8>ut>5:oundsG8ception er) {S<stem&out&println($:uon di9ertimento&&&$);} S<stem&e8it('); } public 9oid !indo!@eacti9ated(Pindo!G9ent e) {} public 9oid !indo!@eiconi5ied(Pindo!G9ent e) {} public 9oid !indo!Iconi5ied(Pindo!G9ent e) {} public 9oid !indo!>pened(Pindo!G9ent e) {} } class ascolta/ista implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) { int indice ((Integer) e&getItem())&int3alue();
:::...
i5 (indice ') te8t&set2e8t($?occa dei ?ettori( arco di 2raiano( an5iteatro ?omano( citt spettacolo$); i5 (indice +) te8t&set2e8t($localit San Hio9anni( Campanile( 9ia ?oma( lago( 5esta S&Hio9anni( 5esta dell)emigrante$); i5 (indice 1) te8t&set2e8t($oasi di San /eonardo$); i5 (indice 4) te8t&set2e8t($centro storico$); i5 (indice .) te8t&set2e8t($centro storico$); i5 (indice 0) te8t&set2e8t($centro storico$); i5 (indice S) te8t&set2e8t($centro storico$); i5 (indice -) te8t&set2e8t($centro storico$); i5 (indice T) te8t&set2e8t($centro storico$); i5 (indice ,) te8t&set2e8t($:osco$); i5 (indice +') te8t&set2e8t($centro storico$); i5 (indice ++) te8t&set2e8t($/ago di San Hiorgio$);
:::...
i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice } } }
:::...
+1) te8t&set2e8t($centro storico$); +4) te8t&set2e8t($*iana ?omana( centro storico( case di *adre *io$); +.) te8t&set2e8t($?aduno internazionale di mongol5iere( palazzo @ucale$); +0) te8t&set2e8t($centro storico$); +S) te8t&set2e8t($@iga di Campolattaro$);
%e liste sono quindi un *uon 05I per fare effettuare all'utente una scelta fra varie possi*ilit. /i un altro 05I che serve a fare questo, che in pratica una lista a scomparsa, nel senso che visi*ile solo l'oggetto selezionato, e che si vedono gli altri solo quando si deve fare la scelta, tipo men) a scomparsa, mentre nelle liste sono sempre visi*ili. Il 05I di cui sto parlando il +hoice &scelta', il cui funzionamento simile a quello delle liste. Il costruttore uno, senza parametri, mentre i metodi sono9 9oid add(String item), aggiunge una possi*ilit in fondo alle scelte possi*ili. 9oid addItem(String item), come la add 9oid addItem/istener(Item/istener l), associa un ascoltatore di eventi per la +hoice. String getItem(int inde8), restituisce la scelta possi*ile che si trova all'indice i. int getItemCount(), da' il numero di possi*ilit per la +hoice. G9ent/istenerBC get/isteners(Class listener2<pe), da tutti gli ascoltatori associati alla +hoice. int getSelectedInde8(), restituisce l'indice della scelta selezionata nella +hoice. String getSelectedItem(), restituisce la scelta selezionata nella +hoice. >b;ectBC getSelected>b;ects(), da tutti gli item selezionati. 9oid insert(String item( int inde8), inserisce una scelta nella posizione indicata della +hoice. 9oid remo9e(int position)( 9oid remo9e(String item)( 9oid remo9eAll() , per rimuovere le scelte possi*ili dalla lista di scelte. 9oid remo9eItem/istener(Item/istener l), elimina l'ascoltatore di eventi di tipo Item%istener associato alla +hoice. 9oid select(int pos), void select&:tring str', per selezionare una scelta. Racciamo un programmino che usi le +hoice, per3 visto che finora a**iamo creato delle applicazioni a finestre, creiamo un'applet, visto che e 05I, come gi detto, possono essere usate in am*edue i tipi di programmi. Darlando di applet, visto che non lo a**iamo fatto finora, creiamo un applet che legge i parametri passatigli dal file html che lo invoca, come fanno in pratica la maggior parte degli applet presenti sul sito html.it. 6ell'applet, a titolo di esempio ho messo un piccolo controllo sul campo autore, questo solo per farvi vedere come si pu3 fare. %a cosa pu3 risultare utile se si crea un'applet e la si distri*uisce, in modo da lasciare o**ligatorio il parametro autore e il suo valore, per evitare che altri possano spacciarsi per il ceratore dell'applet, e quindi per affermare i diritti di cerazione dell'applet. Il controllo non sofisticato, un hac$er lo evitere**e facilmente, per3 un hac$er non ha interesse di crac$are un programma free, solo per eliminare i diritti d'autore, mentre per un utente normale impossi*ile eseguire il programma senza specificare il nome dell'autore. .uel nome pu3 anche essere ad esempio un numero di serie, se si vuole vendere un programma. Il file html, si chiamer +hoice.html, ed il suo contenuto sar9 [#tml7 [#ead7 [title7 Gsempio di uso della ;a9a&a!t&C#oice e del passaggio di parametri ad un applet ["title7 ["#ead7 [bod<7 [A**/G2 code $Scelte&class$ !idt# 40' #eig#t +''7 [param name loc+ 9alue $:ene9ento$7 [param name loc1 9alue $Foiano di 3al Fortore$7
:::...
[param name [param name [param name [param name [param name [param name [param name [param name [param name [param name [param name [param name [param name [param name [param name ["A**/G27 ["bod<7 ["#tml7 #entre il codice dell'applet, editato nel file chiamato :celte.>ava, 9 import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; import ;a9a&applet&6; public class Scelte e8tends Applet { /abel te8t ne! /abel($:ellezze c#e possono essere 9isitate nella localit scelta$); C#oice scelte ne! C#oice(); public 9oid init() { loc4 9alue $:aselice$7 loc. 9alue $San :artolomeo in Haldo$7 loc0 9alue $San Marco dei Ca9oti$7 locS 9alue $Monte5alcone in 3al Fortore$7 loc- 9alue $*esco Sannita$7 locT 9alue $Colle Sannita$7 loc, 9alue $Castel9etere in 3al Fortore$7 loc+' 9alue $Castel5ranco in Miscano$7 loc++ 9alue $Hinestra degli Sc#ia9oni$7 loc+1 9alue $San Hiorgio la Molara$7 loc+4 9alue $Molinara$7 loc+. 9alue $Fragneto Mon5orte$7 loc+0 9alue $Circello$7 loc+S 9alue $Campolattaro$7 autore 9alue $*ietro Castellucci$7
:::...
"" Controllo diritti di autoreL String autore get*arameter($autore$); i5 (autore null) S<stem&e8it('); i5 (autore&compare2o($*ietro Castellucci$)W ') { S<stem&out&println($*arametro autore non 9alido( inserire come 9alore *ietro Castellucci$); S<stem&e8it('); } String p get*arameter($loc+$); i5 (p null) p $/ocalit + non de5inita$; scelte&add(p); p get*arameter($loc1$); i5 (p null) p $/ocalit 1 non de5inita$; scelte&add(p); p get*arameter($loc4$); i5 (p null) p $/ocalit 4 non de5inita$; scelte&add(p); scelte&add(p); p get*arameter($loc.$); i5 (p null) p $/ocalit . non de5inita$; scelte&add(p); p get*arameter($loc0$); i5 (p null) p $/ocalit 0 non de5inita$;
:::...
scelte&add(p); p get*arameter($locS$); i5 (p null) p $/ocalit S non de5inita$; scelte&add(p); p get*arameter($loc-$); i5 (p null) p $/ocalit - non de5inita$; scelte&add(p); p get*arameter($locT$); i5 (p null) p $/ocalit T non de5inita$; scelte&add(p); p get*arameter($loc,$); i5 (p null) p $/ocalit , non de5inita$; scelte&add(p); p get*arameter($loc+'$); i5 (p null) p $/ocalit +' non de5inita$; scelte&add(p); p get*arameter($loc++$); i5 (p null) p $/ocalit ++ non de5inita$; scelte&add(p); p get*arameter($loc+1$); i5 (p null) p $/ocalit +1 non de5inita$; scelte&add(p); p get*arameter($loc+4$); i5 (p null) p $/ocalit +4 non de5inita$; scelte&add(p); p get*arameter($loc+.$); i5 (p null) p $/ocalit +. non de5inita$; scelte&add(p); p get*arameter($loc+0$); i5 (p null) p $/ocalit +0 non de5inita$; scelte&add(p); p get*arameter($loc+S$); i5 (p null) p $/ocalit +S non de5inita$; scelte&add(p); p get*arameter($loc+-$); i5 (p null) p $/ocalit +- non de5inita$; scelte&add(p); scelte&addItem/istener(ne! ascoltaC#oice()); "" 3isualizzo la C#oice add(scelte( :order/a<out&CG%2G?); add(te8t( :order/a<out&S>F2U); } class ascoltaC#oice implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) {
:::...
:::...
int indice scelte&getSelectedInde8(); i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice i5 (indice } } }
:::...
') te8t&set2e8t($?occa dei ?ettori( arco di 2raiano( an5iteatro ?omano$); +) te8t&set2e8t($localit San Hio9anni( Campanile( 9ia ?oma( lago$); 1) te8t&set2e8t($oasi di San /eonardo$); 4) te8t&set2e8t($centro storico$); .) te8t&set2e8t($centro storico$); 0) te8t&set2e8t($$); S) te8t&set2e8t($$); -) te8t&set2e8t($$); T) te8t&set2e8t($$); ,) te8t&set2e8t($:osco$); +') te8t&set2e8t($$); ++) te8t&set2e8t($/ago di San Hiorgio$); +1) te8t&set2e8t($$); +4) te8t&set2e8t($*iana ?omana( centro storico( case di *adre *io$); +.) te8t&set2e8t($?aduno internazionale di mongol5iere( palazzo @ucale$); +0) te8t&set2e8t($$); +S) te8t&set2e8t($@iga di Campolattaro$);
%'ultimo componente 05I che vediamo in questa lezione lo :crollDane, ovvero un pannello in cui possi*ile inserire un componente grande a piacere, che deve essere visualizzato a pezzi. %o :crollDane usa due :croll*ar, una orizzontale ed una verticale, per selezionare la parte del 05I che si vuole vedere. (a notare che la :croll*ar un oggetto 05I anch'esso, quindi pu3 essere inserito e gestito nelle proprie applicazioni. 6ello :crollDane si pu3 scegliere se visualizzare le :croll*ar sempre, mai o solo se necessario. 5no :crollDane tipico quello che si usa per visualizzare un file di testo. Ho due tipi di costruttori per l'oggetto9 Scroll*ane(int sbp), crea uno :crollDane con politica di visualizzazione lelle :croll*ar definita da sp*. I valori possi*ili sono 9 Scroll*ane&SC?>//:A?SKA/PANS sempre in vista Scroll*ane&SC?>//:A?SKASK%GG@G@ in vista solo se ce n' *isogno Scroll*ane&SC?>//:A?SK%G3G? mai in vista Scroll*ane(), crea uno :crollDane con politica :crollDane.:+BO%%-8B:N8:N677(7(. !ra i metodi, oltre a quelli per gestire lo :crollDane troviamo quelli di +ontainer e di +omponent, infatti :crollDane una estensione di +ontainer, quindi pu3 essere visto come un contenitore pu3 essere visto come un componente.
LEZIONE "5:
+i rimane da vedere un componente fondamentale per un interfaccia, ovvero il !esto. %e a*stract window !ool$it di Java mettono a disposizione due classi per il testo9 !e"t8rea e !e"tRield, am*edue estendono la classe !e"t+omponent.
Il Testo' gli eventi' (ialog
:::...
:::...
In !e"t+omponent troviamo una serie di metodi utili per la gestione del testo, sia in !e"t8rea che in !e"tRield, tra cui9 Color get:acAground() e set:acAground(Color c), per prendere e settare il colore di -ac$ground del testo. String getSelected2e8t(), prende il testo selezionato. int getSelectionGnd(), da la posizione della fine selezione del testo. Int getSelectionStart(), da la posizione dell'inizio selezione del testo. String get2e8t(), da il testo del !e"t+omponent boolean isGditable(), dice se il testo del componente edita*ile. 9oid select(int selectionStart( int selectionGnd), seleziona il testo da selection:tart a selection7nd. 9oid selectAll(), seleziona tutto il testo. 9oid setGditable(boolean b), setta se il testo edita*ile o meno. 9oid setSelectionGnd(int selectionGnd), setta la fine della selezione del testo. 9oid setSelectionStart(int selectionStart), setta l'inizio della selezione. 9oid set2e8t(String t), setta il contenuto del componente di testo con il valore t. Inoltre in !e"t+omponent si possono usare tutti i metodi di +omponent, ovvero9 action( add( addComponent/istener( addFocus/istener( addUierarc#<:ounds/istener( addUierarc#</istener( addInputMet#od/istener( addae</istener( addMouse/istener( addMouseMotion/istener( add%oti5<( add*ropert<C#ange/istener( add*ropert<C#ange/istener( bounds( c#ecAImage( c#ecAImage( coalesceG9ents( contains( contains( createImage( createImage( deli9erG9ent( disable( disableG9ents( dispatc#G9ent( do/a<out( enable( enable( enableG9ents( enableInputMet#ods( 5ire*ropert<C#ange( getAlignmentM( getAlignmentN( get:ounds( get:ounds( getColorModel( getComponentAt( getComponentAt( getComponent>rientation( getCursor( get@rop2arget( getFont( getFontMetrics( getForeground( getHrap#ics( getHrap#icsCon5iguration( getUeig#t( getInputConte8t( getInputMet#od?e=uests( get/ocale( get/ocation( get/ocation( get/ocation>nScreen( getMa8imumSize( getMinimumSize( get%ame( get*arent( get*eer( get*re5erredSize( getSize( getSize( get2oolAit( get2ree/ocA( getPidt#( getM( getN( gotFocus( #andleG9ent( #asFocus( #ide( imageFpdate( inside( in9alidate( is@ispla<able( is@ouble:u55ered( isGnabled( isFocus2ra9ersable( is/ig#t!eig#t( is>pa=ue( isS#o!ing( is3alid( is3isible( Ae<@o!n( Ae<Fp( la<out( list( list( list( list( list( locate( location( lostFocus( minimumSize( mouse@o!n( mouse@rag( mouseGnter( mouseG8it( mouseMo9e( mouseFp( mo9e( ne8tFocus( paint( paintAll( postG9ent( pre5erredSize( prepareImage( prepareImage( print( printAll( processComponentG9ent( processFocusG9ent( processUierarc#<:oundsG9ent( processUierarc#<G9ent( processInputMet#odG9ent( processae<G9ent( processMouseG9ent( processMouseMotionG9ent( remo9e( remo9eComponent/istener( remo9eFocus/istener( remo9eUierarc#<:ounds/istener( remo9eUierarc#</istener( remo9eInputMet#od/istener( remo9eae</istener( remo9eMouse/istener( remo9eMouseMotion/istener( remo9e*ropert<C#ange/istener( remo9e*ropert<C#ange/istener( repaint( repaint( repaint( repaint( re=uestFocus( res#ape( resize( resize( set:ounds( set:ounds( setComponent>rientation( setCursor( set@rop2arget( setGnabled( setFont( setForeground( set/ocale( set/ocation( set/ocation( set%ame( setSize( setSize( set3isible( s#o!( s#o!( size( toString( trans5erFocus( update( 9alidate /ediamo quindi i !e"tRield. 5n !e"tRield in pratica una singola linea di testo edita*ile, con un aspetto grafico, uno di quei campi che siamo a*ituati a vedere nelle Rorm che si trovano su internet per immettere nomi, cognomi, ecc. Ho quattro possi*ili costruttori9 2e8tField(), crea una !e"tRield vuota. 2e8tField(int c), crea una !e"tRield vuota di c colonne, ovvero una linea di c caratteri. 2e8tField(String t), crea una !e"tRield inizializzata con t. 2e8tField(String t( int c), crea una !e"tRield inizializzata con t, di c caratteri. !ra i vari metodi, quelli pi) interessanti per i nostri scopi, sono9
:::...
boolean ec#oC#arIsSet(), dice se la !e"tRield fa l'echo dei caratteri inseriti. int getColumns(), da il numero di colonne della !e"tRield. c#ar getGc#oC#ar(), da il carattere usato per l'echo. 9oid setColumns(int columns), setta il numero di colonne della !e"tRield. 9oid setGc#oC#ar(c#ar c), setta il carattere di echo per la !e"tRield. 9oid set2e8t(String t), per settare il testo contenuto. Der le dimensioni9 @imension getMinimumSize() @imension getMinimumSize(int c) @imension get*re5erredSize() @imension get*re5erredSize(int c)
:::...
%a !e"t8rea invece un vero e proprio testo, non solo una riga, ma tante, comprende anche le due scroll*ar per navigare sul testo se questo pi) grande della finestra dove visualizzato. I costruttori sono9 2e8tArea(), costruisce una nuova !e"t8rea. 2e8tArea(int r( int c) , costruisce una nuova !e"t8rea, di r righe e c colonne. 2e8tArea(String te8t), costruisce una nuova !e"t8rea inizializzata con il testo passato. 2e8tArea(String te8t( int ro!s( int columns) , costruisce una nuova !e"t8rea inizializzata con il testo passato, di r righe e c colonne. 2e8tArea(String te8t( int ro!s( int columns( int scrollbars), come il precedente, solo che permette di specificare la politica di visualizazione delle scroll*ar. /ediamone alcuni metodi9 9oid append(String str), appende il testo passato alla !e"t8rea. &nelle vecchie versioni di Java append!e"t &:tring str''. int getColumns()( int get?o!s() per avere informazioni sul numero di colonne o righe. 9oid insert(String str( int pos), inserisce il testo passato nella posizione passata. &nelle vecchie versioni di Java insert!e"t&:tring str''. 9oid replace?ange(String str( int start( int end), rimpiazza il testo da start a end con la stringa passata. 9oid setColumns(int columns) e 9oid set?o!s(int ro!s) per settare il numero di colonne o righe della !e"t8rea. Der le dimensioni dell'oggetto 05I9 @imension getMinimumSize() @imension getMinimumSize(int ro!s( int columns) @imension get*re5erredSize() @imension get*re5erredSize(int ro!s( int columns) 8**iamo visto tutti i componenti di testo, a questo punto possiamo fare un'esempio che le usa am*edue. +reiamo un'applet, quindi il launcher 9 [#tml7 [#ead7 [title7 Gsempio di uso dei componenti di testo& ["title7 ["#ead7 [bod<7 [A**/G2 code $2esto&class$ !idt# 0'' #eig#t 1''7 [param name testo 9alue $2esto iniziale per la 2e8tArea&Inserire altri caratteri&$7 ["A**/G27 ["bod<7 ["#tml7 mentre il codice, da editare in !esto.>ava, il seguente9
:::...
import ;a9a&a!t&e9ent&ae</istener; import ;a9a&a!t&e9ent&ae<G9ent; import ;a9a&a!t&2e8tField; import ;a9a&a!t&2e8tArea; import ;a9a&a!t&:order/a<out; import ;a9a&applet&6; public class 2esto e8tends Applet { 2e8tField 2F ne! 2e8tField(1'); 2e8tArea 2A ne! 2e8tArea(); public 9oid init() { add(2A(:order/a<out&CG%2G?); add(2F(:order/a<out&S>F2U); String t get*arameter($testo$); i5 (tW null) 2A&set2e8t(t); 2F&setGditable(5alse); 2A&addae</istener(ne! M<ae</istener()); } public class M<ae</istener implements ae</istener { public 9oid Ae<*ressed(ae<G9ent e) { } public 9oid Ae<?eleased(ae<G9ent e) { int 9alore e&getae<Code(); i5 (9aloreW +') 2F&set2e8t($Inserito carattere $Ee&getae<C#ar()); else 2F&set2e8t($Inserito carattere I%3I>$); } public 9oid Ae<2<ped(ae<G9ent e) { } } }
:::...
:::...
...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE "6:
:::...
8**iamo visto quesi tutti i componenti 05I di awt, per costruire una interfaccia *asta com*inare queste e ascoltarne gli eventi. Der ogni 05I vista a**iamo visto come gestire alcuni eventi, vediamo adesso quali altri eventi possono essere ascoltati. Innanzitutto a**iamo ascoltato degli eventi di tipo 8ction7vent, ovvero eventi che consistono nel compiere un'azione sulle gui da parte dell'utente, tipo premere un *ottone. Der fare questo, ricordo che a**iamo implementato l'interfaccia 8ction%istener, e ne a**iamo ridefinito l'unico evento actionDerformed &8ction7vent e', che viene invocato quando viene esequita una azione sul componente 05I &o sui componenti' a cui associato. Der associare al 05I l'ascoltatore di eventi che a**iamo definito a**iamousato il metodo add8ction%istener &8ction%istener ascoltatore' del 05I. De usarli *isogna includere nel programma9 import ;a9a&a!t&e9ent&Action/istener; import ;a9a&a!t&e9ent&ActionG9ent; oppure impore ;a9a&a!t&e9ent&6; 8scoltatori di eventi di tipo 8ction%istener possono essere associati agli oggetti 05I di awt9 :utton /ist &quando si seleziona o deseleziona un elemento' MenuItem 2e8tField 8**iamo visto anche come implementare un Item%istener, per ascoltare eventi provenienti da 05I che hanno uno stato di on4off, quando cam*iano il proprio stato. Der associarlo ad un 05I a**iamo usato addItem%istener&Item%istener ascoltatore' del 05I, quando l'evento generato dal 05I, viene invocato il metodo item:tate+hanged&Item7vent e' dell'ascoltatore associato. (a includere9 import ;a9a&a!t&e9ent&6; oppure import ;a9a&a!t&e9ent&Item/istener; import ;a9a&a!t&e9ent&ItemG9ent; I 05I awt per cui pu3 essere ascoltato l'evento sono9 %hec)'o> C#ecAbo8MenuItem &non lo a**iamo visto, esso come un #enuItem, solo che funziona come un +hec$*o", ovvero pu3 essere cliccato o meno, se associato ad un +hec$*o"0roup, diviene ancora una volta un radio*utton, solo che su un menu'. C#oice /ist 8**iamo anche visto gli ascoltatori degli eventi delle finestre, ovvero di tipo 2indow%istener. 7ssi vengono associati alle finestre usando il metodo di queste add2indow%istener&2indow%istener 2%', e per definirle *isogna implementare l'interfaccia 2indow%istener e ridefinirne i metodi9 9oid !indo!Acti9ated(Pindo!G9ent e), invocato quando la finestra diviene attiva, ovvero viene in primo piano sul des$top. 9oid !indo!Closed(Pindo!G9ent e), invocato quando la finestra si chiusa. 9oid !indo!Closing(Pindo!G9ent e), invocato quando si preme il *ottone chiudiRinestra &1'. 9oid !indo!@eacti9ated(Pindo!G9ent e), invocato quando la finestra passa in secondo piano. 9oid !indo!@eiconi5ied(Pindo!G9ent e), invocato quando la finestra passa da icona ad attiva. 9oid !indo!Iconi5ied(Pindo!G9ent e), quando viene ridotta ad icona. 9oid !indo!>pened(Pindo!G9ent e), quando viene aperta.
La gestione degli eventi in Java)
:::...
Der sentire gli eventi della finestra *isogna includere9 import ;a9a&a!t&e9ent&Pindo!/istener; import ;a9a&a!t&e9ent&Pindo!G9ent; oppure import ;a9a&a!t&e9ent&6;
:::...
0li eventi delle finestre avvengono sempre pi) o meno a coppie, ad esempio quando si preme la 1 in alto a destra della finestre, prima viene invocato window+losing e poi window+losed, oppure quando una finestra passa da icona ad attiva prima sente window(eiconified e poi 2indow8ctivated, eccetera. 7' possi*ile sentire eventi di tipo finestra per gli elementi9 Pindo! Frame @ialog :ulle (ialog apro una piccola parentesi9 :ono dei Rrame senza icona , riduci a icona e massimizza, sonomolto utili per fare appunto dei dialoghi veloci con l'utente, sono ad esempio delle dialog le finestre che appaiono nelle applicazioni e dicono :ei sicuro di volere uscirea 5na (ialog pu3 essere modale o non modale, la prima una (ialog che *locca completamente l'applicazione, la quale non sente pi) gli eventi, la seconda invace va in parallelo a questa. %e dialog di awt non possono contenere dei menu, mentre quelle di swing &>ava".swing.J(ialog' si. /ediamo quali eventi possono essere ascoltati da oggetti di tipo !e"t+omponent, ovvero oggetti di tipo !e"tRield e !e"t8rea. Dossiamo ascoltare eventi di tipo !e"t7vent, implementando l'interfaccia !e"t%istener, e ridefinendone il metodo te"t/alue+hanged&!e"t7vent e', invocato ogni volta che il testo viene modificato. %'interfaccia e l'evento si trovano in >ava.awt.event Der oggetti di tipo container, ovvero per Danel, :crollDane, 2indow &e quindi (ialog e Rrame', posso ascoltare gli eventi sul contenitore, usando il metodo add+ontainer%istener&+ontainer%istener l'. -isogna implementare l'interfaccia +ontainer%istener e ridefinire i metodi9 9oid componentAdded(ContainerG9ent e) 9oid component?emo9ed(ContainerG9ent e) che vengono automaticamente invocati quando vengono aggiunti o tolti elementi al contenitore. -isogna includere >ava.awt.event.+ontainer%istener e >ava.awt.event.+ontainer7vent. 8 questo punto vediamo quali eventi si possono ascoltare su oggetti di tipo +omponent, ovvero su !5!!I i componenti awt, compresi i contenitori e le finestre. In +omponent troviamo i metodi9 addComponent/istener(Component/istener l) addFocus/istener(Focus/istener l) addUierarc#<:ounds/istener(Uierarc#<:ounds/istener l) addUierarc#</istener(Uierarc#</istener l) addInputMet#od/istener(InputMet#od/istener l) addae</istener(ae</istener l) addMouse/istener(Mouse/istener l) addMouseMotion/istener(MouseMotion/istener l) add*ropert<C#ange/istener(*ropert<C#ange/istener listener) add*ropert<C#ange/istener(String propert<%ame( *ropert<C#ange/istener listener) Il +omponent%istener ascolta eventi sul componente, si devono ridefinire i metodi9 9oid componentUidden(ComponentG9ent e) 9oid componentMo9ed(ComponentG9ent e) 9oid component?esized(ComponentG9ent e) 9oid componentS#o!n(ComponentG9ent e)
:::...
:::...
che vengono invocati quando il componente viene nascosto, mosso, cam*iato di dimensioni e visualizzato. Rocus%istener ascolta eventi di focus della tastiera sul componente, ovvero se si seleziona o meno il componente con la tastiera. -isogna ridefinirne i metodi9 5ocusHained(FocusG9ent e), chiamato quando il componente selezionato. 5ocus/ost(FocusG9ent e), chiamato dal componente quando perde la selezione della tastiera. :i pensi ad esempio alla navigazione tra varie form di una interfaccia premendo il tasto !8-. Hierarch -ounds%istener, sente eventi di spostamento degli antenati dal componente, ad esempio un *ottone su una finestra, se implementa questa interfaccia sente se la finestra si muove. -isogna ridefinire i metodi9 9oid ancestorMo9ed(Uierarc#<G9ent e), chiamata quando l'antenato viene mosso. 9oid ancestor?esized(Uierarc#<G9ent e) , chiamata quando l'antenato viene am*iato di dimensione. Hierarch %istener ascolta i cam*iamenti degli antenati del componente, *isogna ridefinire il metodo hierarch +hanged&Hierarch 7vent e', sar Hierarch 7vent a contenere il cam*iamento fatto. ;e %istener lo a**iamo gia visto, ascolta eventi provenienti dalla tastiera, do**iamo ridefinire i metodi 9oid Ae<*ressed(ae<G9ent e), invocato quando un tasto viene premuto. 9oid Ae<?eleased(ae<G9ent e), invocato quando un tasto viene lasciato. 9oid Ae<2<ped(ae<G9ent e), invocato quando un tasto si tiene premuto. In pratica quando si preme un tasto vengono sentiti gli eventi nell'ordine9 $e Dressed, $e ! ped e $e Beleased. #ouse%istener ascolta gli eventi provenienti dal mouse, *isogna ridefinire i metodi9 9oid mouseClicAed(MouseG9ent e), invocato quando viene cliccato un *ottone del muose sul componente. 9oid mouseGntered(MouseG9ent e), invocato quando il mouse entra nel componente. 9oid mouseG8ited(MouseG9ent e), invocato quando il mouse esce dal componente. 9oid mouse*ressed(MouseG9ent e), invocato quando il mouse si tiene premuto sul componente. 9oid mouse?eleased(MouseG9ent e), invocato quando il mouse viene rilasciato. #ouse#otion%istener, altri eventi del mouse sul componente9 mouse@ragged(MouseG9ent e), quando il mouse viene premuto e mosso sul componente. 9oid mouseMo9ed(MouseG9ent e), invocato quando il mouse si muove sul componente, con o senza *ottoni premuti. %'ultima interfaccia per eventi del mouse #ouseInput%istener, che implementa tutte e due le interfacce precedenti, quindi ascolta tutti gli eventi precedenti del mouse. 6ell'esempio successivo vengono ascoltati vari eventi, viene anche usata una (ialog. import ;a9a&a!t&e9ent&6; import ;a9a&a!t&6; class Ascolta e8tends Frame { :utton b+ ne! :utton($:ottone+$); :utton b1 ne! :utton($3isualizza @ialog$); :utton b4 ne! :utton($Gsci$); :utton b. ne! :utton($C#iudi @ialog$); C#oice l+ ne! C#oice(); 2e8tField 2F+ ne! 2e8tField(+0); @ialog @;
:::...
AscoltaAction/istener aal; AscoltaItem/istener ail; AscoltaPindo!/istener a!l; AscoltaPindo!/istener@ialog a!ld; AscoltaMouse/istener aml; Ascoltaae</istener aAl; public Ascolta() { set2itle($Frame( esempio ascoltatori e9enti$); set/ocation(+''(+''); set/a<out(ne! Hrid/a<out(0(+)); add(b+); add(b1); add(b4); add(l+); add(2F+); @ ne! @ialog(t#is(true); @&setSize(1''(+''); @&set/ocation(1''(+''); @&add(b.(:order/a<out&S>F2U); @&set2itle($@ialog - modale$); prepara@(5alse); l+&add($Scelta +$); l+&add($Scelta 1$); l+&add($Scelta 4$); "" Inizializzo gli ascoltatori degli e9enti& aal ne! AscoltaAction/istener(); ail ne! AscoltaItem/istener(); a!l ne! AscoltaPindo!/istener(); a!ld ne! AscoltaPindo!/istener@ialog(); aml ne! AscoltaMouse/istener(); aAl ne! Ascoltaae</istener(); b+&addAction/istener(aal); b1&addAction/istener(aal); b4&addAction/istener(aal); 2F+&addAction/istener(aal); l+&addItem/istener(ail); addPindo!/istener(a!l); addMouse/istener(aml); b+&addMouse/istener(aml); b1&addMouse/istener(aml); b4&addMouse/istener(aml); b.&addMouse/istener(aml); l+&addMouse/istener(aml); 2F+&addMouse/istener(aml); 2F+&add2e8t/istener(ne! 2e8t/istener() { public 9oid te8t3alueC#anged(2e8tG9ent e) { S<stem&out&println($2e8t/istenerL cambiato 9alore della 2e8tField$); } } ); @&addMouse/istener(aml); addae</istener(aAl); b+&addae</istener(aAl); b1&addae</istener(aAl); b4&addae</istener(aAl); b.&addae</istener(aAl); l+&addae</istener(aAl);
:::...
:::...
2F+&addae</istener(aAl); @&addae</istener(aAl); pacA(); s#o!(); } 9oid prepara@(boolean m) { @&setModal(m); } public static 9oid main (String BC s) { S<stem&out&println($Ascolto gli e9enti&$); ne! Ascolta(); } "" Action/istener class AscoltaAction/istener implements Action/istener { public 9oid action*er5ormed(ActionG9ent e) {
:::...
String c e&getActionCommand(); i5 (c&compare2o($:ottone+$) ') S<stem&out&println($Action/istenerL *remuto :ottone+$); else i5 (c&compare2o($Gsci$) ') { S<stem&out&println($Action/istenerL *remuto Gsci$); S<stem&e8it(,); "" X un numero =ualsiasi( si c#iama e8it code& } else i5 (c&compare2o($3isualizza @ialog$) ') { S<stem&out&println($Action/istenerL *remuto 3isualizza @ialog$); @&s#o!(); b.&addAction/istener(aal); b1&remo9eAction/istener(aal); @&addPindo!/istener(a!ld); } else i5 (c&compare2o($C#iudi @ialog$) ') { S<stem&out&println($Action/istenerL *remuto 3isualizza @ialog$); @&#ide(); b.&remo9eAction/istener(aal); b1&addAction/istener(aal); @&remo9ePindo!/istener(a!ld); } else { S<stem&out&println($Action/istenerL *remuto In9io nella 2e8tField( lettoL$E2F+&get2e8t()); 2F+&set2e8t($$); } } } "" Item/istener class AscoltaItem/istener implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) { String 9al l+&getSelectedItem(); S<stem&out&println($Item/istenerL Selezionato $E9al);
:::...
} } "" Pindo!/istener public class AscoltaPindo!/istener implements Pindo!/istener { public 9oid !indo!Acti9ated(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra atti9ata$); } public 9oid !indo!Closed(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra c#iusa$); } public 9oid !indo!Closing(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL *remuto c#iudi 5inestra$); S<stem&e8it('); } public 9oid !indo!@eacti9ated(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra disatti9ata$); } public 9oid !indo!@eiconi5ied(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra deiconi5icata$); } public 9oid !indo!Iconi5ied(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra riduci a icona$); } public 9oid !indo!>pened(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra aperta$); } } public class AscoltaPindo!/istener@ialog implements Pindo!/istener { public 9oid !indo!Acti9ated(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL @ialog atti9ata$); } public 9oid !indo!Closed(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL @ialog c#iusa$); } public 9oid !indo!Closing(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL *remuto c#iudi @ialog$); @&#ide(); b.&remo9eAction/istener(aal); b1&addAction/istener(aal); @&remo9ePindo!/istener(a!ld);
:::...
:::...
} public 9oid !indo!@eacti9ated(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL Finestra disatti9ata$); } public 9oid !indo!@eiconi5ied(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL @ialog deiconi5icata$); } public 9oid !indo!Iconi5ied(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL @ialog riduci a icona$); } public 9oid !indo!>pened(Pindo!G9ent e) { S<stem&out&println($Pindo!/istenerL @ialog aperta$); } } "" Mouse /istenerL class AscoltaMouse/istener implements Mouse/istener { public 9oid mouseClicAed(MouseG9ent e) { Component a e&getComponent(); String n a&get%ame(); S<stem&out&println($Mouse/istenerL Mouse cliccato sul componente $En); } public 9oid mouseGntered(MouseG9ent e) { Component a e&getComponent(); String n a&get%ame(); S<stem&out&println($Mouse/istenerL Mouse entrato nel componente $En); } public 9oid mouseG8ited(MouseG9ent e) { Component a e&getComponent(); String n a&get%ame(); S<stem&out&println($Mouse/istenerL Mouse uscito dal componente $En); } public 9oid mouse*ressed(MouseG9ent e) { Component a e&getComponent(); String n a&get%ame(); S<stem&out&println($Mouse/istenerL il bottone e) sc#iacciato su coponente $En); } public 9oid mouse?eleased(MouseG9ent e) { Component a e&getComponent(); String n a&get%ame(); S<stem&out&println($Mouse/istenerL Mouse rilasciato sul componente $En); } } "" 2astiera class Ascoltaae</istener implements ae</istener { public 9oid Ae<*ressed(ae<G9ent e) { S<stem&out&println($ae</istenerL *remuto tasto $Ee&getae<C#ar()E
:::...
:::...
$ codice $E e&getae<Code()); } public 9oid Ae<?eleased(ae<G9ent e) { S<stem&out&println($ae</istenerL ?ilasciato tasto $Ee&getae<C#ar()E $ codice $E e&getae<Code()); } public 9oid Ae<2<ped(ae<G9ent e) { S<stem&out&println($ae</istenerL Stai premendo il tasto $Ee&getae<C#ar()E $ codice $E e&getae<Code()); } } }
:::...
LEZIONE "7:
Oltre al pac$age >ava.awt, Java mette a disposizione del programmatore il pac$age >ava".swing per creare delle interfacce grafiche. In questo capitolo vedremo perch la :un #icros stem ha creato quest'altro pac$age e quali sono le differenze con awt. Der presentare il pac$age parler3 del programma che sto facendo per la mia !esi in Informatica all'5niversit di Disa. Der informazioni riguardo ad Orespics potete contattare me, oppure le Drof.sse %agan e Bicci presso il dipartimento di Informatica di Disa &+orso Italia, ?@'. Il nome del programma Orespics Drogramming %anguage, ed in pratica un am*iente integrato in cui possi*ile programmare agenti paralleli che comunicano tra di loro scam*iandosi dei messaggi. %'am*iente permette di definire ed eseguire questi agenti, esso si propone come strumento didattico di supporto all'apprendimento delle modalit di programmazione parallela, programmazione che al programmatore a*ituato a programmare in modo sequenziale pu3 risultare molto difficoltosa. Droprio perch lo strumento uno strumento didattico, ha una interfaccia utente 5ser Rriendl . %'interfaccia stata scritta usando il pac$age :wing di Java. :wing stato interamente scrittto in Java, usando il pac$age awt, e mette a disposizione all'utente tante classi presenti anche in awt, ma notevolmente migliorate e potenziate, mette inoltre tante altre classi non presenti in awt. /ediamo quindi quali sono le classi e le interfacce contenute nel pacchetto9 Inter-acce Action :ounded?angeModel :uttonModel CellGditor Combo:o8Gditor Combo:o8Model @esAtopManager Icon DCombo:o8&ae<SelectionManager /istCell?enderer /istModel /istSelectionModel MenuGlement MutableCombo:o8Model ?enderer ?oot*aneContainer Scrollable Scroll*aneConstants SingleSelectionModel S!ingConstants FI@e5aults&Acti9e3alue FI@e5aults&/az<3alue Pindo!Constants %la!!i AbstractAction
Introduzione a s*ing
:::...
Abstract:utton AbstractCellGditor Abstract/istModel ActionMap :orderFactor< :o8 :o8&Filler :o8/a<out :uttonHroup Cell?enderer*ane ComponentInputMap @ebugHrap#ics @e5ault:ounded?angeModel @e5ault:uttonModel @e5aultCellGditor @e5aultCombo:o8Model @e5ault@esAtopManager @e5aultFocusManager @e5ault/istCell?enderer @e5ault/istCell?enderer&FI?esource @e5ault/istModel @e5ault/istSelectionModel @e5aultSingleSelectionModel FocusManager Hra<Filter ImageIcon InputMap Input3eri5ier DApplet D:utton DC#ecA:o8 DC#ecA:o8MenuItem DColorC#ooser DCombo:o8 DComponent D@esAtop*ane D@ialog DGditor*ane DFileC#ooser DFrame DInternalFrame DInternalFrame&D@esAtopIcon D/abel D/a<ered*ane D/ist DMenu DMenu:ar DMenuItem D>ption*ane D*anel D*ass!ordField D*opupMenu D*opupMenu&Separator D*rogress:ar D?adio:utton D?adio:uttonMenuItem D?oot*ane DScroll:ar DScroll*ane DSeparator DSlider DSplit*ane D2abbed*ane D2able D2e8tArea
:::...
:::...
D2e8tField D2e8t*ane D2oggle:utton D2oggle:utton&2oggle:uttonModel D2ool:ar D2ool:ar&Separator D2ool2ip D2ree D2ree&@<namicFtil2ree%ode D2ree&Gmpt<SelectionModel D3ie!port DPindo! ae<StroAe /ooAAndFeel MenuSelectionManager >9erla</a<out *rogressMonitor *rogressMonitorInputStream ?epaintManager Scroll*ane/a<out Scroll*ane/a<out&FI?esource Size?e=uirements SizeSe=uence S!ingFtilities 2imer 2ool2ipManager FI@e5aults FI@e5aults&/az<InputMap FI@e5aults&*ro8</az<3alue FIManager FIManager&/ooAAndFeelIn5o 3ie!port/a<out Eccezioni Fnsupported/ooAAndFeelG8ception
:::...
6otiamo in numero di classi molto superiore di quelle di awt, inoltre notiamo che ci sono tante classi che hanno lo stesso nome di alcune classi di awt, tranne che per una J iniziale, come ad esempio JRrame, J(ialog, eccetera, queste classi hanno lo stesso funzionamento delle analoghe classi di awt, tranne che per il fatto che contengono tanti metodi utili in pi). Dresentiamo alcune delle cose in pi) in swing rispetto ad awt. In swing ci sono le !ool*ar, ovvero delle piccole *arre su cui ci vanno dei *ottoni, esse possono essere spostate all'interno della finestra che le contiene. I *ottoni di swing, come quasi tutti gli altri J+omponent hanno la possi*ilit olre che di avere un'etichetta anche una immagine, immagine che pu3 cam*iare a seconda dello stato del *ottone. Inoltre in swing possono essere usati i !ooltip, ovvero quei suggerimenti che escono automaticamente su un componente quando il mouse vi ci si sofferma per un po di tempo. /ediamo l'effetto di questi componenti swing in Orespics.
6ella Rigura possiamo notare la !ool*ar &in cui ho nascosto i *ordi' di altre Q !ool*ar, una per ogni categoria di *ottoni. :i vedono i *ottoni che contengono delle immagini, alcune attive e altre inattive.
6ella Rigura si pu3 vedere una !ooltip su uno dei *ottoni.
:::...
:::...
6ella Rigura possiamo notare che anche nei menu possono essere inserite delle immagini, rendendoli molto gradevoli all'utente.
%e tool*ar possono essere facilmente nascoste e visualizzate sullo schermo.
6ella Rigura notiamo il cam*iamento dell'immagine del *ottone con il pinguino, che diventa pi) grande, con swing, come gi detto possi*ile cam*iare l'icona a seconda dello stato del *ottone. 8ltri due componenti molto *elli presenti in :wing e non in awt sono i !a**edDane e gli 8l*eri. I primi sono i controlli a schede tipici delle interfacce di 2indows, molto gradevoli, e i secondi fanno vedere delle strutture ad al*ero, tipo qelle che si vedono navigando sugli hard dis$ usando esplora di 2indows. +on swing si pu3 anche cam*iare il cosiddetto %oo$ and Reel della finestra, ovvero il suo aspetto, rendendola simile ad una interfaccia tipica di Java, di 2indows, di #acintosh &se si su una macchina #ac' e di %inu" &1P2indows P #otif'.
+on :wing cam*ia completamente la gestione del testo, infatti si possono creare testi colorati, con vari stili di carattere. !ante altre sono le possi*ilit di :wing, come ad esempio delle (ialog per navigare sui file con delle preview e delle dialog per la scelta dei colori, gi implementate dal pacchetto. #olto interessante secondo me sapere che la dialog di scelta dei colori della Rigura <E viene creata e usata
:::...
con una singola istruzione, ovvero *asta invocare il metodo9 static D@ialog create@ialog(Component c( String title( boolean modal( DColorC#ooser c#ooser*ane( Action/istener oA/istener( Action/istener cancel/istener) della classe J+olor+hooser.
:::...
+omunque credo di avere fatto capire quali sono le potenzialit del pacchetto, pacchetto che per3 ancora non stato incluso nelle versioni di Java dei *rowser, e che quindi non ancora possi*ile creare delle applet swing senza caricare plugins nei sopracitati *rowser. 6ei testi di swing possi*ile inserire anche immagini, e inoltre si possono leggere e decodificare direttamente file di tipo html, rtf &5n cugino del .doc'. In :wing c' la classe Jdialog, analoga alla 8pplet di >ava.applet, essa ne una estensione, e presenta, oltre ai metodi della class 8pplet &di cui una estensione', altri metodi molto interessanti, tra cui il metodo void setJ#enu-ar&J#enu-ar menu-ar'. Ovviamente siccome ci sono tanti 05I in pi) in swing, c' la necessit di gestirne gli eventi, esiste quindi il sottopacchetto >ava".swing.event che estende gli eventi di >ava.awt.event per gestire gli eventi dei componenti di swing.
LEZIONE "8:
6el capitolo precedente a**iamo visto come usare i componenti 05I di 8*stract 2indow !ool$it per costruire delle interfacce utente grafiche per i nostri programmi, e a**iamo detto che un componente 05I in sostanza un oggetto con delle qualit grafiche. Il componente 05I un componente di alto livello del pacchetto awt, esso costruito usando i componenti a *asso livello del pacchetto, ovvero le primitive grafiche, e gli eventi. Densiamo ad esempio ad un *ottone, esso graficamente non altro che una scatola con un testo all'interno, che cam*ia aspetto quando viene schiacciato, ovvero quando sente l'evento 8ction7vent di esso. 5sando le caratteristiche di *asso livello, possiamo costruirci i nostri 05I personalizzati, oppure modificare quelli esistenti secondo i nostri *isogni, ma non solo, possiamo estendere un componente particolare, un componente tela, su cui possiamo disegnare quello che vogliamo e metterlo nelle nostre interfacce come un qualsiasi altro 05I. :e usiamo gli applet piuttosto che le applicazioni possiamo evitare di usare la tela, in quanto l'applet ha implicitamente una tela. #a iniziamo a vedere concretamente come possi*lie disegnare su un componente qualsiasi o su un applet, iniziamo a parlare delle applet, per poi estendere i ragionamenti fatti ai componenti in generale.
+ondamenti di disegno con Java
LEZIONE "9:
6el linguaggio Java possi*ile disegnare su un'applet semplicemente ridefinendone il metodo paint, questo metodo viene automaticamente invocato dal sistema quando la finestra contenente l'applet va in primo piano, quindi ogni comando grafico all'applet sar dato nel metodo paint dell'applet 9oid paint (Hrap#ics g) { "" @isegno } quando l'applet ha disegnato, e si vogliono visualizzare eventuali modifiche possi*ile invocare il metodo repaint&' oppure il metodo update&0raphics g' che cancella l'area in cui l'applet ha disegnato e ne reinvoca la paint. Il metodo paint&0raphics g' non pu3 essere invocato direttamente. 6on solo l'applet ha il metodo paint che pu3 essere ridefinito, ma anche gli oggetti di tipo +omponent, ovvero tutti i 05I, quindi per cam*iare l'aspetto grafico di un qualsiasi componente grafico *asta ridefinirne il metodo paint. !ra tutti i component c' la precedentemente citata tela su cui possi*ile disegnare, essa un oggetto della classe +anvas. +hi a*ituato a programmare con altri linguaggi si aspetter che nella paint ci sia un inizializzazione del device su cui si va a disegnare e poi una serie di istruzioni tipo draw%ine, draw-o" eccetera, ma devo dirvi da su*ito che questo non del tutto vero, ovvero nei +omponent e negli applet non
+unzioni paint' repaint' update,,
:::...
:::...
c' nessun metodo grafico. 8 questo punto si spiega anche il parametro g di tipo 0raphics della paint, infatti esso conterr i metodi grafici usa*ili da Java, in effetti esso rappresenta in qualche modo l'area in cui verranno disegnate le varie primitive. 0raphics una classe che non pu3 essere instanziata, ma nella paint viene ricevuta come paramtero, ed solo qui che pu3 essere usata, essa contiene i metodi9 abstract 9oid clear?ect(int 8( int <( int !idt#( int #eig#t) abstract 9oid clip?ect(int 8( int <( int !idt#( int #eig#t) abstract 9oid cop<Area(int 8( int <( int !idt#( int #eig#t( int d8( int d<) abstract Hrap#ics create() Hrap#ics create(int 8( int <( int !idt#( int #eig#t) abstract 9oid dispose() 9oid dra!4@?ect(int 8( int <( int !idt#( int #eig#t(boolean raised) abstract 9oid dra!Arc(int 8( int <( int !idt#( int #eig#t( int startAngle( int arcAngle) 9oid dra!:<tes(b<teBC data( int o55set( int lengt#( int 8( int <) 9oid dra!C#ars(c#arBC data( int o55set( int lengt#( int 8( int <) abstract boolean dra!Image(Q) 6e esistono varie versioni abstract 9oid dra!/ine(int 8+( int <+( int 81( int <1) abstract 9oid dra!>9al(int 8( int <( int !idt#( int #eig#t) abstract 9oid dra!*ol<gon(intBC 8*oints( intBC <*oints( int n*oints) 9oid dra!*ol<gon(*ol<gon p) abstract 9oid dra!*ol<line(intBC 8*oints( intBC <*oints( int n*oints) 9oid dra!?ect(int 8( int <( int !idt#( int #eig#t) abstract 9oid dra!?ound?ect(int 8( int <( int !idt#( int #eig#t( int arcPidt#( int arcUeig#t) abstract 9oid dra!String(AttributedC#aracterIterator iterator( int 8( int <) abstract 9oid dra!String(String str( int 8( int <) 9oid 5ill4@?ect(int 8( int <( int !idt#( int #eig#t( boolean raised) abstract 9oid 5illArc(int 8( int <( int !idt#( int #eig#t( int startAngle( int arcAngle) abstract 9oid 5ill>9al(int 8( int <( int !idt#( int #eig#t) abstract 9oid 5ill*ol<gon(intBC 8*oints( intBC <*oints( int n*oints) 9oid 5ill*ol<gon(*ol<gon p) abstract 9oid 5ill?ect(int 8( int <( int !idt#( int #eig#t) abstract 9oid 5ill?ound?ect(int 8( int <( int !idt#( int #eig#t( int arcPidt#( int arcUeig#t) 9oid 5inalize() abstract S#ape getClip() abstract ?ectangle getClip:ounds() ?ectangle getClip:ounds(?ectangle r) abstract Color getColor() abstract Font getFont() FontMetrics getFontMetrics() abstract FontMetrics getFontMetrics(Font 5) boolean #itClip(int 8( int <( int !idt#( int #eig#t) abstract 9oid setClip(int 8( int <( int !idt#( int #eig#t) abstract 9oid setClip(S#ape clip) abstract 9oid setColor(Color c) abstract 9oid setFont(Font 5ont) abstract 9oid set*aintMode() abstract 9oid setM>?Mode(Color c+) String toString() abstract 9oid translate(int 8( int <) 8vremo modo tra non molto di vedere in dettaglio tutti questi metodi. In Java= la classe 0raphics stata potenziata aggiungendo la classe 0raphics=(, che la estende aggiungendo notevoli potenzialit alla grafica in Java. Der avere un'assaggio delle potenzialit di >ava potede vedere la (emo rilasciata insieme alle J(;, se ad esempio avete scaricato le J(;<.C e le avete installate in c9X>d$<.C, la demo si trova in9 cLJ;dA+&4JdemoJ;5cJDa9a1@ e per eseguirla *isogna *attere dal prompt9 ;a9a -;ar Da9a1@emo&;ar
:::...
:::...
LEZIONE 30:
Iniziamo a vedere i metodi drawImage della classe 0raphics, con i quali possi*ile visualizzare delle immagini salvate con formato gif o >pg. 6ella classe 0raphics ci sono vari metodi drawImage, essi sono9 a*stract *oolean drawImage&Image img, int ", int , +olor *gcolor, ImageO*server o*server' abstract boolean dra!Image(Image img( int 8( int <( Image>bser9er obser9er) abstract boolean dra!Image(Image img( int 8( int <( int !idt#( int #eig#t( Color bgcolor( Image>bser9er obser9er) abstract boolean dra!Image(Image img( int 8( int <( int !idt#( int #eig#t( Image>bser9er obser9er) abstract boolean dra!Image(Image img( int d8+( int d<+( int d81( int d<1( int s8+( int s<+( int s81( int s<1( Color bgcolor( Image>bser9er obser9er) abstract boolean dra!Image(Image img( int d8+( int d<+( int d81( int d<1( int s8+( int s<+( int s81( int s<1( Image>bser9er obser9er) !utti i metodi richiedono i due parametri Image e ImageO*server. Image rappresenta l'immagine da visualizzare, essa una classe astratta che fornisce un accesso indipendente dal formato a immagini grafiche, oggetti di questa classe vengono creati usando metodi di altre classi che creano delle immagini, a seconda del conteso in cui si vogliono usare le immagini. 8d esempio, volendo disegnare una immagine in un componente 0ui, si pu3 usare il metodo createImage&' della classe +omponent. /olendo invece disegnare una immagine in un'applet, possi*ile usare il metodo getImage&' della classe 8pplet. %a classe !ool$it ha sia createImage&' che getImage&'. %'altro parametro richiesto da tutte le drawImage&' un oggetto che implementa l'interfaccia ImageO*server, e rappresenta in pratica l'oggetto grafico su cui verr visualizzata l'immagine. +omponent implementa l'interfaccia ImageO*server, di conseguenza la implementano tutte le sue estensioni, tra cui9 !utti i 05I %e 8pplets !utte le finestre &tra cui i Rrames' !ra gli altiri parametri ci sono9

Visualizzazione di immagini
la posizione " in cui verr visualizzata l'imagine nel componente la posizione in cui verr visualizzata l'imagine nel componente il colore dello sfondo Droviamo a fare un'esempio di visualizzazione di una immagine. +reiamo innanzitutto una immagine, ad
:::...
esempio la seguente
:::...
e la salviamo in formato gif usando un qualunque editore di immagini, chiamandola ad esempio pietro.>pg. 8 questo punto creiamo la seguente applet9 import ;a9a&a!t&6; "" *er la classe Hrap#ics import ;a9a&applet&6; "" *er la classe Applet import ;a9a&net&6; "" *er leF?/ "6 Come abbiamo gia detto i 5iles per gli applet non sono altro c#e degli F?/ 6" public class 3isualizzaImmagine e8tends Applet { Image Immagine*ietro; public 9oid init() { set:acAground(Color&!#ite); Immagine*ietro getImage(get@ocument:ase()($pietro&;pg$); } public 9oid paint(Hrap#ics g) { g&dra!Image(Immagine*ietro('('(t#is); getAppletConte8t()&s#o!Status($3isualizzo l)immagine pietro&;pg( Applet creata da *ietro Castellucci$); } } la mettiamo in un file chiamato /isualizzaImmagine.>ava e la invochiamo usando il documento html seguente &Immagine.html'9 [#tml7 [#ead7 [title7 Applet 3isualizzaImmagine( 9isualizza l)immagine pietro&;pg ["title7 ["#ead7 [bod<7 [A**/G2 code $3isualizzaImmagine&class$ !idt# 4T0 #eig#t +''7 ["A**/G27 [:?7 Ruella di sopra X una applet( ma =uella di sotto noW [:?7 [IMH S?C $pietro&;pg$7 ["bod<7 ["#tml7 :e eseguiamo l'applet ci accorgiamo che non vi alcuna differenza tra l'immagine caricata nell'applet e quella caricata usando il tag I#0 :B+ dell'html, a parte il messaggio che appare quando vi si passa sopra con il mouse, potre**e sem*rare anche un lavoro inutile per le vostre pagine html. .uesto non assolutamente vero, infatti l'imagine caricata nell'applet appartiene ad un programma che pu3
:::...
:::...
fare anche cose complesse, ad esempio possi*ile aggiungere altri componenti 05I all'applet, oppure fare delle ela*orazioni sull'immagine stessa, come mostra il seguente esempio &/isualizzaImmagine=.>ava'9 import ;a9a&a!t&6; "" *er la classe Hrap#ics import ;a9a&applet&6; "" *er la classe Applet import ;a9a&net&6; "" *er leF?/ import ;a9a&a!t&e9ent&6; "" *er gli e9enti "6 Come abbiamo gia detto i 5iles per gli applet non sono altro c#e degli F?/ 6" public class 3isualizzaImmagine1 e8tends Applet { Image Immagine*ietro; C#ecAbo8Hroup gruppo ne! C#ecAbo8Hroup(); C#ecAbo8 b+ ne! C#ecAbo8($Ferma$(gruppo(true); C#ecAbo8 b1 ne! C#ecAbo8($Animata$(gruppo(5alse); *anel p ne! *anel(ne! Hrid/a<out(+(4)); public 9oid init() { set:acAground(Color&!#ite); set/a<out(ne! :order/a<out()); Immagine*ietro getImage(get@ocument:ase()($pietro&;pg$); p&add(ne! /abel()); p&add(b+); p&add(b1); b+&addItem/istener(ne! I/()); b1&addItem/istener(ne! I/()); add(p(:order/a<out&S>F2U); } boolean M>3IMG%2> 5alse; int numero '; int inc +; public 9oid paint(Hrap#ics g) { i5 (WM>3IMG%2>) { g&dra!Image(Immagine*ietro('('(t#is); getAppletConte8t()&s#o!Status($3isualizzo l)immagine pietro&;pg( Immagine 5erma( Applet creata da *ietro Castellucci$); numero '; } else { g&set*aintMode();
:::...
g&dra!Image(Glabora(Immagine*ietro(numero)('('(t#is);
:::...
5or (int A ';A[ ,,;AEE) getAppletConte8t()&s#o!Status($3isualizzo l)immagine pietro&;pg( Frame $EnumeroE$( Applet creata da *ietro Castellucci$); getAppletConte8t()&s#o!Status($3isualizzo l)immagine pietro&;pg( Frame $EnumeroE$( Applet creata da *ietro Castellucci$); i5 (numero7 +') inc -+; i5 (numero[ ') inc +; numeroE inc; } repaint(); } Image Glabora (Image img( int 5rm) { return img&getScaledInstance(41.-(5rm61')( T0-(5rm6.)(img&SCA/GKFAS2); } public class I/ implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) { i5 (b+&getState()) M>3IMG%2> 5alse; else M>3IMG%2> true; repaint(); } } } +aricata dal file html seguente9 [#tml7 [#ead7 [title7 Applet 3isualizzaImmagine( 9isualizza l)immagine pietro&;pg ["title7 ["#ead7 [bod<7 [A**/G2 code $3isualizzaImmagine1&class$ !idt# 4T0 #eig#t +''7 ["A**/G27 [:?7 Ruella di sopra X una applet( ma =uella di sotto noW [:?7 [IMH S?C $pietro&;pg$7 ["bod<7 ["#tml7 %a nuova classe 0raphics=( mette a disposizione altri metodi drawImage, tra cui alcuni che hanno un parametro di tipo 8ffine!ransform che come si capisce dal nome una trasformazione affine dell'immagine, ovvero una scalatura, una rotazione o una traslazione, o una com*inazione di queste. Der avere una versione senza sfarfallio *asta aggiungere la funzione9
:::...
public 9oid update(Hrap#ics g) { paint(g); }
:::...
LEZIONE 31:
+apito il funzionamento della paint&' siamo pronti a disegnare qualsiasi cosa su un'applet o su un generico componente. %a cosa pi) semplice da disegnare la linea, per farlo usiamo il metodo draw%ine&' di 0raphics9 dra!/ine(Inizio8( Inizio<( Fine8( Fine<) il quale disegna una linea che parte dal punto &Inizio", Inizio ' e arriva al punto &Rine", Rine ' Drima di usare la draw%ine&' capiamo come si possono cam*iare i colori delle cose disegnate. I colori si cam*iano usando il metodo set+olor&+olor c' della classe 0raphics. +olor un'altra classe di awt che permette di definire un colore, alcuni suoi costruttori sono9 Color(5loat r( 5loat g( 5loat b), crea un colore specificando i valori B0- &Bed P 0reen P -lue, ovvero Bosso P /erde P -lu' con dei valori compresi tra @ e <. Color(5loat r( 5loat g( 5loat b( 5loat a), come il precedente, solo che permette di definire anche il valore alfa Color(int r( int g( int b) , crea un colore specificando i valori B0- &Bed P 0reen P -lue, ovvero Bosso P /erde P -lu' con dei valori compresi tra @ e =AA. Color(int r( int g( int b( int a), come il precedente, solo che permette di definire anche il valore alfa 8lcuni colori semplici sono dati da delle costanti nella classe color9 Color&blacA Color&blue Color&c<an Color&darAHra< Color&gra< Color&green Color&lig#tHra< Color&magenta Color&orange Color&pinA Color&red Color&!#ite Color&<ello! 6el seguente applet si disegnano alcune linee colorate. import ;a9a&a!t&Hrap#ics; import ;a9a&a!t&Color; import ;a9a&a!t&:utton; import ;a9a&a!t&:order/a<out; import ;a9a&a!t&Hrid/a<out; import ;a9a&a!t&*anel; import ;a9a&a!t&e9ent&ActionG9ent; import ;a9a&a!t&e9ent&Action/istener; import ;a9a&applet&6;
(isegno
:::...
public class linee e8tends Applet { 5inal int SI +.; 5inal int %> '; :utton ? ne! :utton($?osso$); :utton H ne! :utton($3erde$); :utton : ne! :utton($:lu$); int rK '; int gK '; int bK '; int ir '; int ig '; int ib '; public 9oid init() { set/a<out(ne! :order/a<out()); *anel np ne! *anel(ne! Hrid/a<out(+(4)); np&add(?); np&add(H); np&add(:); ?&addAction/istener(ne! Action/istener() { public 9oid action*er5ormed(ActionG9ent e) { ir SI; ig %>; ib %>; repaint(); } } );
:::...
H&addAction/istener(ne! Action/istener() { public 9oid action*er5ormed(ActionG9ent e) { ir %>; ig SI; ib %>; repaint(); }
:::...
} ); :&addAction/istener(ne! Action/istener() { public 9oid action*er5ormed(ActionG9ent e) { ir %>; ig %>; ib SI; repaint(); } } );
:::...
add(np(:order/a<out&S>F2U); } public 9oid paint(Hrap#ics g) { 5or (int i ';i[1'';iE +') { g&setColor(ne! Color(rK(gK(bK)); rK rKEir; gK gKEig; bK bKEib; g&dra!/ine('(i(i(1''); } g&setColor(Color&blacA); g&dra!/ine('('('(1''); g&dra!/ine('(1''(1''(1''); rK '; gK '; bK '; } } +hiamiamo il file linee.>ava e lo carichiamo con il file html seguente &linee.html'9 [#tml7 [#ead7 [title7 Applet /inee (linee&class) ["title7 ["#ead7 [bod<7 [A**/G2 code $linee&class$ !idt# 1'' #eig#t 4''7 ["A**/G27 ["bod<7 ["#tml7
:::...
...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE 3":

<E;;:N=OLI
:::...
+igure geometric!e e testo
0raphics permette di disegnare dei rettangoli specificandone due spigoli opposti usando il metodo9 dra!?ect(Inizio8(Inizio<(Fine8(Fine<); questo metodo equivalente a9 dra!/ine(Inizio8(Inizio<(Fine8(Inizio<); dra!/ine(Inizio8(Inizio<(Inizio8(Fine<); dra!/ine(Fine8(Inizio<(Fine8(Fine<); dra!/ine(Inizio8(Fine<(Fine8(Fine<); possi*ile anche costruire rettangoli che danno una specie di effetto rialzato o incavato usando il metodo drawC(Bect&int ",int ,int larghezza,int altezza,*oolean rialzato' e rettangoli con gli spigoli arrotondati con il metodo drawBoundBect&int ", int , int larghezza, int altezza, int larghezza8rco, int altezza8rco'. 7' inoltre possi*ile colorare all'interno tutte le figure chiuse usando i metodi fill, ad esempio per colorare un BoundBect *isogna usare fillBoundBect, che ha glistessi parametri della corrispondente draw. %E<%?I ED ELLI I
:i pu3 disegnare una ellisse usando la drawOval &int ", int , int larghezza,int altezza' e colorarla usando la fillOval&int ", int , int larghezza,int altezza'. :e altezza e altezza sono uguali si disegna un cerchio. ,OLI=ONI 5sando la drawDol gon si disegna un generico poligono. 7sistono due tipi di drawDol gon9 dra!*oligon( intBC *F%2I8( int *F%2I<( int %FMG?>*F%2I); e dra!*ol<gon (*ol<gon p) %a seconda usa un oggetto della classe Dol gon, che definisce un poligono. 7sistono le corrispondenti fillDol gon. ;E ;O Der disegnare una stringa si pu3 usare il metodo draw:tring &:tring !7:!O, int ", int 'M 5n testo pu3 essere disegnato con diverse Ront, per cam*iare le Ront 0raphics mette a disposizione il metodo setRont&Ront font', dove font l'oggetto che definisce il tipo di carattere. Ront la classe che definisce i caratteri, possi*ile instanziarla creando uno specifico Ront, usando Ront &:tring name, int st le, int size'. Ront una classe a**astanza complicata, per3 facile trovare ed usare i Ronts del sistema mentre si esegue un programma >ava9 6elle vecchie versioni di >ava *aste scrivere9 String BC %>MI 2oolAit&get@e5ault2oolAit()&getFont/ist(); #entre nelle nuove versioni di Java &da J(; <.= ' String BC %>MI Hrap#icsGn9ironment& get/ocalHrap#icsGn9ironment()& getA9ailableFontFamil<%ames(); poi facile instanziare oggetti Ront conoscendo i nomi. :<%?I :i possono disegnare degli archi usando draw8rc&int ", int , int larghezza, int altezza, int angoloIniziale, int angolo8rco'
:::...
%'uso di tutti questi metodi illustrato nell'esempio seguente. Il file che lo manda in esecuzione 9 [#tml7 [#ead7 [title7 Applet gra5@emo (gra5@emo&class) ["title7 ["#ead7 [bod<7 [A**/G2 code $gra5@emo&class$ !idt# 0'' #eig#t .''7 ["A**/G27 ["bod<7 ["#tml7
:::...
LEZIONE 33:
%'esempio, editato nel file graf(emo.>ava 9 import ;a9a&a!t&Hrap#ics; import ;a9a&a!t&Color; import ;a9a&a!t&:utton; import ;a9a&a!t&:order/a<out; import ;a9a&a!t&Hrid/a<out; import ;a9a&a!t&Flo!/a<out; import ;a9a&a!t&*anel; import ;a9a&a!t&/abel; import ;a9a&a!t&C#oice; import ;a9a&a!t&Font; import ;a9a&a!t&2oolAit; import ;a9a&a!t&C#ecAbo8; import ;a9a&a!t&Scrollbar; import ;a9a&a!t&Hrap#icsGn9ironment; import ;a9a&a!t&e9ent&ItemG9ent; import ;a9a&a!t&e9ent&Item/istener; import ;a9a&a!t&e9ent&Ad;ustment/istener; import ;a9a&a!t&e9ent&Ad;ustmentG9ent; import ;a9a&applet&6; public class gra5@emo e8tends Applet {
ile gra (emo,-ava
Scrollbar ? ne! Scrollbar(Scrollbar&3G?2ICA/( '( +( '( 100); Scrollbar H ne! Scrollbar(Scrollbar&3G?2ICA/( '( +( '( 100); Scrollbar : ne! Scrollbar(Scrollbar&3G?2ICA/( '( +( '( 100);
:::...
C#oice F% ne! C#oice(); C#oice H? ne! C#oice(); C#ecAbo8 F ne! C#ecAbo8($Figure c#iuse piene$(5alse); int BC puntiM {+(+''(1''(4''(4,,(4''(1''(+''}; int BC puntiN {1''(+0'(0'(+0'(1''(+''(10'(+4'}; int punti T; public 9oid init() { "" Calcolo i Font del sistemaL "" StringBC %>MI Hrap#icsGn9ironment& "" get/ocalHrap#icsGn9ironment()& "" getA9ailableFontFamil<%ames(); "6 *er Da9a presente sui bro!ser String BC %>MI 2oolAit&get@e5ault2oolAit()&getFont/ist(); 6" String BC %>MI 2oolAit&get@e5ault2oolAit()&getFont/ist(); tr< { int indice '; !#ile (true) { F%&addItem(%>MIBindiceEEC); } } catc# (Arra<Inde8>ut>5:oundsG8ception e) {}; set/a<out(ne! :order/a<out()); *anel np ne! *anel(ne! Hrid/a<out(+(4)); *anel rosso ne! *anel(ne! Flo!/a<out()); rosso&add(ne! /abel($?osso$)); rosso&add(?); np&add(rosso); *anel 9erde ne! *anel(ne! Flo!/a<out()); 9erde&add(ne! /abel($3erde$)); 9erde&add(H); np&add(9erde); *anel blu ne! *anel(ne! Flo!/a<out()); blu&add(ne! /abel($:lu$)); blu&add(:); np&add(blu); ?&setFnitIncrement(+');
:::...
:::...
?&set3alue(100); H&setFnitIncrement(+'); H&set3alue(100); :&setFnitIncrement(+'); :&set3alue(100); add(np(:order/a<out&S>F2U); H?&addItem($/inea$); H?&addItem($?ettangolo$); H?&addItem($?ettangolo 4@$); H?&addItem($?ettangolo Arrotondato$); H?&addItem($Cerc#io$); H?&addItem($Gllisse$); H?&addItem($*oligono generico$); H?&addItem($2esto$); H?&addItem($Arco$); *anel up ne! *anel(ne! Hrid/a<out(+(4)); up&add(H?); up&add(F%); up&add(F); add(up(:order/a<out&%>?2U); ?&addAd;ustment/istener(ne! A/()); H&addAd;ustment/istener(ne! A/()); :&addAd;ustment/istener(ne! A/()); H?&addItem/istener(ne! I/()); F%&addItem/istener(ne! I/()); F&addItem/istener(ne! I/()); } public 9oid paint(Hrap#ics g) { g&setColor(ne! Color(100-?&get3alue()( 100-H&get3alue()( 100-:&get3alue() )); g&setFont(ne! Font(F%&getSelectedItem()('(.')); boolean 5illed F&getState();
:::...
:::...
int pg H?&getSelectedInde8(); g&dra!String(H?&getSelectedItem()(+(4''); i5 (pg ') { g&dra!/ine(+(+''(4,,(4''); return; } i5 (pg +) { g&dra!?ect(0'(+''(10'(+''); i5 (5illed) g&5ill?ect(0'(+''(10'(+''); return; } i5 (pg 1) { g&dra!4@?ect(0'(+''(10'(+''(true); return; } i5 (pg 4) { g&dra!?ound?ect(0'(+''(4''(+''(1'(1'); i5 (5illed) g&5ill?ound?ect(0'(+''(4''(+''(1'(1'); return; } i5 (pg .) { g&dra!>9al(+''(+''(1''(1''); i5 (5illed) g&5ill>9al(+''(+''(1''(1''); return; } i5 (pg 0) { g&dra!>9al(+''(+''(1''(+''); i5 (5illed) g&5ill>9al(+''(+''(1''(+''); return; } i5 (pg S) { g&dra!*ol<gon(puntiM(puntiN(punti); i5 (5illed) g&5ill*ol<gon(puntiM(puntiN(punti); return; } i5 (pg -) { g&dra!String($Ruesta X una stringa$(+(1''); return; } i5 (pg T) { g&dra!Arc(+(0'(4,T(1''(+'(1-'); i5 (5illed) g&5illArc(+(0'(4,T(1''(+'(1-'); return; }
:::...
:::...
} public class I/ implements Item/istener { public 9oid itemStateC#anged(ItemG9ent e) { repaint(); } } public class A/ implements Ad;ustment/istener { public 9oid ad;ustment3alueC#anged(Ad;ustmentG9ent e) { repaint(); } } }
:::...
LEZIONE 34:
/isto che il programma stato creato per un *rowser &che hanno le vecchie versioni di Java' ho dovuto usare :tring TU 6O#IL!ool$it.get(efault!ool$it&'.getRont%ist&'M per avere i caratteri, se si compila con J(; <.= o <.C si deve scrivere9 d ;a9ac gra5@emo&;a9a -deprecation Il quale dar un warning per dire che si usa un metodo deprecato. :e invece userete l'appletviewer per visualizzare l'applet potete cam*iare String BC %>MI 2oolAit&get@e5ault2oolAit()&getFont/ist(); con String BC %>MI Hrap#icsGn9ironment& get/ocalHrap#icsGn9ironment()& getA9ailableFontFamil<%ames(); e apprezzare la grande quantit di Ront presenti. 6ell'esempio ho usato per i colori tre scroll*ar, che tra i 05I non avevamo visto. Der creare l'oggetto scroll*ar ho usato il costruttore9 Scrollbar ? ne! Scrollbar(Scrollbar&3G?2ICA/( '( +( '( 100); che crea una scroll*ar verticale con valori che vanno da @ a =AA con valore iniziale @. Doi ho settato il valore della scroll*ar con B.set/alue&=AA'M ed ho detto che l'incremento per ogni clic$ deve essere di <@ con B.set5nitIncrement&<@'M Der ascoltare i cam*iamenti uso un oggetto che implementa la classe 8d>ustment%istener che ascolta eventi di tipo 8d>ustment7vent. Der associare l'ascoltatore all'oggetto scroll*ar si usa il metodo add8d>ustment%istener.
.ote per compilare il programma
:::...
:::...
LEZIONE 35:
In tutto quello fatto finora a**iamo cercato di creare programmi compati*ili tra le vecchie e la nuova versione di Java, questo per creare degli applet generali che potessero girare su tutti i *rowser &i quali come ho gi detto attualmente hanno Java <.<." come motore per le applet'. 6ell'argomento che stiamo per trattare purtroppo questo non possi*ile, infatti con le vecchie versioni di Java si possono creare delle applet che leggono e suonano file di tipo .au, usando i metodi pla di applet e l'interfaccia 8udio+lip. !utto questo ancora possi*ile con Java=, versione <.C, ma sono stati inclusi dei pacchetti per gestire i suoni, che offrono delle potenzialit eccezionali.
Il suono di Java /,/,0 e /,),0
LEZIONE 36:
I pacchetti aggiunti al linguaggio sono ?9 <. >ava".sound.midi =. >ava".sound.midi.spi C. >ava".sound.sampled ?. >ava".sound.sampled.spi
Suono" -ava0,s*ing,sampled
%e parti che finiscono per spi servono a leggere e scrivere files sonori, convertirli o leggere files di strumenti nel caso di midi. 6oi non vedremo queste parti, mentre vedremo >ava".sound.sampled e >ava".sound.midi. Il pacchetto >ava".swing.sampled permette di registrare suonare e modificare dati sonori. Il contenuto del pacchetto 9 Inter-acce

+lip (ata%ine %ine %ine%istener #i"er Dort :ource(ata%ine !arget(ata%ine 8udioRileRormat 8udioRileRormat.! pe 8udioRormat 8udioRormat.7ncoding 8udioInput:tream 8udioDermission
%la!!i

:::...

:::...
8udio: stem -oolean+ontrol -oolean+ontrol.! pe +ompound+ontrol +ompound+ontrol.! pe +ontrol +ontrol.! pe (ata%ine.Info 7num+ontrol 7num+ontrol.! pe Rloat+ontrol Rloat+ontrol.! pe %ine.Info %ine7vent %ine7vent.! pe #i"er.Info Dort.Info Bever*! pe %ine5navaila*le7"ception 5nsupported8udioRile7"ception
Eccezioni

/ediamo come usare questo pacchetto solo per suonare un file sonoro, ad esempio il file chiamato italian.wav. Inanzitutto do**iamo reperire il file, e questo lo facciamo come al solito instanziando un oggetto della classe Rile &di >ava.io' File s5 ne! File($italian&!a9$); 8 questo punto iniziamo una tr IJ catch, nella quale includeremo tutto quello che ha a che fare con il suono, cattureremo le eccezioni9 catc#(FnsupportedAudioFileG8ception ee){} catc#(I>G8ception ea){} catc#(/ineFna9ailableG8ception /FG){}; Der usare il motore sonoro di Java do**iamo partire dalla classe 8udio: stem, da questa otterremo due oggetti di tipo 8udioRileRormat e 8udioInput:tream AudioFileFormat a55 AudioS<stem&getAudioFileFormat(s5); AudioInputStream ais AudioS<stem&getAudioInputStream(s5); che rappresentano il contenuto del file italian.wav (o**iamo creare un oggetto 8udioRormat da 8udioRileRormat per poterlo suonare AudioFormat a5 a55&getFormat(); Il nostro scopo quello di creare un oggetto che implementi l'interfaccia +lip, il quale contiene i metodi pla , per fare questo scriveremo9 @ata/ine&In5o in5o ne! @ata/ine&In5o( Clip&class( ais&getFormat()( ((int) ais&getFrame/engt#() 6 a5&getFrameSize())); Clip ol (Clip) AudioS<stem&get/ine(in5o); (a ol, che di tipo +lip possiamo suonare, e questo si fa aprendo la linea e invocando i metodi per suonare9 ol&open(ais); [-(A*?G l)input stream( o99ero il 5ile italian&!a9) e quindi
:::...
ol&loop(%FMG?>);
:::...
dove 65#7BO indica il numero di ripetizioni del dile, nel nostro caso +lip. %OODN+O6!I65O5:%W per indicare che *isogna ripetere all'infinito. %'esempio completo, editato in suono.>ava il seguente9 import ;a9a8&s!ing&6; import ;a9a8&sound&sampled&6; import ;a9a&io&6; public class suono e8tends DFrame { public suono() { File s5 ne! File($italian&!a9$); AudioFileFormat a55; AudioInputStream ais; tr< { a55 AudioS<stem&getAudioFileFormat(s5); ais AudioS<stem&getAudioInputStream(s5); AudioFormat a5 a55&getFormat(); @ata/ine&In5o in5o ne! @ata/ine&In5o( Clip&class( ais&getFormat()( ((int) ais&getFrame/engt#() 6 a5&getFrameSize())); Clip ol (Clip) AudioS<stem&get/ine(in5o);
ol&open(ais); ol&loop(Clip&/>>*KC>%2I%F>FS/N); S<stem&out&println($?iproduzione iniziata( premere C2?/-C per interropere$); } catc#(FnsupportedAudioFileG8ception ee){} catc#(I>G8ception ea){} catc#(/ineFna9ailableG8ception /FG){}; } public static 9oid main(StringBC ar) { ne! suono(); } } :em*ra un po macchinoso, ma seguendo questa procedura possi*lie leggere e suonare ogni file wav. Der effettuare altre operazioni il pacchetto a**astanza complesso, e oggi non esistono manuali che ne spiegano il funzionamento &tranne la documentazione del J(;, che come avrete avuto modo di vedere non spiega come usare le cose, ma le descrive soltanto'.
:::...
...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE 37:
:::...
/ediamo come leggere e suonare un file midi, per fare questo ci occorre il pacchetto >ava".suond.midi, il quale contiene9 Inter-acce

Il pacc!etto -ava0,suond,midi
+ontroller7vent%istener #eta7vent%istener #idi+hannel #idi(evice Beceiver :equencer :ound*an$ : nthesizer !ransmitter Instrument #eta#essage #idi(evice.Info #idi7vent #idiRileRormat #idi#essage #idi: stem Datch :equence :equencer.: nc#ode :hort#essage :ound*an$Besource : se"#essage !rac$ /oice:tatus Invalid#idi(ata7"ception #idi5navaila*le7"ception
%la!!i

Eccezioni

%a tecnica per suonare un file midi simile a quella usata per i file wav, solo che si parte da #idi: stem. 6el seguente esempio viene suonato il file sorpresa.mid, che un file midi che io apprezzo molto, e credo che apprezzaranno tutti i miei coetanei. 7ditatelo nel file midifiles.>ava import ;a9a8&s!ing&6; import ;a9a8&sound&midi&6; import ;a9a&io&6; public class midi5iles e8tends DFrame { public midi5iles() { tr< { File 51 ne! File($sorpresa&mid$); MidiFileFormat m551 MidiS<stem&getMidiFileFormat(51); Se=uence S MidiS<stem&getSe=uence(51); Se=uencer se= MidiS<stem&getSe=uencer();
:::...
se=&open(); se=&setSe=uence(S); se=&start(); S<stem&out&println($Sorpresa per tutti i miei coetanei$); S<stem&out&println($*remere C2?/-C per interrompere$);
:::...
} catc#(MidiFna9ailableG8ception ecc){} catc#(In9alidMidi@ataG8ception ecc1){} catc#(I>G8ception ecc4){} ; } public static 9oid main(StringBC ar) { ne! midi5iles(); } }
LEZIONE 38:
+ome ho gia detto anche possi*ile sintetizzare suoni, questo quello che fa il prossimo programma, da editare nel file sintetizzatore.>ava import ;a9a8&s!ing&6; import ;a9a&a!t&6; import ;a9a&a!t&e9ent&6; import ;a9a8&s!ing&border&6; import ;a9a&io&6; import ;a9a&util&6; import ;a9a8&sound&sampled&6; import ;a9a8&sound&midi&6; public class sintetizzatore e8tends DFrame { int 2GM*> 0'; int CA%A/G '; int F%S -+; int S2?FMG%2> '; Sintetizzatore SI%2G2IOOA2>?G ne! Sintetizzatore(); "" HFI D/abel tastiera+ ne! D/abel(ne! ImageIcon($tastiera+&gi5$)); D/abel tastiera1 ne! D/abel(ne! ImageIcon($tastiera1&gi5$)); D:utton >A: ne! D:utton($>A$); DCombo:o8 Strumenti ne! DCombo:o8(); DCombo:o8 Canali ne! DCombo:o8(); D/abel uns ne! D/abel($Fltima nota suonata$); D2e8tField msg ne! D2e8tField( $%essuna nota$
Sintetizzare suoni
:::...
); DSlider S/ ne! DSlider(); public sintetizzatore() { set2itle($Sintetizzatore sonoro b< *ietro Castellucci$); setupAspetto(); setup3alori(); setupG9enti(); SI%2G2IOOA2>?G&setStrumento( Strumenti&getSelectedInde8()(CA%A/G); set?esizable(5alse); set@e5aultClose>peration(@>K%>2UI%HK>%KC/>SG); pacA(); 2oolAit t 2oolAit&get@e5ault2oolAit();
:::...
@imension d t&getScreenSize(); @imension !in getSize(); !in getSize(); set/ocation(d&!idt#"1-(!in&!idt#"1)-+(d&#eig#t"1-(!in&#eig#t"1)-+); s#o!(); } 9oid setupAspetto() { tastiera+&setCursor(ne! Cursor(Cursor&UA%@KCF?S>?)); tastiera1&setCursor(ne! Cursor(Cursor&UA%@KCF?S>?)); >A:&setCursor(ne! Cursor(Cursor&UA%@KCF?S>?)); tastiera+&set2ool2ip2e8t( $Cliccami per suonare$ ); tastiera1&set2ool2ip2e8t( $Cliccami per suonare$ ); >A:&set2ool2ip2e8t( $Gsco dal programma$ );
D*anel * ne! D*anel(ne! :order/a<out()); D*anel *annello ne! D*anel(ne! Hrid/a<out(1(+)); *annello&add(tastiera+); *annello&add(tastiera1); *&add(*annello(:order/a<out&CG%2G?);
:::...
D*anel S* ne! D*anel(ne! Flo!/a<out()); Strumenti&set:order( :orderFactor<&create2itled:order( $Strumenti$ ) ); Canali&set:order( :orderFactor<&create2itled:order( $Canali$ ) ); S*&add(Strumenti); "" S*&add(Canali); S*&add(uns); msg&setGditable(5alse); msg&set:acAground(*&get:acAground()); S*&add(msg); S*&add(>A:); *&add(S*(:order/a<out&S>F2U); S/&set:order(:orderFactor<&create2itled:order( $*ressione $ )); S/&set>rientation(DSlider&3G?2ICA/); S/&setMa;or2icASpacing(10); S/&setMa8imum(+''); S/&setMinimum('); S/&setMinor2icASpacing(+); S/&set*aint/abels(true); S/&set*aint2icAs(true); S/&set*aint2racA(true); S/&setSnap2o2icAs(true); S/&set3alue(2GM*>); *&add(S/(:order/a<out&GAS2); setContent*ane(*); }
:::...
9oid setup3alori() { tr< { int i '; !#ile (true) { String nome SI%2G2IOOA2>?G&StrumentiBiEEC&get%ame(); Strumenti&addItem(nome); } } catc# (Arra<Inde8>ut>5:oundsG8ception e)
:::...
{};
:::...
tr< { int i '; !#ile (true) { String nome $Canale$E$ $E(iE+); SI%2G2IOOA2>?G&CA%A/IBiEEC&all%otes>55(); Canali&addItem(nome); } } catc# (Arra<Inde8>ut>5:oundsG8ception e) {}; i5 (Strumenti&getItemCount()7') Strumenti&setSelectedInde8(S2?FMG%2>); }
9oid setupG9enti() { tastiera+&addMouse/istener(ne! 2astiera+/istener()); tastiera1&addMouse/istener(ne! 2astiera1/istener());
Strumenti&addItem/istener(ne! Item/istener() { public 9oid itemStateC#anged(ItemG9ent e) { SI%2G2IOOA2>?G&setStrumento( Strumenti&getSelectedInde8()(CA%A/G); } } );
Canali&addItem/istener(ne! Item/istener() { public 9oid itemStateC#anged(ItemG9ent e) { CA%A/G Canali&getSelectedInde8(); SI%2G2IOOA2>?G&cambiaCanale(CA%A/G); } });
>A:&addAction/istener(ne! Action/istener() { public 9oid action*er5ormed(ActionG9ent e) { S<stem&out&println($Hrazie per a9ere suonato con meW$); S<stem&e8it('); } }
:::...
);
:::...
} "" G9enti public class 2astiera+/istener implements Mouse/istener { public 9oid mouseClicAed(MouseG9ent e) {} public 9oid mouseGntered(MouseG9ent e) {} public 9oid mouseG8ited(MouseG9ent e) {} public 9oid mouse*ressed(MouseG9ent e) { "" S<stem&out&println($2astiera + *untoL (8 $Ee&getM()E$(< $Ee&getN()E$)$); F%S get%ota(e&getM()); "" S<stem&out&println($%ota $Enota); 2GM*> S/&get3alue(); SI%2G2IOOA2>?G&suona(F%S(2GM*>(CA%A/G); msg&set2e8t($$E(F%SE+)); } public 9oid mouse?eleased(MouseG9ent e) {} } public class 2astiera1/istener implements Mouse/istener { public 9oid mouseClicAed(MouseG9ent e) {} public 9oid mouseGntered(MouseG9ent e) {} public 9oid mouseG8ited(MouseG9ent e) {} public 9oid mouse*ressed(MouseG9ent e) { "" S<stem&out&println($2astiera 1 *untoL (8 $Ee&getM()E$(< $Ee&getN()E$)$); F%S S.Eget%ota(e&getM()); "" S<stem&out&println($%ota $Enota); 2GM*> S/&get3alue(); SI%2G2IOOA2>?G&suona(F%S(2GM*>(CA%A/G); msg&set2e8t($$E(F%SE+)); } public 9oid mouse?eleased(MouseG9ent e) {} }
:::...
:::...
"" Ftilit< 5un int get%ota (int pos) { int nota; nota (pos"+1); return nota; }
public static 9oid main(StringBC arg) { ne! sintetizzatore(); } ""66666666666666666666666666666666666666666 "" S>F%@ MA%AHG? ""66666666666666666666666666666666666666666 ""66666666666666666666666666666666666666666666666666666666666 "" SintetizzatoreL ""66666666666666666666666666666666666666666666666666666666666 public class Sintetizzatore { pri9ate S<nt#esizer SN%2; pri9ate Se=uencer se=uencer; pri9ate Se=uence se=; pri9ate SoundbanA :A%a; public InstrumentBC Strumenti; public MidiC#annelBC CA%A/I; public Sintetizzatore() { setupSintetizzatore(); } 9oid setupSintetizzatore() { tr< { SN%2 MidiS<stem&getS<nt#esizer(); se=uencer MidiS<stem&getSe=uencer(); se= ne! Se=uence(Se=uence&**R( +'); SN%2&open(); :A%a SN%2&get@e5aultSoundbanA(); i5 (:A%a W null) Strumenti SN%2&get@e5aultSoundbanA()&getInstruments(); else Strumenti SN%2&getA9ailableInstruments(); CA%A/I SN%2&getC#annels(); } catc#(MidiFna9ailableG8ception ecc){tuttonull();} catc#(In9alidMidi@ataG8ception ecc1){tuttonull();} ; }
:::...
9oid tuttonull() { SN%2 null; se=uencer null; se= null; :A%a null; Strumenti null; } public 9oid setStrumento(int str(int can) { SA str; int prog StrumentiBstrC&get*atc#()&get*rogram(); CA%A/IBcanC&programC#ange(prog); } pri9ate int SA '; public 9oid cambiaCanale(int can) { int prog StrumentiBSAC&get*atc#()&get*rogram(); CA%A/IBcanC&programC#ange(prog); } public 9oid suona(int nota(int tempo( int canale) { CA%A/IBcanaleC&all%otes>55(); CA%A/IBcanaleC&note>n(nota(tempo); } public 9oid suona(int nota(int tempo) { suona(nota(tempo('); } public 9oid zitto() { CA%A/IB'C&all%otes>55(); } } "" Gnd o5 Sintetizzatore }
:::...
8vrete notato la corposit del programma, non fatevi spaventare, perch la maggior parte del codice serve per la grafica e per sentire gli eventi, la parte interessante per sintetizzare suoni l'ho racchiusa nella sottoclasse :intetizzatore, ovvero in sintetizzatore.:intetizzatore ovvero la seguente9 ""66666666666666666666666666666666666666666666666666666666666 "" SintetizzatoreL ""66666666666666666666666666666666666666666666666666666666666 public class Sintetizzatore { pri9ate S<nt#esizer SN%2; pri9ate Se=uencer se=uencer; pri9ate Se=uence se=; pri9ate SoundbanA :A%a; public InstrumentBC Strumenti; public MidiC#annelBC CA%A/I;
:::...
public Sintetizzatore() { setupSintetizzatore(); } 9oid setupSintetizzatore() { tr< { SN%2 MidiS<stem&getS<nt#esizer(); se=uencer MidiS<stem&getSe=uencer(); se= ne! Se=uence(Se=uence&**R( +'); SN%2&open(); :A%a SN%2&get@e5aultSoundbanA(); i5 (:A%a W null) Strumenti SN%2&get@e5aultSoundbanA()&getInstruments(); else Strumenti SN%2&getA9ailableInstruments(); CA%A/I SN%2&getC#annels(); } catc#(MidiFna9ailableG8ception ecc){tuttonull();} catc#(In9alidMidi@ataG8ception ecc1){tuttonull();} ; } 9oid tuttonull() { SN%2 null; se=uencer null; se= null; :A%a null; Strumenti null; } public 9oid setStrumento(int str(int can) { SA str; int prog StrumentiBstrC&get*atc#()&get*rogram(); CA%A/IBcanC&programC#ange(prog); } pri9ate int SA '; public 9oid cambiaCanale(int can) { int prog StrumentiBSAC&get*atc#()&get*rogram(); CA%A/IBcanC&programC#ange(prog); } public 9oid suona(int nota(int tempo( int canale) { CA%A/IBcanaleC&all%otes>55(); CA%A/IBcanaleC&note>n(nota(tempo); } public 9oid suona(int nota(int tempo) { suona(nota(tempo('); } public 9oid zitto() { CA%A/IB'C&all%otes>55(); } } "" Gnd o5 Sintetizzatore %'aspetto del programma il seguente9
:::...
:::...
:::...
LEZIONE 39:
**iamo fatto una carrellata su alcune parti del famoso linguaggio Java, usatissimo per scrivere programmi che girano su internet e non solo, iniziando dalle *asi fino ad arrivare alle interfacce grafiche, la grafica ed infine il suono, tutti aspetti a**astanza avanzati della programmazione. /orrei scusarmi con i lettori meno esperti se hanno avuto qualche pro*lema nel comprendere alcune parti della guida, e allo stesso tempo vorrei scusarmi con i pi) esperti se hanno trovato le alcune cose noiose o troppo semplici. +hi ha seguito il corso dovre**e essere in grado di scriversi delle semplici applet e applicazioni da solo, non penso che siate ancora in grado di gestire grosse applicazioni complesse, anche se con un po' di pratica e i semplici concetti del corso penso che diverrete ottimi programmatori. Io rimmarr3 sempre disponi*ile per eventuali domande sul corso o chiarimenti &non scrivetemi per i Javascript o per la configurazione degli applet scaricati dalla rete'. Der chi volesse approfondire gli argomenti trattati o vederne di nuovi, pu**lico la *i*liografia completa dalla quale partono le mie conoscenze. 5n saluto a tutti Pietro Castell&cci Roiano di /al Rortore &-enevento' $i'liogra-ia
Conclusioni e bibliogra ia
(ocumentazione ufficiale della :un #icros stems di Java (evelopment ;it /ersioni <.C, <.C Belase +andidate <, <.C Belase +andidate =, <.C Belase +andidate C, <.C -eta, <.=.= , <.=.<. (isponi*ile in rete sul sito ufficiale di Java9 http944>ava.sun.com Java (idattica e Drogrammazione, ;.8rnold e J. 0osling, 8ddisonP2esle Drima edizione, #arzo <FFV #anuale .57 P :pecial 7dition 5sing Java, =nd 7dition, versione trovata su internet. Java= !utto^Oltre, J. Jawors$i, :8#: Du*lishing P 8DO07O Javatm =( 0raphics, J. ;nudsen, O'B7I%%W 8m*iente per l'esplorazione di micromondi concorrenti, Dietro +astellucci, !esi di %aurea in Informatica.
:::...

Corso Java

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Corso Java

Caricato da

Copyright:

Formati disponibili

...::: h t t p : / / m a g o n i c o l a . 4 t .

MANUALE COMPLETO DI JAVA

Cosa sono i Package di Java

Scrittura di applicazioni "a console"

Il nostro primo programma in Java

Tipi primitivi di Java e valori

public double A static int : +'+;

pri9ate 5inal int C

protected static boolean @ public p() { M +' ; N M; O MEN;

static int C>H%>MG

Il programma da scrivere in Ri*o.>ava il seguente9 class Fibo

...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE 10:

Eccezioni e cenni sui thread

Chiave 0ava.ver"ion 0ava.vendor 0ava.vendor.url 0ava.home

public class ?9ettore { public static int %FMG?> +''''';

public static 9oid main (StringBC s) { 3ector 3 ne! 3ector(%FMG?>);

i5 (numnome numnome--; 3&add(i(tmp);

public class ?#as# { public static int %FMG?> +''''';

public static 9oid main (StringBC s) { Uas#table U ne! Uas#table(%FMG?>E+);

conclusioni sui package

Interfacce grafiche ed eventi

Cosa una applicazione a Finestre

public static 9oid main(StringBC arg) { ne! FinestraS!ing();

Inter acce gra ic!e" #$I e A%T

Contenitori e Gestione dei Layout

Il Testo' gli eventi' (ialog

...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE "6:

La gestione degli eventi in Java)

6ella Rigura si pu3 vedere una !ooltip su uno dei *ottoni.

%e tool*ar possono essere facilmente nascoste e visualizzate sullo schermo.

+ondamenti di disegno con Java

+unzioni paint' repaint' update,,

H&addAction/istener(ne! Action/istener() { public 9oid action*er5ormed(ActionG9ent e) { ir %>; ig SI; ib %>; repaint(); }

...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE 3":

+igure geometric!e e testo

ile gra (emo,-ava

.ote per compilare il programma

Il suono di Java /,/,0 e /,),0

I pacchetti aggiunti al linguaggio sono ?9 <. >ava".sound.midi =. >ava".sound.midi.spi C. >ava".sound.sampled ?. >ava".sound.sampled.spi

...::: h t t p : / / m a g o n i c o l a . 4 t . c o m LEZIONE 37:

9oid setupG9enti() { tastiera+&addMouse/istener(ne! 2astiera+/istener()); tastiera1&addMouse/istener(ne! 2astiera1/istener());

Strumenti&addItem/istener(ne! Item/istener() { public 9oid itemStateC#anged(ItemG9ent e) { SI%2G2IOOA2>?G&setStrumento( Strumenti&getSelectedInde8()(CA%A/G); } } );

Canali&addItem/istener(ne! Item/istener() { public 9oid itemStateC#anged(ItemG9ent e) { CA%A/G Canali&getSelectedInde8(); SI%2G2IOOA2>?G&cambiaCanale(CA%A/G); } });

Potrebbero piacerti anche