Download dell'intero lavoro - Provincia di Torino
Download dell'intero lavoro - Provincia di Torino
Download dell'intero lavoro - Provincia di Torino
You also want an ePaper? Increase the reach of your titles
YUMPU automatically turns print PDFs into web optimized ePapers that Google loves.
SCUOLA INTERATENEO DI SPECIALIZZAZIONE<br />
PER LA FORMAZIONE DEGLI INSEGNANTI DELLA SCUOLA SECONDARIA<br />
SIS<br />
Via Carlo Alberto 10 – 10123 TORINO –<br />
tel. 011.6702887 Fax 011.6702888<br />
e-mail: sis@dm.unito.it<br />
Un approccio <strong>di</strong>dattico per la programmazione orientata<br />
agli oggetti in linguaggio Java in una V a I.T.I.S.<br />
Relazione finale per l’abilitazione<br />
all’insegnamento secondario<br />
Anno Accademico 2005-2006<br />
In<strong>di</strong>rizzo<br />
Tecnologico<br />
Classe <strong>di</strong> Abilitazione<br />
A042 – Informatica<br />
Can<strong>di</strong>dato<br />
CANDIDO Abramo<br />
Supervisore<br />
prof. BELOTTI Pierangelo
Quando insegni, insegna allo stesso tempo a dubitare <strong>di</strong> ciò che insegni.<br />
Ortega y Gasset<br />
2
CONTENUTI<br />
1. Introduzione ................................................................................................... 4<br />
2. Il Riferimento <strong>di</strong>dattico metodologico......................................................... 5<br />
2.1. Le scelte <strong>di</strong>dattiche ........................................................................................................................ 5<br />
2.2. Verso la competenza informatica................................................................................................ 7<br />
2.3. Insegnare Informatica................................................................................................................... 8<br />
2.4. Didattica dell’informatica............................................................................................................. 9<br />
2.5. Scelta degli strumenti e delle metodologie................................................................................. 11<br />
3. Il progetto ..................................................................................................... 12<br />
3.1. Il contesto dell’intervento <strong>di</strong>dattico ........................................................................................... 12<br />
3.2. Scelta dei contenuti in relazione alla <strong>di</strong>sciplina e alle sue caratteristiche .............................. 12<br />
3.3. Descrizione sintetica del progetto............................................................................................... 13<br />
3.3.1. Programmazione <strong>di</strong>dattica ......................................................................................................... 14<br />
4. Analisi del processo ..................................................................................... 16<br />
4.1. Lo svolgimento dell’intervento <strong>di</strong>dattico................................................................................... 16<br />
4.1.1. Didattica e software libero.......................................................................................................... 17<br />
4.2. Gli aspetti emotivi e relazionali.................................................................................................. 18<br />
4.3. Riflessioni ..................................................................................................................................... 20<br />
4.4. Progettazione della verifica ........................................................................................................ 22<br />
4.5. Valutazione del <strong>lavoro</strong> fatto dagli studenti ............................................................................... 24<br />
5. Conclusioni ................................................................................................... 28<br />
Bibliografia................................................................................................................. 31<br />
Supporti Didattici:<br />
Supporto Didattico A ........................................................ Trasparenze usate nell’I.D. all’Itis Avogadro<br />
Supporto Didattico B .............................................Dispense <strong>di</strong>dattiche usate nell’I.D. all’Itis Avogadro<br />
Supporto Didattico C .....................................................Verifica sommativa per l’I.D. all’Itis Avogadro<br />
Allegati:<br />
Allegato A ............................................................................................ P.O.F Itis Avogadro A.A. 2005-06<br />
3
1. Introduzione<br />
I corsi frequentati alla SSIS, con la bibliografia suggerita dalla stessa istituzione, e le esperienze <strong>di</strong><br />
tirocinio hanno rappresentato una ghiotta opportunità e un osservatorio privilegiato per utilizzare le<br />
chiavi <strong>di</strong> lettura fornite per indagare e comprendere i processi cognitivi degli allievi, le strategie da<br />
loro messe in atto nella risoluzione <strong>di</strong> problemi, le convinzioni e le emozioni con le quali affrontano<br />
e si rapportano allo stu<strong>di</strong>o dell’informatica. L’ingresso in aula come insegnante, con al seguito le<br />
nozioni pedagogico-psicologiche e i vari modelli <strong>di</strong>dattici, si è rivelata una tappa fondamentale del<br />
percorso <strong>di</strong> costruzione della ricetta del “buon insegnante”, e ha permesso <strong>di</strong> confutare o constatare<br />
come trovano realizzazione pratica le teorie e i modelli <strong>di</strong>dattici <strong>di</strong> riferimento che non possono<br />
prescindere dal considerare gli aspetti emotivi e relazionali.<br />
Questo <strong>lavoro</strong> nasce da un approccio <strong>di</strong>dattico adottato durante l’esperienza <strong>di</strong> tirocinio attivo<br />
svoltasi nell’anno scolastico 2005-06 presso l’Istituto Tecnico Industriale “A. Avogadro”.<br />
Lo scopo dell’intervento <strong>di</strong>dattico, stabilito con i docenti accoglienti e unitamente al supervisore, ha<br />
riguardato l’introduzione alla programmazione ad oggetti tramite il linguaggio Java. Si è cercato <strong>di</strong><br />
porre gli allievi in una situazione non solo “<strong>di</strong> fare”, e quin<strong>di</strong> <strong>di</strong> “acquisire facendo”, ma anche <strong>di</strong><br />
collaborare all’interno del gruppo e <strong>di</strong> comprendere le <strong>di</strong>namiche e le fasi <strong>di</strong> progettazione <strong>di</strong><br />
artefatti software. Attraverso la modellazione si sono aiutati i ragazzi a fare proprie le teorie<br />
presentate, e si è facilitata la comprensione dei processi che sono alla base della nascita <strong>di</strong> una<br />
applicazione informatica. La formazione a cui mira la mia proposta tende a spostare l’attenzione<br />
dall’impostazione teorica e <strong>di</strong>sciplinare ad una <strong>di</strong>dattica e pratica che implica una particolare<br />
attenzione ai bisogni degli allievi, bisogni che ho “imparato ad imparare” e che proprio per questi<br />
motivi, sarò certamente in grado <strong>di</strong> apprezzare.<br />
Non mi sono accontentato <strong>di</strong> un’osservazione dei fenomeni nella loro in<strong>di</strong>vidualità e peculiarità ma<br />
ho cercato <strong>di</strong> cogliere l’aspetto globale e <strong>di</strong>namico delle situazioni, evidenziando correlazioni<br />
(aspetti fondamentali nell’ambito dell’osservazione <strong>di</strong> situazioni educative); né mi sono limitato a<br />
rilevare i dati cercando <strong>di</strong> dare una lettura <strong>di</strong> ciò che vedevo avendo la necessità <strong>di</strong> cogliere<br />
caratteristiche e/o <strong>di</strong>namiche interne, senza pregiu<strong>di</strong>zi, al fine <strong>di</strong> comprendere in modo oggettivo.<br />
Il presente <strong>lavoro</strong> è organizzato per sezioni, ho cercato <strong>di</strong> collocarlo in un quadro unitario<br />
analizzando la grande quantità <strong>di</strong> elementi raccolti e riprendendo le piste e spunti <strong>di</strong> riflessione che<br />
sono germogliate copiose durante questo cammino formativo del biennio alla SSIS. In questo <strong>lavoro</strong><br />
<strong>di</strong> “scomposizione” degli eventi sono stati estremamente preziosi gli strumenti <strong>di</strong> preparazione<br />
all’intervento <strong>di</strong>dattico, materiale <strong>di</strong>dattico, presentazioni, griglie <strong>di</strong> valutazione e liste <strong>di</strong> controllo<br />
degli aspetti da monitorare, perché mi hanno aiutato ad in<strong>di</strong>viduare le singole variabili atomiche del<br />
processo <strong>di</strong> appren<strong>di</strong>mento-insegnamento.<br />
La presenza in classe è stata un piacevole ritorno tra una <strong>di</strong>mensione scolastica innovata in cui il<br />
ruolo degli attori si è evoluto assumendo caratteristiche nuove.<br />
4
2. Il Riferimento <strong>di</strong>dattico metodologico<br />
L’intervento in classe e la sua conduzione <strong>di</strong>retta ha rappresentato, grazie alle esperienze <strong>di</strong><br />
tirocinio, il momento per applicare, sperimentare, valutare e far sorgere una riflessione critica in<br />
itinere degli insegnamenti appresi durante la frequenza dei corsi <strong>di</strong>sciplinari e trasversali della SIS.<br />
La consapevolezza dell’esistenza <strong>di</strong> <strong>di</strong>versi approcci <strong>di</strong>dattici per presentare agli allievi un dato<br />
argomento è necessaria e funzionale per operare delle scelte <strong>di</strong> impostazione della <strong>di</strong>dattica, e per<br />
delineare una strategia <strong>di</strong> appren<strong>di</strong>mento.<br />
A tal proposito sono state fonti <strong>di</strong> ispirazione per come presentare la materia agli studenti i corsi del<br />
macroesame <strong>di</strong> Didattica dell’informatica e Storia ed epistemologia della scienza dai quali ho<br />
apprezzato l’importanza <strong>di</strong> contestualizzare il sapere scientifico e <strong>di</strong> ban<strong>di</strong>re l’approccio<br />
epistemologico empirista-positivista che tende a trasmettere la concezione della scienza come un<br />
prodotto confezionato e sinonimo <strong>di</strong> verità, commettendo un delitto intellettuale e occultando il<br />
processo della scienza, il turbinio e l’affanno che si cova <strong>di</strong>etro alla corrente e momentaneamente<br />
adottata teoria, e i tratti propri del sapere scientifico (ipotetico, contingente, storicamente<br />
determinato, non oggettivo, non riflessivo della realtà). Le conseguenze della concezione positivista<br />
sull’insegnamento vanno a sancire il primato dell’osservazione e l’evidenza come fonte <strong>di</strong><br />
conoscenza, e si ripercuotono sul modello <strong>di</strong>dattico d’appren<strong>di</strong>mento che è quello trasmissivo con i<br />
lati negativi (natura innaturale della scienza, neutralità concettuale dell’allievo, rappresentazioni<br />
concettuali <strong>di</strong>fformi degli allievi, rottura epistemologica).<br />
2.1. Le scelte <strong>di</strong>dattiche<br />
Oggi, invece, non si può fare a meno <strong>di</strong> pensare a un ruolo attivo degli studenti nella costruzione del<br />
loro sapere; non solo, quin<strong>di</strong> “educare”, ma anche “educere” [dal latino educere = trarre fuori].<br />
Alla luce <strong>di</strong> questo significato ambivalente che assume il termine educazione, si delinea un nuovo<br />
ruolo per l’insegnante che, come sostiene Gordon, “non è più colui che trasferisce il suo sapere agli<br />
studenti ma colui che sa essere con gli studenti in modo funzionale al loro processo <strong>di</strong><br />
appren<strong>di</strong>mento o ,meglio ancora, al processo attraverso il quale gli studenti educano sè stessi” 1 .<br />
Alla base del metodo trasmissivo vi è l’idea <strong>di</strong> uno studente paragonabile ad un “bicchiere vuoto”,<br />
che l’insegnante ha il compito <strong>di</strong> riempire <strong>di</strong> contenuti: le conoscenze vengono semplicemente<br />
trasmesse dall’insegnante all’allievo tramite le classiche lezioni frontali in cui il docente spiega e gli<br />
allievi ascoltano; gli studenti hanno poi il dovere <strong>di</strong> stu<strong>di</strong>are e rielaborare da soli sul libro <strong>di</strong> testo gli<br />
argomenti illustrati in classe.<br />
Il metodo socio-costruttivista parte invece da un presupposto profondamente <strong>di</strong>verso, cioè dall’idea<br />
<strong>di</strong> studente come soggetto pensante. Le conoscenze non possono essere trasmesse, ma devono<br />
essere costruite da colui che apprende a partire dalle concezioni che ha, con l’aiuto dell’insegnante e<br />
la collaborazione del gruppo classe: gli studenti, pertanto, <strong>di</strong>ventano protagonisti del processo <strong>di</strong><br />
appren<strong>di</strong>mento. Il modello costruttivista 2 sostiene, infatti, che un appren<strong>di</strong>mento efficace<br />
presupponga un cambiamento metodologico nella costruzione del sapere e che, dunque, non si<br />
possa fare a meno <strong>di</strong> tenere in considerazione le concezioni iniziali degli studenti, spesso costituite<br />
da conoscenze accettate senza alcun spirito critico. In particolare, nell’ambito delle <strong>di</strong>scipline<br />
scientifiche, questo tipo <strong>di</strong> approccio comporta l’avvicinarsi degli allievi alla metodologia<br />
scientifica nei suoi aspetti essenziali: formalizzare un problema, proporre delle ipotesi, verificare le<br />
ipotesi, ecc. Per poter mettere in atto un insegnamento basato su questo approccio, è molto utile<br />
proporre situazioni problematiche che possono suscitare interesse negli studenti coinvolgendoli<br />
1 T. Gordon, “Insegnanti efficaci. Il metodo Gordon: pratiche educative per insegnanti, genitori e studenti”, ed. Giunti<br />
Lisciani, pag.7<br />
2 D.W. Johnson, R. T. Johnson, E.J. Holubec, Appren<strong>di</strong>mento cooperativo in classe, Trento, Erickson, 1996, pp. 17-35.<br />
5
emotivamente ed è altrettanto utile dare spazio a lavori <strong>di</strong> gruppo in cui gli allievi, guidati<br />
dall’insegnante, possano confrontarsi tra loro.<br />
Ma dopo aver trovato un modello <strong>di</strong> riferimento, quale metodologia <strong>di</strong>dattica mettere in atto Forte<br />
delle esperienze <strong>di</strong> tirocinio del biennio S.I.S. non ci sono stati dubbi: non esiste una metodologia<br />
perfetta e un insegnante non può mettere in atto solo ed esclusivamente un tipo <strong>di</strong> <strong>di</strong>dattica. In ogni<br />
insegnante coesistono <strong>di</strong>verse metodologie (che in parte ne rispecchiano la personalità) e l’abilità<br />
sta proprio nell’adattare la metodologia <strong>di</strong> <strong>lavoro</strong> al contesto e alle caratteristiche della classe in cui<br />
si va ad operare.<br />
In relazione a questo aspetto, nello svolgimento del presente intervento <strong>di</strong>dattico, si è adoperata una<br />
metodologia, <strong>di</strong>fficilmente ascrivibile ad una determinata categoria, che raccoglie spunti<br />
principalmente da tre tipologie <strong>di</strong> <strong>di</strong>dattica:<br />
• Didattica per concetti<br />
• Didattica per problemi<br />
• Didattica per obiettivi<br />
Il tutto coor<strong>di</strong>nato dall’approccio costruttivista: i ragazzi devono costruire il loro sapere e non si può<br />
pensare <strong>di</strong> trasmettere conoscenza.<br />
Per fare un breve cenno sulle caratteristiche principali <strong>di</strong> questi tipi <strong>di</strong> <strong>di</strong>dattica, si può cominciare<br />
con il mettere in evidenza che le tre metodologie in questione concentrano la loro attenzione su<br />
aspetti <strong>di</strong>versi: la <strong>di</strong>dattica per problemi dà rilievo soprattutto ai processi dell’appren<strong>di</strong>mento, la<br />
<strong>di</strong>dattica per obiettivi ai risultati, mentre la <strong>di</strong>dattica per concetti considera entrambi gli aspetti.<br />
Quello che mi prefiggevo, progettando il mio intervento <strong>di</strong>dattico, era <strong>di</strong> tenere in considerazione<br />
tutti questi aspetti, pertanto, nell’analisi del <strong>lavoro</strong> condotto si potranno identificare aspetti relativi a<br />
tutte e tre le metodologie <strong>di</strong>dattiche.<br />
L’integrazione <strong>di</strong> <strong>di</strong>verse metodologie <strong>di</strong>dattiche ha permesso <strong>di</strong> impostare il <strong>lavoro</strong> in modo più<br />
flessibile, adeguandolo <strong>di</strong> volta in volta alle necessità del momento. Pertanto, non si è esclusa a<br />
priori alcuna metodologia, ma si è cercato <strong>di</strong> utilizzare il bagaglio accumulato durante la frequenza<br />
S.I.S. e durante la breve esperienza <strong>di</strong> insegnamento per adattare l’intervento al contesto <strong>di</strong> <strong>lavoro</strong>.<br />
Nel delineare un modello <strong>di</strong> riferimento, non si può fare a meno <strong>di</strong> considerare gli aspetti<br />
relazionali, che certamente non sono <strong>di</strong> secondaria importanza. Purtroppo, la scuola trascura la<br />
<strong>di</strong>mensione emotiva 3 che entra in gioco nel processo <strong>di</strong> insegnamento-appren<strong>di</strong>mento; come ha<br />
evidenziato Winnicott nell’ambito <strong>di</strong> un ampio <strong>di</strong>scorso sulla società in generale, la scuola spesso<br />
paga a caro prezzo, dal punto <strong>di</strong> vista dell’insuccesso e dell’inefficienza, la sua <strong>di</strong>sattenzione nei<br />
confronti dei fattori emotivo-affettivi. Ripensando ai vecchi programmi ministeriali, si rende conto<br />
<strong>di</strong> come la scuola, fino a poco tempo fa, considerasse separatamente la <strong>di</strong>mensione cognitiva da<br />
quella emotiva, dando spesso per scontata la buona situazione emotiva degli allievi.<br />
Gli insegnanti si trovano <strong>di</strong> fronte a vissuti <strong>di</strong> ansia, <strong>di</strong> aggressività e <strong>di</strong> insuccesso che riguardano<br />
non allievi con problemi <strong>di</strong> han<strong>di</strong>cap, ma studenti normodotati o ad<strong>di</strong>rittura dotati <strong>di</strong> una creatività<br />
fuori dal comune. Di fronte a ciò non esiste la “ricetta del buon insegnante” ma è già un passo<br />
avanti se il docente tiene conto del fatto che con il proprio atteggiamento nei confronti degli<br />
studenti può influenzare il modo in cui i ragazzi si rapporteranno alla <strong>di</strong>sciplina. Non è sufficiente,<br />
quin<strong>di</strong>, che un insegnante sia molto preparato, né tanto meno, che sia innamorato della propria<br />
materia, per stimolare gli allievi e far nascere in loro il desiderio <strong>di</strong> apprendere è necessario<br />
impostare un buon rapporto prima <strong>di</strong> tutto dal punto <strong>di</strong> vista umano e una relazione positiva tra<br />
menti che favorisca la crescita mentale e promuova la “pensabilità” 4 .<br />
In definitiva un insegnamento può <strong>di</strong>ventare interessante se impartito da un insegnante che abbia<br />
appreso il modo corretto <strong>di</strong> rapportarsi con gli studenti, instaurando una relazione <strong>di</strong> reciproco<br />
rispetto. Alla luce <strong>di</strong> queste considerazioni, è nata una consapevolezza: l’ ”arma” principale <strong>di</strong> ogni<br />
3 G. Blan<strong>di</strong>no, B. Granieri , Le risorse emotive nella scuola, 2004, Cortina, Milano<br />
4 A.R.Colasanti, Star bene a scuola: la promozione <strong>di</strong> comportamenti sociali positivi , in “Orientamenti pedagogici”,<br />
vol. n. 49, n.4 (292), luglio-agosto, 2002, pp. 595-610.<br />
6
insegnante è la riflessione, che porta a considerare la molteplicità <strong>di</strong> aspetti che entrano in gioco nel<br />
processo <strong>di</strong> appren<strong>di</strong>mento e a tenerne conto nell’organizzazione del <strong>lavoro</strong>.<br />
L’insegnante <strong>di</strong>viene un me<strong>di</strong>atore ed è evidente che la con<strong>di</strong>visione <strong>di</strong> obiettivi e finalità sia un<br />
elemento imprescin<strong>di</strong>bile per realizzare un buon intervento in classe 5 , gli allievi hanno il <strong>di</strong>ritto <strong>di</strong><br />
conoscere quale sarà il percorso <strong>di</strong>dattico che affronteranno, avere la possibilità <strong>di</strong> mo<strong>di</strong>ficarlo in<br />
base ai loro bisogni e esigenze.<br />
Grazie al tirocinio ho utilizzato le chiavi <strong>di</strong> lettura fornite nel corso <strong>di</strong> Didattica dell’Informatica 6 : la<br />
necessità <strong>di</strong> indagare e comprendere i processi cognitivi degli allievi, le strategie da loro messe in<br />
atto nella risoluzione <strong>di</strong> problemi, le convinzioni ed emozioni con le quali affrontano lo stu<strong>di</strong>o dei<br />
sistemi informatici; ma è un’opportunità che naturalmente nasce solo se si tiene conto delle<br />
esigenze <strong>di</strong> chi, docente e studenti, mette a <strong>di</strong>sposizione il proprio tempo, il proprio <strong>lavoro</strong> e nel<br />
caso degli studenti…se stessi.<br />
2.2. Verso la competenza informatica<br />
Se la competenza <strong>di</strong>venta nell’ambito teorico un senso possibile, é importante chiarire il significato<br />
<strong>di</strong> alcuni termini propri del linguaggio cognitivo utilizzato in <strong>di</strong>dattica della informatica, termini<br />
utilizzati in riferimento sia agli oggetti <strong>di</strong> insegnamento (contenuti) che all’appren<strong>di</strong>mento degli<br />
studenti (conoscenze, competenze):<br />
Contenuto: una porzione limitata <strong>di</strong> sapere;<br />
Conoscenza: è, allo stesso tempo, la rielaborazione <strong>di</strong> contenuti in modo autonomo per raggiungere<br />
una meta, e il risultato <strong>di</strong> tale elaborazione; una conoscenza può coinvolgere uno o più contenuti;<br />
Competenza: è un concetto complesso e <strong>di</strong>namico. Complesso poiché si tratta dell’insieme <strong>di</strong> due<br />
componenti, uso (esogeno) e padronanza (endogena), <strong>di</strong> conoscenze che collegano contenuti<br />
<strong>di</strong>versi; concetto <strong>di</strong>namico, in quanto la competenza non si esprime solo attraverso l’uso e la<br />
padronanza, la competenza racchiude in sé anche fattori metacognitivi, affettivi, il desiderio <strong>di</strong><br />
completare conoscenze e quin<strong>di</strong> <strong>di</strong> aumentare competenze.<br />
Come insegnante ho cercato <strong>di</strong> orientarmi e <strong>di</strong> considerare lo studente come colui che deve<br />
raggiungere competenza e non “semplice” conoscenza. La competenza implica necessariamente il<br />
“voler fare”, dunque chiama imme<strong>di</strong>atamente in causa fatti affettivi come volizione e<br />
atteggiamento. I mezzi che ci permettono <strong>di</strong> passare dalle capacità alle competenze sono le<br />
conoscenze che maturiamo e le abilità <strong>di</strong> cui ci impadroniamo e che usiamo nelle <strong>di</strong>verse situazioni.<br />
Nessuno può <strong>di</strong>chiarare <strong>di</strong> essere più o meno competente fino a quando non è posto nelle con<strong>di</strong>zioni<br />
<strong>di</strong> poterlo <strong>di</strong>mostrare, fino a quando, cioè, non fa esercizio delle proprie capacità.<br />
Le capacità se non esercitate si atrofizzano, non si sviluppano e non <strong>di</strong>ventano mai competenze; è<br />
un bene se queste capacità atrofizzate riguardano la parte meno nobile del nostro essere, è un male<br />
se riguardano ciò che ci rende migliori.<br />
La competenza in informatica è al centro della <strong>di</strong>sciplina, riconosciuta come scienza costituita,<br />
come oggetto proprio, specifico, <strong>di</strong> conoscenza. L’allievo entra in contatto con saperi specifici,<br />
saperi che la società ha inglobato nelle conoscenze riconosciute come base per un <strong>di</strong>gnitoso<br />
ingresso nel suo interno; si appropria <strong>di</strong> una parte <strong>di</strong> tali saperi, tanto formalmente quanto<br />
informalmente.<br />
La competenza informatica si riconosce quando un in<strong>di</strong>viduo vede, interpreta e si comporta nel<br />
mondo in un senso informatico. Ci sono buoni risolutori <strong>di</strong> problemi che possono riconoscere,<br />
delimitare e risolvere situazioni problematiche; il che, viceversa, a volte, non è facile da evidenziare<br />
in persone che trattano bene algoritmi. Poiché la competenza informatica comporta la capacità e<br />
<strong>di</strong>sponibilità a guardare il mondo in modo informatico e dato che ciò non si apprende<br />
spontaneamente in modo implicito, si rende necessario pensare che deve far parte del curricolo,<br />
5 A. Calvani, Elementi <strong>di</strong> <strong>di</strong>dattica, Roma, Carocci, 2000.<br />
6 Corso <strong>di</strong> Didattica dell’Informatica e Laboratorio <strong>di</strong> Informatica, A.A. 2004-05, prof. B. Montrucchio<br />
7
proprio questo processo <strong>di</strong> insegnamento–appren<strong>di</strong>mento specificamente rivolto a “saper vedere<br />
informaticamente” il mondo.<br />
In virtù della complessità racchiusa nel termine competenza, la valutazione <strong>di</strong> competenze non può<br />
ridursi ad un test tra<strong>di</strong>zionale (tipicamente compito in classe o interrogazione), per verificare la<br />
padronanza in qualche cosa <strong>di</strong> specifico. La valutazione, in vista <strong>di</strong> una <strong>di</strong>dattica volta a far<br />
raggiungere competenze si presenta come un processo <strong>di</strong> analisi dell’aula, ovvero delle sue varie<br />
componenti: il curricolo, l’efficacia dell’insegnante e l’allievo.<br />
2.3. Insegnare Informatica<br />
L’informatica come <strong>di</strong>sciplina ha una duplice valenza: quella <strong>di</strong> essere considerata come una<br />
scienza che stu<strong>di</strong>a le regole generali della trasmissione, della rappresentazione e della<br />
conservazione <strong>di</strong> informazioni, con una propria epistemologia, e può essere inserita tra le nuove<br />
tecnologie che stanno cambiando ra<strong>di</strong>calmente il nostro modo <strong>di</strong> vivere. Anche se risulta riduttivo<br />
confinarla solo all’uso del calcolatore o <strong>di</strong> applicazioni per calcolatori, in essa confluiscono la<br />
matematica, la logica, la fisica, la teoria dell’informazione, l’elettronica. Le tecnologie informatiche<br />
si occupano della elaborazione delle informazioni in segnali elettrici in grado <strong>di</strong> essere trattati dai<br />
calcolatori e quin<strong>di</strong> produce i “linguaggi” e le istruzioni che i calcolatori capiscono.<br />
Credo che sia utile conoscere quali siano gli obiettivi dell’insegnamento <strong>di</strong> Informatica e <strong>di</strong> Sistemi<br />
<strong>di</strong> elaborazione e trasmissione dell’informazione (classe <strong>di</strong> abilitazione A042).<br />
Il corso <strong>di</strong> informatica ha come fine principale quello <strong>di</strong> mettere l’allievo in con<strong>di</strong>zioni <strong>di</strong> affrontare<br />
la soluzione <strong>di</strong> un problema, posto dalla richiesta <strong>di</strong> un ipotetico committente, scegliendo le<br />
metodologie e gli strumenti software più idonei, offrendo all’allievo la formazione necessaria per<br />
seguire con una certa autonomia l’evoluzione delle tecnologie informatiche senza assumere un<br />
carattere nozionistico-sintattico e ridursi ad una collezione <strong>di</strong> parata sistematica sui vari tecnicismi<br />
riguardanti la nicchia dei linguaggi <strong>di</strong> programmazione o dei sistemi <strong>di</strong> gestione delle base dati.<br />
L’allievo deve sviluppare le capacità <strong>di</strong> analizzare e risolvere problemi <strong>di</strong> varia natura, deve<br />
interpretare il problema e costruirne la soluzione, acquisire la capacità <strong>di</strong> lavorare in gruppo<br />
sviluppando capacità relazionali, superando la competizione ed imparando a criticare e ad essere<br />
criticati.<br />
L’insegnante ha il compito <strong>di</strong> aiutare l’allievo per portarlo all’acquisizione della mentalità<br />
informatica coa<strong>di</strong>uvandolo nel potenziamento delle capacità richieste (astrazione, generalizzazione,<br />
associazione, <strong>di</strong>pendenze, correlazioni, modellazione coerente con la realtà per descrivere le entità e<br />
le relazioni che costituiranno la base dati, applicazione degli algoritmi e delle strutture in maniera<br />
ottimale) senza trascurare gli aspetti organizzativi e motivazionali<br />
Il corso <strong>di</strong> sistemi <strong>di</strong> elaborazione e trasmissione dell’informazione si pone la finalità <strong>di</strong> contribuire<br />
alla formazione <strong>di</strong> un adeguato bagaglio <strong>di</strong> precise conoscenze tecniche e <strong>di</strong> capacità operative<br />
riguardanti i calcolatori e le reti <strong>di</strong> trasmissione dell’informazione. L’allievo deve acquisire capacità<br />
<strong>di</strong> analisi dei sistemi informatici, e strategie specifiche <strong>di</strong> risoluzione dei problemi. Bisogna evitare<br />
<strong>di</strong> ridurre la trattazione della <strong>di</strong>sciplina a puro nozionismo descrittivo, per privilegiare, invece, le<br />
semplici realizzazioni alla portata degli allievi, in laboratorio; ciò consente <strong>di</strong> preparare gli alunni<br />
alla risoluzione pratica <strong>di</strong> piccoli problemi <strong>di</strong> <strong>di</strong>mensionamento <strong>di</strong> sistemi informatici. E’ infatti<br />
attraverso la sperimentazione sulla macchina che lo studente è in grado in comprendere e<br />
interiorizzare i costrutti del linguaggio o gli schemi sistemistici presentati a lezione. Dopo ogni<br />
modulo deve essere possibile pensare ad una attività <strong>di</strong> laboratorio, dove da un lato si presenti<br />
l’ambiente <strong>di</strong> sviluppo (sistema operativo, e<strong>di</strong>tor, compilatore, ecc.) e dall’altro si consenta allo<br />
studente la compilazione <strong>di</strong> programmi già scritti, l’identificazione <strong>di</strong> errori sintattici in programmi<br />
già scritti e la scrittura <strong>di</strong> semplici programmi nuovi dal nulla o partendo da schemi da completare.<br />
8
2.4. Didattica dell’informatica<br />
Si potrebbe pensare che – essendo l’informatica una <strong>di</strong>sciplina fondata sulla matematica <strong>di</strong>screta –<br />
molte delle proposte formulate in <strong>di</strong>dattica della matematica si trasferiscano allo stu<strong>di</strong>o<br />
dell’informatica. Questo è vero solo parzialmente, e per varie ragioni. La ragione principale sta nel<br />
fatto che insegnare informatica vuol <strong>di</strong>re non solo insegnare concetti e metodologie, ma anche<br />
tecnologia. La necessità <strong>di</strong> mettere gli studenti in grado <strong>di</strong> risolvere problemi concreti, e cioè <strong>di</strong><br />
analizzarli, <strong>di</strong> progettare soluzioni e <strong>di</strong> implementarle utilizzando il calcolatore, pone in molti casi<br />
problemi <strong>di</strong>dattici non trascurabili. Questi sono riassumibili a mio avviso come segue:<br />
• il primo problema è quello <strong>di</strong> stabilire il rapporto corretto tra i <strong>di</strong>versi ambiti <strong>di</strong><br />
insegnamento – per l’appunto concetti, metodologie e tecnologie – per evitare<br />
sbilanciamenti pericolosi, e in un senso – corsi eccessivamente teorici, dai quali gli studenti<br />
apprendono molti concetti ma senza essere in grado <strong>di</strong> metterli concretamente in pratica – e<br />
nell’altro – corsi eccessivamente tecnologici, dai quali gli studenti apprendono solo<br />
competenze prettamente operative, senza la dovuta ampiezza metodologica;<br />
• il secondo problema, una volta stabilito il giusto equilibrio tra teoria e pratica, è<br />
rappresentato dal modo in cui le nozioni dei <strong>di</strong>versi ambiti devono essere insegnate; è<br />
<strong>di</strong>fficile immaginare che i principi <strong>di</strong> una <strong>di</strong>sciplina e le sue metodologie possano essere<br />
insegnate allo stesso modo in cui si insegnano le regole della sintassi <strong>di</strong> un linguaggio o i<br />
coman<strong>di</strong> per l’amministrazione dei sistemi informatici, ovvero nozioni <strong>di</strong> minore rilevanza<br />
dal punto <strong>di</strong> vista concettuale e metodologico e prevalentemente <strong>di</strong> carattere mnemonico.<br />
Fino a qualche anno fa per gli insegnanti <strong>di</strong> informatica non era previsto alcun percorso <strong>di</strong><br />
preparazione specifico; conseguita la laurea gli insegnanti affrontavano senza filtri l’esperienza <strong>di</strong><br />
insegnamento, contando su sé stessi, sulle proprie capacità, e sulla propria volontà e applicando<br />
l’unico modo <strong>di</strong> insegnare conosciuto, ovvero quello che avevano vissuto dalla parte <strong>di</strong> studenti<br />
durante il periodo pre-universitario.<br />
Questo modo <strong>di</strong> concepire l’insegnamento è proprio della <strong>di</strong>dattica della informatica <strong>di</strong> tipo<br />
tra<strong>di</strong>zionale in cui “lo sforzo del <strong>di</strong>datta è tutto teso a trasformare un <strong>di</strong>scorso specialistico (e<br />
dunque complesso in quanto si fa uso <strong>di</strong> un linguaggio tecnico non naturale) in uno più<br />
comprensibile e più consono alla natura dell’allievo”. La <strong>di</strong>dattica tra<strong>di</strong>zionale tende a dare per<br />
scontato che un allievo, una volta appreso un concetto in un determinato ambiente, o per mezzo <strong>di</strong><br />
un dato strumento, sarà in grado <strong>di</strong> trasferire la conoscenza acquisita in situazioni simili ma in<br />
ambienti <strong>di</strong>versi in maniera del tutto spontanea: questo non sempre accade, anzi sovente le capacità<br />
cognitive e procedurali restano ancorate all’ambito in cui sono state imparate. Il problema<br />
principale <strong>di</strong> questo tipo <strong>di</strong> <strong>di</strong>dattica, intesa come <strong>di</strong>vulgazione <strong>di</strong> idee è proprio questo: operando<br />
esclusivamente sull’insegnamento non possiamo essere certi che avvenga (effettivamente e<br />
completamente) il cosiddetto “transfer cognitivo”.<br />
L’attenzione deve quin<strong>di</strong> spostarsi dal processo <strong>di</strong> insegnamento a quello <strong>di</strong> appren<strong>di</strong>mento,<br />
effettuando prove empiriche, con opportuni e ben stu<strong>di</strong>ati <strong>di</strong>spositivi sperimentali, sui risultati<br />
cognitivi ottenuti, passando così alla ricerca considerata sperimentale, entrando nel campo<br />
dell’epistemologia dell’appren<strong>di</strong>mento. In tale ottica è l’appren<strong>di</strong>mento il fine ultimo della<br />
<strong>di</strong>dattica, la meta sulla quale si concentrano e si riassumono gli sforzi, le riflessioni, le ricerche.<br />
Per quel che concerne la <strong>di</strong>dattica dell’informatica, esistono in ogni modo riflessioni comuni alle<br />
varie correnti <strong>di</strong> pensiero che la pervadono, a cui corrispondono inevitabilmente le parole chiave<br />
della <strong>di</strong>sciplina: trasposizione, contratto, ostacolo, immagine, modello.<br />
Innanzi tutto è necessaria una breve riflessione sul rapporto tra insegnamento ed appren<strong>di</strong>mento. In<br />
questi due processi sono coinvolti insegnante, allievo e l’oggetto dell’insegnamento, come<br />
schematizzato dal celebre triangolo della <strong>di</strong>dattica <strong>di</strong> Chevallard. Occorre porre particolare<br />
attenzione al termine “sapere” che si trova ben al <strong>di</strong> fuori del rapporto <strong>di</strong>retto insegnante-allievo. Un<br />
sapere dunque esterno al fenomeno <strong>di</strong> insegnamento appren<strong>di</strong>mento e perciò (se inteso come sapere<br />
accademico, il cosiddetto savoir savant, quello formale, quello dei programmi ministeriali) un<br />
9
sapere momentaneamente inutilizzabile per una <strong>di</strong>dattica efficace. Ovviamente si deve tentare <strong>di</strong><br />
portare questo sapere all’interno della <strong>di</strong>dattica, si tratta quin<strong>di</strong> <strong>di</strong> agire sul sapere accademico per<br />
trasformarlo in sapere da insegnare, facendo passare l’insegnamento dal vertice del triangolo in cui<br />
è in<strong>di</strong>viduato il sapere e contemporaneamente richiedere un analogo adattamento agli allievi, cosa<br />
tutt’altro che facile da ottenere. Per tentare <strong>di</strong> ottenere questo si deve agire sulle caratteristiche del<br />
nostro insegnamento e, soprattutto, sul sapere stesso: non è pensabile che un allievo possa<br />
apprendere contenuti informatici <strong>di</strong>rettamente espressi in forma accademica, senza che essi siano<br />
adeguatamente plasmati, resi accessibili.<br />
La trasposizione <strong>di</strong>dattica è proprio questa in<strong>di</strong>spensabile operazione <strong>di</strong> preventivo adattamento del<br />
sapere alle caratteristiche del <strong>di</strong>alogo educativo che avviene tra l’insegnante e l’allievo.<br />
Ovviamente l’insegnante deve anche tener conto del sistema <strong>di</strong>dattico e dell’ambiente sociale e<br />
culturale in cui si trova ad agire. L’ambiente in cui è “immerso” il triangolo della <strong>di</strong>dattica è<br />
chiamato noosfera, che può essere definita come il luogo dei <strong>di</strong>battiti <strong>di</strong> idee significative<br />
sull’insegnamento, le finalità della scuola, gli scopi della formazione, le attese della società, i<br />
programmi ministeriali; la noosfera è l’interme<strong>di</strong>ario tra il sistema scolastico e l’ambiente sociale<br />
più esteso ed esterno alla scuola. Il complesso <strong>di</strong> interazioni e <strong>di</strong> comportamenti che si instaura tra<br />
allievo ed insegnante, che deve avere quale prodotto finale l’appren<strong>di</strong>mento, è formato da una serie<br />
<strong>di</strong> fasi e <strong>di</strong> momenti che caratterizzano l’attività d’aula quoti<strong>di</strong>ana.<br />
Il rapporto allievo-insegnante è basato su regole non scritte, su convenzioni sottintese, accettate<br />
implicitamente tanto dal <strong>di</strong>scente quanto dal docente. Queste regole, seppure mai <strong>di</strong>chiarate, sono<br />
ben conosciute da entrambe le parti in causa, come se costituissero una sorta <strong>di</strong> contratto mai<br />
firmato la cui vali<strong>di</strong>tà è però in<strong>di</strong>scutibilmente nota e chiara a tutti: questo “contratto <strong>di</strong>dattico”<br />
influenza in termini decisivi il processo <strong>di</strong> insegnamento-appren<strong>di</strong>mento. Esistono vari approcci ed<br />
accezioni del contratto <strong>di</strong>dattico ma la definizione <strong>di</strong> riferimento rimane quella <strong>di</strong> Brousseau che lo<br />
definisce come “l’insieme dei comportamenti dell’insegnante che sono attesi dall’allievo e<br />
l’insieme dei comportamenti dell’allievo che sono attesi dall’insegnante”.<br />
10
2.5. Scelta degli strumenti e delle metodologie<br />
Alla luce <strong>di</strong> quanto detto finora, si sono utilizzati per tutta la durata dell’intervento <strong>di</strong>dattico<br />
strumenti che permettano <strong>di</strong> essere coerenti con il modello <strong>di</strong> riferimento. Ovviamente, nella scelta<br />
degli strumenti, non si può fare a meno <strong>di</strong> tenere in considerazione, oltre alle caratteristiche della<br />
<strong>di</strong>sciplina, anche la tipologia <strong>di</strong> allievi con cui ci si rapporta.<br />
Strumenti e metodologie<br />
Continua <strong>di</strong>scussione in classe<br />
Proiezione <strong>di</strong> presentazioni<br />
(videoproiettore)<br />
Attività pratiche <strong>di</strong> gruppo<br />
Mappe riassuntive<br />
Motivazioni<br />
La continua interazione con i ragazzi permette <strong>di</strong> guidarli nella<br />
costruzione <strong>di</strong> nuovi concetti richiamando quelli già emersi ed è utile<br />
inoltre per mantenere viva l’attenzione<br />
La proiezione <strong>di</strong> presentazioni appositamente preparate per ogni lezione<br />
permette <strong>di</strong> fare continuo uso del linguaggio visivo, in<strong>di</strong>spensabile per<br />
spiegare con più semplicità i fenomeni <strong>di</strong> cui si parla, convinti che il<br />
linguaggio visivo sia <strong>di</strong> fondamentale importanza nello stu<strong>di</strong>o delle<br />
scienze e che questo sia particolarmente vero per ragazzi per cui<br />
l’esclusivo uso del linguaggio scientifico corretto potrebbe risultare<br />
<strong>di</strong>fficoltoso. L’utilizzo dei luci<strong>di</strong> risulta poi utile anche per guidare i<br />
ragazzi nel prendere appunti: si ritiene infatti, che uno dei compiti<br />
dell’insegnante sia quello <strong>di</strong> aiutare gli allievi nello sviluppo <strong>di</strong> capacità<br />
<strong>di</strong> sintesi.<br />
Le attività pratiche permettono ai ragazzi <strong>di</strong> riprodurre i fenomeni <strong>di</strong> cui<br />
si è parlato a lezione e quin<strong>di</strong> <strong>di</strong> comprenderli meglio. Inoltre il<br />
confronto con i compagni durante lo svolgimento del <strong>lavoro</strong> è fonte<br />
continua <strong>di</strong> stimoli.<br />
L’utilizzo <strong>di</strong> mappe riassuntive al termine <strong>di</strong> un percorso <strong>di</strong>dattico può<br />
facilitare lo stu<strong>di</strong>o in<strong>di</strong>viduale degli allievi, perché permettono <strong>di</strong><br />
riepilogare i principali concetti emersi durante le lezioni.<br />
11
3. Il progetto<br />
3.1. Il contesto dell’intervento <strong>di</strong>dattico<br />
Il contesto dell’intervento <strong>di</strong>dattico è quello dei moduli <strong>di</strong> tirocinio attivo svolti all’ITIS “A.<br />
Avogadro 7 ” <strong>di</strong> <strong>Torino</strong>, che nell’anno successivo alla ricorrenza del bicentenario della sua<br />
fondazione, è considerato per serietà degli stu<strong>di</strong> un piccolo Politecnico.<br />
La riconosciuta considerazione <strong>di</strong> cui gode l’istituto nasce dal continuo aggiornamento tecnologico<br />
e <strong>di</strong>dattico sia sul piano dei contenuti formativi, che sul piano delle strutture ambientali e delle<br />
attrezzature tecnico scientifiche. Lo stile educativo e le iniziative che tendono a rendere comunitaria<br />
e con<strong>di</strong>visa la presenza e permanenza nell'Istituto, sono in assonanza con un coinvolgente rapporto<br />
con l’ambiente studentesco, perché solo una scuola che va oltre la scuola <strong>di</strong>venta una vera scuola,<br />
nella sua missione civile e nella sua valenza sociale.<br />
Gli in<strong>di</strong>rizzi <strong>di</strong> stu<strong>di</strong>o attivi per la sezione <strong>di</strong>urna sono Elettrotecnica ed Automazione, Informatica,<br />
Meccanica, Liceo Scientifico Tecnologico mentre per la sezione serale (Progetto Sirio) sono<br />
Elettrotecnica ed Automazione, Informatica, Meccanica; per l’in<strong>di</strong>rizzo informatico si adotta la<br />
programmazione “Abacus 8 ”.<br />
L’intervento <strong>di</strong>dattico si è svolto nella classe V A dell’in<strong>di</strong>rizzo informatico, composta da ventidue<br />
alunni, il contesto è stimolante; nella fase osservativa si è potuto notare come la classe sia abituata a<br />
<strong>di</strong>scutere, il docente accogliente, infatti, incentiva al confronto, stimola al ragionamento, e lascia<br />
spazio a interventi e domande e nel corso dell’attuazione del progetto si è continuato a dare<br />
rilevanza a questi aspetti e la risposta ottenuta dagli allievi è stata confortante.<br />
La <strong>di</strong>sciplina <strong>di</strong> insegnamento è stata Sistemi <strong>di</strong> elaborazione e trasmissione delle informazioni. Il<br />
corso <strong>di</strong> Sistemi, <strong>di</strong>sciplina ponte fra l’Informatica e l’Elettronica, si occupa dello stu<strong>di</strong>o delle<br />
architetture dei computer, delle situazioni che si possono rappresentare e utilizzare attraverso la<br />
programmazione in linguaggi <strong>di</strong> programmazione dal basso livello (Assembler e C) all’alto livello<br />
(Java, C++), nonché della progettazione e gestione delle reti locali e geografiche, attraverso lo<br />
conoscenza dei protocolli <strong>di</strong> comunicazione e dello sviluppo <strong>di</strong> applicazioni internet.<br />
3.2. Scelta dei contenuti in relazione alla <strong>di</strong>sciplina e alle sue caratteristiche<br />
Il corso <strong>di</strong> informatica ha come fine principale quello <strong>di</strong> mettere il perito informatico in grado <strong>di</strong><br />
affrontare (dall’analisi fino alla documentazione) la soluzione <strong>di</strong> un problema, posto dalla richiesta<br />
<strong>di</strong> un ipotetico committente, scegliendo le metodologie e gli strumenti software più idonei, ed<br />
inoltre fornirgli la formazione <strong>di</strong> base che gli consenta <strong>di</strong> seguire con una certa autonomia<br />
l’evoluzione delle tecnologie informatiche. La <strong>di</strong>sciplina fornisce all’alunno le conoscenze e le<br />
abilità necessarie per l’uso <strong>di</strong> un sistema <strong>di</strong> elaborazione ai più alti livelli della gerarchia che lo<br />
modella (linguaggi ad alto o altissimo livello, linguaggi applicativi). Essa deve essere intesa<br />
soprattutto come l’ambiente in cui si sviluppano le capacità <strong>di</strong> analizzare e risolvere problemi<br />
(anche <strong>di</strong> una certa complessità) <strong>di</strong> varia natura, e dove <strong>di</strong> volta in volta vengono proposti i<br />
para<strong>di</strong>gmi e gli strumenti linguistici più idonei alla natura del problema.<br />
Si ricorre ripetutamente al concetto <strong>di</strong> para<strong>di</strong>gma che, in questo contesto, si intende come chiave <strong>di</strong><br />
interpretazione dei problemi e come modello <strong>di</strong> costruzione delle soluzioni (imperativo, logico,<br />
funzionale, rivolto agli oggetti, agli eventi, alle basi <strong>di</strong> dati). Lo studente, allo scopo <strong>di</strong> raggiungere<br />
una certa flessibilità e la capacità <strong>di</strong> affrontare nuove prospettive, deve acquisire alcune <strong>di</strong> queste<br />
chiavi e la capacità <strong>di</strong> impiegarle nei contesti appropriati. Si cerca quin<strong>di</strong> <strong>di</strong> privilegiare gli aspetti<br />
concettuali ed applicativi della materia riducendo al minimo quelli nozionistico sintattici.<br />
7 Ve<strong>di</strong> POF Avogadro pp. 1-4<br />
8 Il Progetto ABACUS è un corso sperimentale che il Ministero della P.I. ha varato nell'anno 92/93 per adeguare le<br />
competenze richieste al Perito informatico alle "innovazioni" avvenute nel settore negli ultimi anni.<br />
12
Il fascino nello stu<strong>di</strong>o dell’Informatica è rappresentato dalla possibilità <strong>di</strong> comprendere le<br />
complessità tecnologica <strong>di</strong> un mondo che <strong>di</strong>venta sempre più <strong>di</strong>gitale e passibile <strong>di</strong> elaborazione e<br />
dall’attualità con cui i nuovi mezzi <strong>di</strong> comunicazioni cambiano i mo<strong>di</strong> abituali <strong>di</strong> vita.<br />
A <strong>di</strong>spetto <strong>di</strong> ciò, uno dei rischi che si corrono più frequentemente nell’insegnamento delle materie<br />
scientifiche è quello <strong>di</strong> lasciarsi trascinare dalle necessità <strong>di</strong>dattiche e sud<strong>di</strong>videre le <strong>di</strong>scipline in<br />
“capitoli <strong>di</strong> libro” trascurando le importanti relazioni tra fenomeni stu<strong>di</strong>ati.<br />
L’argomento scelto per l’intervento <strong>di</strong>dattico riguarda la programmazione orientata agli oggetti e il<br />
linguaggio Java, rappresenta un argomenti <strong>di</strong> notevole interesse per illustrare come i linguaggi <strong>di</strong><br />
programmazione intervengono nella realizzazione <strong>di</strong> applicazioni. Con questo tema si toccano<br />
importanti concetti portanti delle <strong>di</strong>scipline informatiche:<br />
L’esigenza <strong>di</strong> modellazione della realtà per trattare un problema<br />
Il ciclo <strong>di</strong> vita del software<br />
Il para<strong>di</strong>gma <strong>di</strong> programmazione orientata agli oggetti<br />
La capacità <strong>di</strong> razionalizzare e <strong>di</strong> tradurre i concetti astratti in implementazioni fisiche<br />
In relazione a ciò, uno degli obiettivi più importanti dell’intervento in esame è stato quello <strong>di</strong><br />
favorire negli allievi la consapevolezza che prima <strong>di</strong> implementare meccanicamente legandosi vi è<br />
un'attività <strong>di</strong> modellazione che coinvolge le tre fasi (concettuale, logica, fisica), allo stesso modo in<br />
cui esulando dalla tecnologia corrente dei linguaggi <strong>di</strong> programmazione ad oggetti è importante<br />
carpire le <strong>di</strong>namiche e i ragionamenti per l’in<strong>di</strong>viduazione <strong>di</strong> un <strong>di</strong>agramma astratto <strong>di</strong> classi che<br />
sod<strong>di</strong>sfano le specifiche. Per poter tenere considerazione questi aspetti e affinché l’intervento<br />
<strong>di</strong>dattico puntasse in tale <strong>di</strong>rezione, in accordo con il docente accogliente, ho tracciato il percorso<br />
per l’introduzione alla programmazione ad oggetti che potesse confluire ed essere raccordato in<br />
un’applicazione dando un taglio squisitamente pratico e realizzativo, anche per dare una visione<br />
completa agli allievi dalla progettazione alla realizzazione fisica con l’apporto <strong>di</strong> mo<strong>di</strong>fiche o <strong>di</strong><br />
revisioni in initere, finalizzate al continuo miglioramento seguendo i canoni del ciclo <strong>di</strong> vita del<br />
software.<br />
Nella scelta <strong>di</strong> questi contenuti ho cercato <strong>di</strong> dosare il livello <strong>di</strong> <strong>di</strong>fficoltà in maniera opportuna a<br />
seconda dei casi, e contemporaneamente, motivare gli studenti rendendo interessante la materia,<br />
adeguandola ai tempi, proponendo ed evidenziando situazioni problematiche <strong>di</strong>rettamente connesse<br />
alla vita reale.<br />
Il linguaggio <strong>di</strong> programmazione Java si presta in maniera eccellente a tali scopi e rappresenta uno<br />
stimolo decisamente intenso per gli allievi per una serie <strong>di</strong> motivi tra cui:<br />
• può essere insegnato a <strong>di</strong>versi livelli <strong>di</strong> approfon<strong>di</strong>mento<br />
• oltre ad essere un linguaggio è una tecnologia con<strong>di</strong>visa dalla comunità scientifica<br />
• è estremamente <strong>di</strong>ffuso e utilizzato in ambiti lavorativi<br />
• la sua conoscenza è <strong>di</strong>rettamente spen<strong>di</strong>bile nell’imme<strong>di</strong>ato<br />
3.3. Descrizione sintetica del progetto<br />
La progettazione dell’intervento <strong>di</strong>dattico è finalizzata ad introdurre i concetti <strong>di</strong> base della<br />
programmazione orientata agli oggetti, illustrando come un linguaggio evoluto come Java<br />
implementa il para<strong>di</strong>gma orientato agli oggetti.<br />
Nella preparazione del progetto, avvenuta ovviamente dopo le ore <strong>di</strong> osservazione della classe, la<br />
preoccupazione principale è stata quella <strong>di</strong> organizzare il <strong>lavoro</strong> in modo da renderlo il più possibile<br />
adatto e ‘accattivante’ per i ragazzi. Ho deciso, consigliandomi anche col docente accogliente <strong>di</strong><br />
ridurre all’osso le lezioni frontali nel senso più tra<strong>di</strong>zionale del termine, a favore <strong>di</strong> lezioni più<br />
interattive e partecipate.<br />
13
3.3.1. Programmazione <strong>di</strong>dattica<br />
Le tappe proposte a livello <strong>di</strong> progettazione e poi effettivamente seguite in tutta l’organizzazione e<br />
lo svolgimento del <strong>lavoro</strong> rientrano in un percorso <strong>di</strong> lungo periodo, ho tenuto conto <strong>di</strong> quali fossero<br />
gli obiettivi da raggiungere nel breve periodo sud<strong>di</strong>videndoli in obiettivi cognitivi e obiettivi<br />
trasversali (da conseguire prevalentemente tramite attività <strong>di</strong> gruppo) come si evince dallo schema<br />
riportato <strong>di</strong> seguito.<br />
1. Descrizione degli obiettivi che si vogliono conseguire<br />
A breve termine A me<strong>di</strong>o termine A lungo termine<br />
Capacità <strong>di</strong> rielaborare i Progettazione e realizzazione<br />
contenuti trasmessi <strong>di</strong> architetture <strong>di</strong> classi per il<br />
dall’insegnante<br />
problema da risolvere<br />
Comprendere i concetti <strong>di</strong> classe,<br />
oggetto, ere<strong>di</strong>tarietà, polimorfismo,<br />
overri<strong>di</strong>ng e overloa<strong>di</strong>ng, interfaccia<br />
Comprendere il para<strong>di</strong>gma orientato<br />
agli oggetti<br />
Acquisire la sintassi e semantica delle<br />
strutture primitive del linguaggio Java<br />
Implementare le classi e usare gli<br />
oggetti in Java<br />
Capacità <strong>di</strong> allestire installare e<br />
configurare l’ambiente <strong>di</strong> sviluppo<br />
Realizzare i <strong>di</strong>agrammi delle classi per<br />
un dato problema<br />
Saper implementare e documentare la<br />
realizzazione <strong>di</strong> applicativi Java che<br />
usano le classi<br />
Capacità <strong>di</strong> analisi e<br />
valutazione delle<br />
problematiche nel<br />
progetto <strong>di</strong> applicazioni<br />
Capacità <strong>di</strong> modellare con<br />
le classi gli spaccati del<br />
mondo reale<br />
Capacità <strong>di</strong> esposizione<br />
Acquisizione <strong>di</strong> un<br />
linguaggio appropriato<br />
Stimolare interesse<br />
Acquisizione del metodo <strong>di</strong><br />
stu<strong>di</strong>o che rifletta il metodo<br />
scientifico<br />
Autonomia e senso <strong>di</strong><br />
responsabilità<br />
Acquisizione <strong>di</strong> un linguaggio<br />
appropriato<br />
Capacità <strong>di</strong> confrontare le<br />
proprie opinioni con quelle<br />
degli altri<br />
Capacità <strong>di</strong> collaborare con i<br />
compagni<br />
Capacità <strong>di</strong> collaborare con<br />
l’insegnante<br />
2. Descrizione dei prerequisiti che gli allievi devono possedere<br />
• Dimestichezza nell’utilizzo dei semplici operatori (aritmetici, logici, relazionali),<br />
comprendendone la priorità nel loro utilizzo associativo<br />
• Concetti base <strong>di</strong> programmazione (variabile, costante) e dei tipi <strong>di</strong> dato<br />
• Conoscenza delle strutture logiche <strong>di</strong> controllo (con<strong>di</strong>zionali e iterative) utilizzate nella<br />
programmazione procedurale<br />
3. Pre<strong>di</strong>sposizione <strong>di</strong> materiale da adottare<br />
Per la preparazione dei luci<strong>di</strong> da proiettare durante la lezione ho scelto e organizzato i contenuti<br />
attentamente affinché ogni concetto nuovo introdotto fosse accompagnato da illustrazioni e<br />
esempi tratti dal mondo reale, con un linguaggio minimale semplice e <strong>di</strong>retto.<br />
Ho fornito delle <strong>di</strong>spense come sussi<strong>di</strong>o <strong>di</strong>dattico ad integrazione del libro <strong>di</strong> testo utilizzato.<br />
4. Pre<strong>di</strong>sposizione <strong>di</strong> un’attività <strong>di</strong> gruppo volta a collaudare e a rinforzare l’appren<strong>di</strong>mento<br />
teorico favorendo lo scambio <strong>di</strong> informazioni e il <strong>di</strong>alogo tra studenti<br />
L’attività è stata pensata per aiutare i ragazzi a far propri i concetti presentati, stimolandoli a<br />
sviluppare o potenziare l’appren<strong>di</strong>mento tra pari e le capacità espositive. Il <strong>lavoro</strong> condotto in<br />
gruppi <strong>di</strong> due o tre persone consiste nel creare su un cartellone il <strong>di</strong>agrammi delle classi<br />
14
stabilendone le gerarchie e le <strong>di</strong>pendenze, e riconoscendo i meto<strong>di</strong> e le proprietà partendo da un<br />
problema <strong>di</strong> modellazione preso dalla realtà. In seguito si è cercato <strong>di</strong> promuovere una<br />
<strong>di</strong>scussione in cui gli allievi potessero riflettere e scambiare opinioni circa il <strong>di</strong>agramma<br />
realizzato valutando quale soluzione fosse la migliore, e quin<strong>di</strong> procedere all’implementazione<br />
su calcolatore. Si è cercato <strong>di</strong> responsabilizzare il gruppo affidando delle consegne ben<br />
delimitate e delle regole circa la produzione <strong>di</strong> documentazione relativa alla realizzazione del<br />
progetto, l’organizzazione delle classi e dei sorgenti e il formalismo UML da utilizzare.<br />
5. Allestimento <strong>di</strong> una prova <strong>di</strong> verifica sommativa per verificare il raggiungimento degli<br />
obiettivi prefissati<br />
La verifica deve essere costituita da un fatto problematico che deve essere realizzato e<br />
implementato su elaboratore in linguaggio Java in modo da permettere la valutazione del<br />
raggiungimento degli obiettivi in<strong>di</strong>cati (con particolare attenzione agli obiettivi a breve-me<strong>di</strong>o<br />
termine). Alcuni quesiti sono mirati a valutare la conoscenza, altri le competenze acquisite e le<br />
capacità <strong>di</strong> applicazione dei concetti costruiti durante il percorso. Per la modalità <strong>di</strong> correzione<br />
della verifica si attribuisce un punteggio a ciascun quesito in funzione della <strong>di</strong>fficoltà; il<br />
punteggio attribuito ai quesiti che valutano l’applicazione dei concetti deve essere superiore a<br />
quello degli items che valutano la semplice conoscenza dei contenuti.<br />
6. Prospetto dell’intervento <strong>di</strong>dattico<br />
Attività<br />
Osservazione della classe<br />
Lezione introduttiva<br />
• Illustrazione obiettivi<br />
• Analisi dei pre-requisiti<br />
• Introduzione al linguaggio Java<br />
La programmazione orientata agli oggetti<br />
• Introduzione alla programmazione orientata agli oggetti<br />
• Il concetto <strong>di</strong> classe e oggetto<br />
• Attività in laboratorio (Installazione e configurazione<br />
dell’ambiente <strong>di</strong> sviluppo integrato)<br />
La programmazione orientata agli oggetti<br />
• L’incapsulamento e interazioni tra oggetti<br />
• Ere<strong>di</strong>tarietà (Classi e Sottoclassi)<br />
• Attività in laboratorio (Implementazione <strong>di</strong> una classe)<br />
La programmazione orientata agli oggetti<br />
• Ridefinizione dei meto<strong>di</strong> e polimorfismo<br />
• L’ ere<strong>di</strong>tarietà multipla (Interfacce)<br />
• Attività in laboratorio (Realizzazione <strong>di</strong> un <strong>di</strong>agramma <strong>di</strong><br />
classi)<br />
Il linguaggio Java<br />
• Caratteristiche lessicali, tipi, strutture <strong>di</strong> controllo<br />
• Classi, ere<strong>di</strong>tarietà, interfacce, packages, gestione delle<br />
eccezioni<br />
• Attività in laboratorio (Implementazione <strong>di</strong> un <strong>di</strong>agramma <strong>di</strong><br />
classi)<br />
Verifica in classe<br />
Tempo previsto<br />
2 h<br />
3h<br />
20 min<br />
40 min<br />
2 h<br />
3 h<br />
40 min<br />
2 h<br />
20 min<br />
3 h<br />
1 h<br />
1 h<br />
1 h<br />
3 h<br />
1 h<br />
1 h<br />
1 h<br />
3 h<br />
1 h<br />
1 h<br />
1 h<br />
3 h<br />
15
4. Analisi del processo<br />
L’intervento <strong>di</strong>dattico si è svolto in quin<strong>di</strong>ci ore <strong>di</strong> lezione, <strong>di</strong> cui un quarto in laboratorio, più la<br />
prova <strong>di</strong> verifica sommativa. I cambiamenti apportati al progetto iniziale sono stati <strong>di</strong> piccola entità,<br />
<strong>di</strong> seguito si riportano schematicamente i tratti salienti che sono emersi nelle <strong>di</strong>verse lezioni, per i<br />
contenuti delle trasparenze utilizzate nell’intervento <strong>di</strong>dattico e per il materiale <strong>di</strong>dattico fornito agli<br />
allievi come compen<strong>di</strong>o <strong>di</strong>dattico integrativo si rimanda rispettivamente agli allegati B e C<br />
4.1. Lo svolgimento dell’intervento <strong>di</strong>dattico<br />
Il giorno iniziale dell’intervento <strong>di</strong>dattico, ho de<strong>di</strong>cato un’ora ad una lezione introduttiva durante la<br />
quale sono stati presentati oralmente agli allievi gli argomenti che avremmo trattato e gli obiettivi<br />
da raggiungere nel percorso; mi sono ritagliato altresì pochi minuti per contestualizzare la<br />
programmazione orientata agli oggetti e la genesi del linguaggio Java recuperandone<br />
l’epistemologia.<br />
Nel proce<strong>di</strong>mento <strong>di</strong> accertamento dei prerequisiti mi sono sincerato che gli allievi possedessero:<br />
• la conoscenza delle nozioni elementari dell’architettura del calcolatore (architettura del<br />
computer, tipologie <strong>di</strong> memorie, registri)<br />
• la familiarità dei tipi nativi e fondamentali messi a <strong>di</strong>sposizione dal linguaggio<br />
• la conoscenza <strong>di</strong> base della struttura minima <strong>di</strong> un programma scritto in Java, e saperlo scrivere<br />
su un foglio <strong>di</strong> testo o nell’ambiente <strong>di</strong> programmazione<br />
• il concetto <strong>di</strong> variabile e costante, come <strong>di</strong>chiararle e definirle<br />
• la <strong>di</strong>mestichezza nell’utilizzo dei semplici operatori (aritmetici, logici, relazionali),<br />
comprendendone la priorità nel loro utilizzo associativo<br />
• conoscenza dell’ambiente <strong>di</strong> sviluppo integrato (IDE) 9<br />
Tutte le lezioni sono state condotte in modo partecipato, sono stati invitati gli allievo sin dall’inizio<br />
ad esprimersi liberamente interrompendo (chiedendo la parola per alzata <strong>di</strong> mano) ogni qual volta<br />
avessero avuto dubbi o <strong>di</strong>fficoltà. Questo aspetto è stato particolarmente interessante per<br />
l’instaurazione <strong>di</strong> un buon clima <strong>di</strong> cooperazione tra insegnante e allievi basata sulla franchezza e<br />
sulla reciproca stima e considerazione.<br />
Dopo questa introduzione, sono state poste loro alcune domande in modo da suscitare una<br />
<strong>di</strong>scussione che permettesse <strong>di</strong> valutare i prerequisiti. Il tutto è stato svolto in modo assolutamente<br />
informale, per evitare che i ragazzi pensassero <strong>di</strong> essere sottoposti a valutazione; lo scopo era quello<br />
<strong>di</strong> capire come portare avanti il <strong>lavoro</strong> in modo da creare un collegamento con le loro conoscenze<br />
pregresse, facilitandone l’appren<strong>di</strong>mento.<br />
Con l’ausilio delle trasparenze, ho ripercorso le strutture <strong>di</strong> controllo e i <strong>di</strong>agrammi <strong>di</strong> flusso che le<br />
governano, tale operazione <strong>di</strong> recupero dei prerequisiti è stata condotta in maniera agevole e senza<br />
sostanziali intoppi, grazie anche al fatto che gli allievi avevano stu<strong>di</strong>ato l’anno precedente come<br />
linguaggio <strong>di</strong> programmazione imperativo il linguaggio C la cui sintassi e semantica è analoga al<br />
linguaggio Java.<br />
Nella seconda lezione, tramite l’ausilio <strong>di</strong> trasparenze videoproiettate, si sono introdotte le<br />
caratteristiche del linguaggio orientato agli oggetti, dopo aver illustrato la necessità dell’industria<br />
del software <strong>di</strong> avere componenti riusabili (“senza dover ogni volta reinventare la ruota”), si è giunti<br />
ad affrontare il concetto <strong>di</strong> classe e oggetto la cui assimilazione rappresentava l’obiettivo finale.<br />
Grazie ad esempi tratti dalla vita reale, vedendo la classe come l’idea o la forma e presentando<br />
l’oggetto come la realizzazione dell’idea e il prendere forma si è potuto arrivare alla conclusione<br />
che un oggetto è una istanza (“esemplare”) <strong>di</strong> una classe, che viene creato (“instanziato”)<br />
<strong>di</strong>namicamente.<br />
9 In laboratorio per l’implementazione dei programmi sull’elaboratore si è utilizzato l’ambiente <strong>di</strong> sviluppo JBuilder X<br />
della Borland.<br />
16
Le attività in laboratorio hanno riguardato problematiche squisitamente tecniche (installazione e<br />
configurazione dell’ambiente <strong>di</strong> sviluppo e implementazione del co<strong>di</strong>ce realizzato per provarlo e<br />
collaudarlo), ma anche momenti <strong>di</strong> cooperazione in <strong>lavoro</strong> <strong>di</strong> gruppo.<br />
Quello che si voleva far emergere da queste attività è che la progettazione e realizzazione del<br />
software parte dal problema <strong>di</strong> modellazione della realtà mantenendo un errore <strong>di</strong> modello<br />
contenuto in limiti che risultino accettabili per l’utenza.<br />
Dallo scambio <strong>di</strong> opinioni effettuato con qualche studente al <strong>di</strong> fuori dell’orario scolastico è emerso<br />
che questa fase <strong>di</strong> tirocinio è stata percepita da più <strong>di</strong> un allievo come qualcosa <strong>di</strong> parimenti<br />
importante, essendo composta da lezioni poco faticose, <strong>di</strong>vertenti e in sostanza “utili all’<br />
informatica”. Questo giu<strong>di</strong>zio è ovviamente dettato dal modo in cui la <strong>di</strong>sciplina è percepita: gli<br />
studenti <strong>di</strong> questa classe, come notato anche nel periodo <strong>di</strong> osservazione, sono fortemente<br />
con<strong>di</strong>zionati dal contratto <strong>di</strong>dattico per cui la lezione <strong>di</strong> informatica è poco standar<strong>di</strong>zzata e non<br />
consiste nell’introduzione <strong>di</strong> un nuovo argomento, che permette <strong>di</strong> risolvere una serie <strong>di</strong> esercizi<br />
sempre più complicati col passare delle lezioni, fino al compito in classe che sancisce la chiusura <strong>di</strong><br />
un ciclo ed il seguente passaggio a nuovo argomento.<br />
4.1.1. Didattica e software libero<br />
Il software utilizzato nell'insegnamento delle (o con le) nuove tecnologie corrisponda ad un "libro <strong>di</strong><br />
testo". Nel settore se ne sono affermati due: quello che si rifà alla cultura del confronto,<br />
rappresentato dai valori del software libero, e quello che possiamo ricollegare alla cultura del<br />
"monopolio privato", rappresentato dal software proprietario monopolistico che, per sua natura non<br />
ama il confronto e, appena può, lo soffoca al fine <strong>di</strong> impe<strong>di</strong>re all'utente (consumatore) qualsiasi<br />
scelta. Il software libero, come "libro <strong>di</strong> testo", ha molteplici ragioni per essere adottato nella<br />
<strong>di</strong>dattica perché principalmente: non <strong>di</strong>scrimina i soggetti su base economica ma seleziona su base<br />
meritocratica; la gratuità delle licenze d'uso tra l'altro è conforme ai criteri stabiliti dalle varie<br />
circolari sull'adozione dei libri <strong>di</strong> testo che si preoccupano <strong>di</strong> stabilire un tetto <strong>di</strong> spesa, a seconda<br />
del tipo <strong>di</strong> scuola; permette, sia all'insegnante che all'allievo, l'assoluta libertà <strong>di</strong> copia, fondamento<br />
dello scambio della conoscenza; in questo modo si educa alla legalità non dovendo, nella scuola,<br />
ricorrere alla pirateria informatica per svolgere la normale attività educativa; è rispettoso della<br />
libertà d'insegnamento, perché permette all'insegnante <strong>di</strong> scegliere la soluzione e il fornitore che più<br />
si adatta alle sue esigenze conoscitive e <strong>di</strong>dattiche; è rispettoso della libertà <strong>di</strong> parola, perché<br />
permette anche all'insegnante, e alla scuola più in generale, <strong>di</strong> "entrare in gioco" ed essere "soggetto<br />
<strong>di</strong> cultura"; educa alla consapevolezza informatica attraverso la trasparenza, la verifica e la<br />
sperimentazione; incentiva l'economia locale valorizzando le risorse umane locali. Ma la ragione<br />
avanzata dal software proprietario monopolistico che, a scuola, si debba usare il software secondo il<br />
criterio del "più <strong>di</strong>ffuso", ad oggi, ha avuto la meglio, e ha messo all'angolo i valori del software<br />
libero sottraendo ai docenti la libertà <strong>di</strong> scelta nel settore informatico.<br />
Per un insegnante usare il software libero significa avere la possibilità <strong>di</strong> scegliere il proprio libro <strong>di</strong><br />
testo ed esercitare il <strong>di</strong>ritto della libertà d'insegnamento, ma per scegliere bisogna essere informati<br />
(preparati) e consapevoli; in alcuni casi bisogna anche <strong>di</strong>ssentire da ciò che viene "calato dall'alto".<br />
Non stupisce perciò se oggi chi per la propria <strong>di</strong>dattica sceglie <strong>di</strong> lavorare con il software libero,<br />
trovandosi isolato nell' "in<strong>di</strong>fferenza generale", trasforma il proprio insegnamento in un<br />
insegnamento <strong>di</strong> libertà. Il Ministro per la Innovazione e le Tecnologie a più riprese ha in<strong>di</strong>cato<br />
nell'uso del software libero (chiamandolo "software a co<strong>di</strong>ce sorgente aperto") una valida<br />
opportunità per la P.A. e al riguardo ha suggerito ai "decisori" <strong>di</strong> estendere i "buoni esempi". Per<br />
riappropriarci della libertà <strong>di</strong> scelta nelle nuove tecnologie ed essere al servizio della collettività e<br />
non degli interessi privati <strong>di</strong> aziende monopolistiche dobbiamo puntare: sull'autonomia scolastica<br />
(delle amministrazioni periferiche); sull'esercizio della libertà d'insegnamento (dei singoli docenti).<br />
Dobbiamo fare in modo che gli insegnanti esercitino il loro <strong>di</strong>ritto della libertà <strong>di</strong> scelta nelle nuove<br />
tecnologie, togliendosi <strong>di</strong> dosso qualsiasi timore reverenziale. Al riguardo dobbiamo procedere in<br />
17
due <strong>di</strong>rezioni: dare impulso ad incontri <strong>di</strong> informazione e formazione sul software libero per creare<br />
informazione e consapevolezza e battere "l'in<strong>di</strong>fferenza generale" prodotta dalle varie<br />
alfabetizzazioni del MIUR; creare esempi <strong>di</strong> <strong>di</strong>dattica con il software libero, creare modelli da<br />
<strong>di</strong>ffondere, creare documentazione sul software libero, in maniera da agevolarne la <strong>di</strong>ffusione. Il<br />
software libero è rispettoso della libertà d'insegnamento; il software libero è rispettoso della libertà<br />
<strong>di</strong> parola, nel settore informatico; il software libero non <strong>di</strong>scrimina economicamente le persone. Ma<br />
solo quando i docenti si saranno riappropriati della libertà <strong>di</strong> scelta e della libertà d'insegnamento<br />
nelle nuove tecnologie potremmo <strong>di</strong>re <strong>di</strong> avere una formazione informatica in una scuola aperta e<br />
pluralista.<br />
4.2. Gli aspetti emotivi e relazionali<br />
L'insegnamento non consiste nella semplice trasmissione <strong>di</strong> contenuti e teorie ma ha a che fare con<br />
le relazioni che sono concomitanti all'appren<strong>di</strong>mento, quin<strong>di</strong> ne consegue che il <strong>lavoro</strong> educativo è<br />
sempre un <strong>lavoro</strong> <strong>di</strong> gestione: mentre insegna, il docente non deve occuparsi solo delle relazioni<br />
interpersonali, ma anche <strong>di</strong> relazioni <strong>di</strong> gruppo con l'intera classe, garantendo una qualità educativa<br />
che accompagni la crescita sociale e culturale dei singoli e del gruppo (<strong>di</strong>namiche sottolineate dal<br />
progetto Brocca). La gestione educativa della classe pone il problema <strong>di</strong> integrare nel <strong>lavoro</strong> del<br />
docente una responsabilità culturale <strong>di</strong> tipo intellettuale e <strong>di</strong>sciplinare e una responsabilità culturale<br />
emotiva affinché possano essere espressi entrambi i versanti dell'appren<strong>di</strong>mento: quello intellettuale<br />
e quello <strong>di</strong>namico-emotivo, sostenendo l’allievo verso assetti mentali più adeguati al compito <strong>di</strong><br />
apprendere.<br />
In classe si hanno gli in<strong>di</strong>catori che definiscono un insegnate capace: competenze tecniche e<br />
capacità verbali possono fallire nel <strong>lavoro</strong> con gli allievi. Occorrono capacità gestionali <strong>di</strong> contatto,<br />
<strong>di</strong> incoraggiamento e coinvolgimento rispetto agli allievi impegnati a crescere "nell'intimità" (anche<br />
scomoda) del gruppo dei pari.<br />
L’insegnante deve mantenere sempre reciprocamente attivo l'ascolto e l'empatia con gli allievi a<br />
senza scissione tra sentimenti e comportamenti professionali che possono essere percepiti dagli<br />
allievi come frapposizione <strong>di</strong> barriere comunicative.<br />
Gestire la responsabilità <strong>di</strong> un processo educativo è <strong>di</strong>fficile perchè si tratta <strong>di</strong> un processo <strong>di</strong><br />
cambiamento e <strong>di</strong> crescita. Assumersi una responsabilità educativa coinvolge una <strong>di</strong>mensione<br />
relazionale <strong>di</strong> ascolto e risposta alle domande e ai bisogni delle persone che ci sono affidate e una<br />
<strong>di</strong>mensione giuri<strong>di</strong>ca ed etica, dal momento che questa non può essere superficiale perchè coinvolge<br />
delle persone. La risorsa professionale più preziosa del docente è la <strong>di</strong>sponibilità emotiva e<br />
profonda a incontrare e gestire, dentro e fuori <strong>di</strong> sé, le emozioni e le ansie evolutive. Gli insegnanti<br />
che hanno <strong>di</strong>fficoltà a confrontarsi in modo autentico con la <strong>di</strong>namica emotiva della classe e con i<br />
<strong>di</strong>versi stili <strong>di</strong> appren<strong>di</strong>mento degli allievi, scindono questa <strong>di</strong>mensione gestionale. Lo spazio<br />
scolastico può essere anti-educativo e anti-evolutivo, se manca la vita <strong>di</strong> relazione.<br />
Nel corso dell’intervento <strong>di</strong>dattico gli allievi si sono <strong>di</strong>mostrati attenti alle lezioni, partecipativi e<br />
motivati, il clima delle lezioni era simile a quello che si instaura in un gruppo <strong>di</strong> <strong>lavoro</strong>; E’ stato<br />
possibile guidare la classe verso il raggiungimento <strong>di</strong> un obiettivo <strong>di</strong> appren<strong>di</strong>mento prefissato.<br />
Vi sono stati momenti in cui, a causa del basso livello della soglia <strong>di</strong> attenzione e concentrazione<br />
che scemava lentamente dopo la seconda ora, gli allievi instauravano un atteggiamento mentale<br />
antieducativo, infatti essi si <strong>di</strong>straevano facilmente e coglievano ogni occasione per cercare <strong>di</strong><br />
attirare l’attenzione in modo da perdere tempo e ridurre il carico <strong>di</strong>dattico; tale atteggiamento l’ho<br />
riscontrato anche quando ho dovuto affrontare la spiegazione <strong>di</strong> alcuni nozionismi (sintassi e<br />
semantica del linguaggio <strong>di</strong> programmazione Java) rifacendomi ad una <strong>di</strong>dattica tra<strong>di</strong>zionale.<br />
Durante le lezioni ho cercato <strong>di</strong> procedere in modo chiaro per dare la possibilità agli allievi <strong>di</strong><br />
prendere appunti correttamente, mi sono sembrati volitivi e motivati e alcuni sono intervenuti più<br />
volte per avere chiarimenti e per approfon<strong>di</strong>re gli argomenti trattati.<br />
18
Ho potuto constatare che i ragazzi tendono a <strong>di</strong>strarsi molto facilmente, in alcuni casi intervengono<br />
nel corso della lezione in maniera infelice per il solo motivo <strong>di</strong> perdere tempo. A tal proposito è<br />
necessario non lasciarsi fuorviare dai loro interventi, mostrando autorevolezza nel condurli lungo il<br />
percorso <strong>di</strong>dattico prefissato.<br />
Ho cercato <strong>di</strong> agevolare e incitare alla partecipazione i ragazzi alle lezioni, coinvolgendoli nella<br />
<strong>di</strong>scussione e guidandoli nella risoluzione dei problemi proposti.<br />
In laboratorio ho avuto minore <strong>di</strong>fficoltà a gestire la classe e nel contempo ho notato un maggiore<br />
impegno da parte dei ragazzi. In tale contesto è stato, infatti, possibile costituire dei gruppi <strong>di</strong> <strong>lavoro</strong><br />
<strong>di</strong> tre soggetti al più. In questo modo è stato possibile responsabilizzare i ragazzi assegnando al<br />
gruppo un obiettivo preciso, la loro risposta è stata confortante e si sono <strong>di</strong>mostrati entusiasti<br />
dell’esperienza. Nell’ambito del gruppo è favorita la cosiddetta peer education 10 .<br />
L’ultima ora <strong>di</strong> ogni intervento è stata destinata alle attività nel laboratorio <strong>di</strong> informatica, sia per<br />
mantenere la soglia <strong>di</strong> attenzione su livelli decisamente accettabili sia per incentivare la<br />
collaborazione e la <strong>di</strong>scussione tra gli allievi.<br />
In effetti, la lezione in laboratorio si è rivelata un momento privilegiato nel coinvolgimento degli<br />
studenti: il cambio <strong>di</strong> ambiente anche fisico, in una situazione totalmente sconosciuta, ha portato ad<br />
una percezione <strong>di</strong> una lezione inconsueta e sgravata dal peso della valutazione; si è quin<strong>di</strong> notata la<br />
maggiore <strong>di</strong>sponibilità al <strong>di</strong>alogo ed al confronto (e quin<strong>di</strong> all’implicazione personale) anche <strong>di</strong><br />
alcuni tra gli studenti solitamente più insicuri e titubanti. L’utilizzo del software ha inoltre<br />
consentito <strong>di</strong> concentrare maggiormente l’attenzione sugli aspetti qualitativi dei programmi<br />
effettuati e favorito la conversione tra registro logico e pragmatico. In questo clima estremamente<br />
positivo, <strong>di</strong>steso ed estremamente aperto al confronto, le semplici situazioni a-<strong>di</strong>dattiche presentate<br />
hanno portato a lezioni <strong>di</strong>namiche, <strong>di</strong>alogate ed estremamente costruttive.<br />
10 J.P. Pourtois, “La ricerca-azione in pedagogia”, in E. Becchi, B. Vertecchi, Manuale critico della sperimentazione e<br />
della ricerca educativa, Milano, Angeli, 1988, pp. 134-155<br />
19
4.3. Riflessioni<br />
L’esperienza <strong>di</strong>dattica è stata articolata secondo tre momenti o fasi <strong>di</strong> cui schematicamente si<br />
riportano le attività correlate.<br />
1. Fase Preattiva<br />
• Presentazione ai docenti accoglienti e ai tirocinanti del modello <strong>di</strong> tirocinio da parte del<br />
supervisore<br />
• Presentazione scuola, classe, piano <strong>di</strong> <strong>lavoro</strong> da parte dei docenti accoglienti al tirocinante<br />
• Accordo generale sull’intervento<br />
• Osservazione della classe sede <strong>di</strong> tirocinio<br />
• Progettazione dell’intervento <strong>di</strong>dattico (I.D.) e presentazione al supervisore<br />
• Confronto con i docenti accoglienti sull’I.D.<br />
• Discussione con i docenti SSIS e confronto con gli altri specializzan<strong>di</strong><br />
• Collegamento tra laboratori e tirocinio per favorire una progettazione <strong>di</strong>dattica funzionale al<br />
processo <strong>di</strong> insegnamento/appren<strong>di</strong>mento<br />
• Messa a punto dell’I.D.<br />
2. Fase Attiva<br />
• Svolgimento dell’I.D.<br />
• Confronto con i docenti accoglienti e il supervisore sull’andamento dell’I.D.<br />
• Preparazione degli strumenti <strong>di</strong> valutazione<br />
• Valutazione in itinere del processo <strong>di</strong> insegnamento/appren<strong>di</strong>mento<br />
• Raccolta del feedback<br />
3. Fase PostAttiva<br />
• Confronto finale con i docenti accoglienti<br />
• Discussione conclusiva con il supervisore<br />
• Confronto con gli altri specializzan<strong>di</strong><br />
• Riflessione e relazione conclusiva<br />
• Valutazione del processo <strong>di</strong> formazione<br />
La <strong>di</strong>dattica è un sapere complesso che non si può semplificare, ed è complessa perché ha a che fare<br />
con l'insegnante e gli allievi, che hanno una loro personalità, un loro modo <strong>di</strong> essere e <strong>di</strong> agire.<br />
Apprendere non vuol <strong>di</strong>re sola conoscenza (sapere), ma anche competenza (saper fare), inoltre<br />
l'insegnante deve suscitare il valore formativo delle <strong>di</strong>scipline (perché stu<strong>di</strong>are informatica,….), per<br />
fare questo l'insegnante deve aggiornarsi sulla propria <strong>di</strong>sciplina, deve capire come potenzia la<br />
capacità <strong>di</strong> pensiero così da poter motivare i ragazzi sulla epistemologia della materia.<br />
L’insegnante deve fare me<strong>di</strong>azione tra la ricerca e la <strong>di</strong>sciplina in classe.<br />
L’informatica come <strong>di</strong>sciplina risente ancora della profonda <strong>di</strong>cotomia tra <strong>di</strong>sciplina scientifica e<br />
sapere tecnologico, è vero sia che possiede una propria epistemologia con tutto il fermento e<br />
l’affanno della ricerca scientifica condotta con rigore scientifico, ma è anche collocabile al servizio<br />
<strong>di</strong> altre <strong>di</strong>scipline fornendo un modo <strong>di</strong> comunicazione alternativo.<br />
In virtù <strong>di</strong> tale considerazione, lo stu<strong>di</strong>o dell’informatica, se non correlato a qualcosa <strong>di</strong> tangibile, <strong>di</strong><br />
pratico risulta essere poco efficace. Per questa ragione un approccio che proponga come punto <strong>di</strong><br />
partenza un’ampia varietà <strong>di</strong> esempi, esercizi e progetti che prendono spunto da molte situazioni e<br />
che offrono agli studenti la possibilità <strong>di</strong> risolvere problemi reali costituisca decisamente un’ottima<br />
strategia per l’appren<strong>di</strong>mento dell’informatica.<br />
20
Ho cercato <strong>di</strong> proporre la sintassi e l’appren<strong>di</strong>mento <strong>di</strong> tali costrutti tramite l’appren<strong>di</strong>mento per<br />
scoperta 11 ponendo l’accento sull’itinerario <strong>di</strong> appren<strong>di</strong>mento e più precisamente sul suo carattere<br />
<strong>di</strong> processo in<strong>di</strong>pendente e sul fatto che la conquista della verità <strong>di</strong> una proposizione avviene per<br />
conquista autonoma. La scoperta va intesa in senso relativo e cioè come se si fosse i primi a farlo.<br />
Una autentica scoperta, anche in senso relativo, richiede non solo l’enunciazione <strong>di</strong> un’ipotesi<br />
atten<strong>di</strong>bile ma anche l’effettiva verifica.<br />
Il linguaggio utilizzato nelle spiegazioni non usa volutamente una terminologia accademica e<br />
complessa per rendere più accessibili i contenuti ai <strong>di</strong>scenti.<br />
Gli argomenti sono corredati da esempi e piccoli progetti, a cui segue l’implementazione al personal<br />
computer del laboratorio dopo che è stato realizzata l’analisi logica del problema, la scelta<br />
dell’algoritmo, la formalizzazione secondo la terminologia dei <strong>di</strong>agrammi <strong>di</strong> flusso e la deco<strong>di</strong>fica<br />
in linguaggio Java.<br />
Il tutto seguendo gli aspetti caratterizzanti la ricerca-azione, orientata verso l’azione sul campo,<br />
conferendo alla <strong>di</strong>dattica un sapere in azione progettuale che si confronta con la realtà.<br />
A tal fine <strong>di</strong> grande aiuto è l’utilizzo <strong>di</strong> un approccio storico che permette <strong>di</strong> raggiungere due<br />
obiettivi importanti: in primo luogo si tratta <strong>di</strong> un’impostazione che permette <strong>di</strong> proporre gli<br />
argomenti sotto forma <strong>di</strong> situazioni problematiche, portando gli studenti nelle stesse con<strong>di</strong>zioni dei<br />
ricercatori, in secondo luogo stimola negli studenti la riflessione sul ruolo delle osservazioni e sulla<br />
<strong>di</strong>namicità e non contingenza del sapere scientifico. Questo approccio è ritenuto opportuno e<br />
percorribile in tale senso, si tiene a freno così l’esuberanza e la voglia che gli studenti manifestano<br />
<strong>di</strong> poter mettersi subito a programmare perdendosi nei tecnicismi e uscendo dall’iter teorico e <strong>di</strong><br />
progettualità che devono adottare e fare proprio come para<strong>di</strong>gma.<br />
Durante tutto l’intervento <strong>di</strong>dattico, le teorie proposte sono state presentate come interpretazioni dei<br />
fenomeni osservati, cercando <strong>di</strong> non confondere mai il livello empirico con il modello<br />
interpretativo. E’ un aspetto molto importante, perché contribuisce a smantellare la concezione <strong>di</strong><br />
scienza come prodotto preconfezionato, che a volte viene trasmessa ai ragazzi durante i livelli<br />
inferiori <strong>di</strong> scuola secondo cui scienza e verità sono sinonimi. Troppo spesso la scuola contribuisce<br />
al perpetuarsi del pensiero empirico-realista, secondo cui il sapere scientifico è un insieme <strong>di</strong><br />
conoscenze provate e oggettive ed è quin<strong>di</strong> sempre corrispondente al vero. Un buon insegnante <strong>di</strong><br />
scienze debba trasmettere ai suoi studenti l’idea che le teorie scientifiche non rispecchiano la realtà,<br />
ma sono delle interpretazioni coerenti e logiche della realtà, e per far questo, il docente dovrà<br />
presentare i modelli interpretativi dei fenomeni trattati come il frutto <strong>di</strong> un lungo cammino<br />
compiuto dagli scienziati.<br />
Come materiale <strong>di</strong> supporto <strong>di</strong>dattico mi sono avvalso <strong>di</strong> una presentazione in formato elettronico<br />
che ho utilizzato come preambolo <strong>di</strong> ogni lezione, per riprendere velocemente gli argomenti trattati<br />
e per introdurre i nuovi, per i contenuti delle trasparenze utilizzate si rimanda all’Allegato B.<br />
Inoltre, a compen<strong>di</strong>o del libro <strong>di</strong> testo adottato dall’insegnante, ho fornito una <strong>di</strong>spensa sia in<br />
formato cartaceo che in formato elettronico con i contenuti teorici essenziali e con i testi degli<br />
esercizi con cui gli allievi si sono cimentati, per il contenuto delle lezioni si rimanda all’Allegato C.<br />
Come si evince dalla struttura <strong>di</strong> tale <strong>di</strong>spensa, il messaggio che traspare e che ho riba<strong>di</strong>to durante<br />
gli incontri, è che la programmazione, qualunque sia il linguaggio adoperato e la tecnologia scelta,<br />
consta <strong>di</strong> fasi in cui un posto <strong>di</strong> rilievo va sicuramente delegato alla riflessione sulle specifiche e sul<br />
testo del problema al fine <strong>di</strong> ricavare l’intuizione e il “modus operan<strong>di</strong>” logico che permetta in<br />
maniera efficace ed efficiente <strong>di</strong> giungere alla risoluzione voluta.<br />
In questa fase <strong>di</strong> riflessione, l’allievo deve essere in grado <strong>di</strong> capire il problema che gli è stato<br />
sottoposto dal puro punto <strong>di</strong> vista dell’intelligibilità, poi deve articolare la metodologia <strong>di</strong><br />
riconoscimento delle strutture dati e del loro tipo da utilizzare per contenere le variabili necessarie,<br />
quin<strong>di</strong> abbozzare il <strong>di</strong>agramma <strong>di</strong> flusso contenente l’algoritmo risolutivo.<br />
11<br />
21
Se il collaudo su carta del <strong>di</strong>agramma porta a buon fine allora si può iniziare con la fase <strong>di</strong><br />
transco<strong>di</strong>fica usando la sintassi e la semantica del linguaggio implementativo.<br />
E’ buona norma scrivere il co<strong>di</strong>ce su carta per familiarizzare con le strutture car<strong>di</strong>ne del linguaggio<br />
e assimilare i tecnicismi e con le parole chiavi del linguaggio, poi l’ultimo passo è la stesura del<br />
listato in formato elettronico utilizzando l’ambiente <strong>di</strong> sviluppo e usufruendo dell’ambiente <strong>di</strong><br />
debug integrato per il collaudo della realizzazione.<br />
La scelta <strong>di</strong> fornire agli studenti tale impostazione è stata con<strong>di</strong>visa anche dal docente accogliente,<br />
che la pensava già nel modo suddetto, in effetti quando si entra in laboratorio i computer, notevole<br />
fonte <strong>di</strong> <strong>di</strong>strazione, sono spenti e solo quando bisogna collaudare il listato è possibile l’accesso.<br />
Nonostante le <strong>di</strong>fficoltà riscontrate, nel complesso ritengo comunque abbastanza sod<strong>di</strong>sfacente<br />
l’esperienza <strong>di</strong> tirocinio. Gli strumenti <strong>di</strong> <strong>di</strong>dattica dell’informatica si sono rivelati efficaci per<br />
un’analisi critica della natura e dei limiti dei processi <strong>di</strong> appren<strong>di</strong>mento, ma anche delle strutture e<br />
dei meto<strong>di</strong> utilizzati. E’ essenziale possedere strumenti adeguati <strong>di</strong> analisi che consentano <strong>di</strong><br />
prenderne piena coscienza, per poi sperimentare percorsi alternativi ed effettuare ulteriori<br />
valutazioni nel continuo tentativo <strong>di</strong> migliorarsi. L’insegnante in questo senso è anche ricercatore:<br />
deve preparare materiale <strong>di</strong>dattico, valutare e sperimentare approcci alternativi, tenersi informato<br />
sugli sviluppi della <strong>di</strong>dattica, confrontarsi con i colleghi e con gli stessi studenti nel tentativo<br />
continuo <strong>di</strong> migliorare se stesso, la sua professionalità e competenza 12 .<br />
Ovviamente tutto questo avverrà, in futuro, in tempi assai più compressi rispetto a quelli riservati a<br />
questa esperienza <strong>di</strong> tirocinio ed in ambienti sicuramente meno rassicuranti e collaborativi.<br />
Tengo a sottolineare che dal punto <strong>di</strong> vista strettamente personale, ritengo l’esperienza descritta in<br />
questa trattazione estremamente formativa e coinvolgente.<br />
L’accoglienza riservatami dall’ambiente classe è stata positiva oltre ogni previsione, i ragazzi hanno<br />
accettato la mia presenza con <strong>di</strong>sponibilità e sincero entusiasmo, creando un clima in classe <strong>di</strong><br />
collaborazione e confidenza inaspettato. A questo clima ha contribuito anche il docente accogliente,<br />
entusiasta in particolare delle lezioni in laboratorio e del relativo trasporto e partecipazione con cui<br />
queste sono state accolte dagli studenti.<br />
4.4. Progettazione della verifica<br />
La progettazione della verifica sommativa non può essere scissa dalla forma <strong>di</strong> valutazione; mi sono<br />
ispirato alla valutazione autentica 13 che nasce da un’esigenza <strong>di</strong> coerenza con le caratteristiche <strong>di</strong> un<br />
“appren<strong>di</strong>mento significativo” 14 , tale istanza <strong>di</strong>scende dal costruttivismo (Piaget): “io apprendo in<br />
quanto costruisco il mio sapere”.<br />
Le istanze <strong>di</strong> ren<strong>di</strong>contazione per la valutazione autentica impongono che bisogna valutare non solo<br />
ciò che un ragazzo “sa” (sapere riproduttivo), ma anche la costruzione e lo sviluppo delle<br />
conoscenze, la capacità <strong>di</strong> applicazione al reale <strong>di</strong> quanto si è appreso, ponendo attenzione al<br />
processo dell’appren<strong>di</strong>mento e alla capacità <strong>di</strong> applicare le conoscenze acquisite in contesti reali.<br />
Gli aspetti presi in considerazione dalla valutazione autentica 15 sono:<br />
• capacità <strong>di</strong> pensiero critico, esprimere un giu<strong>di</strong>zio sulla base <strong>di</strong> criteri giustificabili;<br />
12 M. Pellerey, Progettazione <strong>di</strong>dattica, <strong>Torino</strong>, SEI, 1983.<br />
13 Corso <strong>di</strong> Docimologia <strong>di</strong> Castol<strong>di</strong>, Definizione <strong>di</strong> valutazione autentica secondo Wiggins (1993; 1998):<br />
“valutare ciò che lo studente sa fare con ciò che sa”.<br />
14 Appren<strong>di</strong>mento che mo<strong>di</strong>fica la “struttura cognitiva” <strong>di</strong> chi apprende<br />
15 M. Comoglio, “La valutazione autentica”, Orientamenti pedagogici, vol. 49, n. 1, gennaio-febbraio 2002.<br />
22
• metacognizione, fa riferimento alla consapevolezza delle strategie mentali che il soggetto<br />
mette in atto e alla sua capacità <strong>di</strong> migliorarle;<br />
• capacità <strong>di</strong> Problem Solving;<br />
• ragionamento inteso come capacità <strong>di</strong> partire da premesse e portare avanti un<br />
ragionamento deduttivo;<br />
• capacità <strong>di</strong> lavorare in gruppo in situazione concreta <strong>di</strong> vita.<br />
In una parola possiamo <strong>di</strong>re che la valutazione autentica serve per valutare le competenze.<br />
I test tipici richiedono solo una risposta corretta, il compito autentico invece richiede un prodotto <strong>di</strong><br />
qualità è una giustificazione della realizzazione o processo (prodotto = frutto, processo =<br />
elaborazione). Le prove tra<strong>di</strong>zionali fanno riferimento a situazioni fittizie, quelle della valutazione<br />
autentica invece si riferiscono a quelle che si creano nella realtà.<br />
La prova somministrata all’ITIS Avogadro è riportata in allegato C.<br />
Per le verifiche formative e per le prove <strong>di</strong> laboratorio in itinere ho pensato <strong>di</strong> assegnare degli<br />
items che richiedessero agli allievi capacità <strong>di</strong> comprensione dei concetti OOP:<br />
( "cosa stampa il seguente co<strong>di</strong>ce OOP ... ", "completare le parti mancanti affinché il<br />
comportamento sia il seguente ..." ) e che capacità <strong>di</strong> progettazione o sintesi <strong>di</strong> co<strong>di</strong>ce OOP<br />
("implementare una data interfaccia <strong>di</strong> classe", "proporre un'interfaccia <strong>di</strong> classe per oggetti aventi<br />
un certo comportamento",-"in<strong>di</strong>viduare le classi degli oggetti e le loro relazioni (is, has, uses) da<br />
una realtà descritta a parole"). Segue un esempio frutto <strong>di</strong> un’esercitazione <strong>di</strong> laboratorio.<br />
Esempio:<br />
Progettare la classe LISTINO_PREZZI così come viene normalmente inteso nel senso comune<br />
(sapere se c'è una certa merce e quanto costa, cambiare il prezzo, ecc. ).<br />
a) proporre una coerente e completa interfaccia <strong>di</strong> classe, scegliendo con cura i nomi e giustificando<br />
le scelte fatte qualora ciò si renda necessario;<br />
b) implementare l'interfaccia in un linguaggio OOP<br />
c) proporre un esempio d'uso (ad. es. un programma principale <strong>di</strong> prova).<br />
23
4.5. Valutazione del <strong>lavoro</strong> fatto dagli studenti<br />
La valutazione 16 è l’espressione da parte del docente <strong>di</strong> un giu<strong>di</strong>zio su ogni singolo allievo in<br />
riferimento ad almeno due componenti dell’educazione: l’insieme delle capacità raggiunte; il grado<br />
<strong>di</strong> implicazione personale. Il processo valutativo riguarda quin<strong>di</strong> solo in parte le competenze<br />
raggiunte dallo studente, non esclusivamente a livello dell’assegnazione <strong>di</strong> un “voto” basato sul<br />
risultato e sull’impegno, ma stu<strong>di</strong>andone il <strong>lavoro</strong> <strong>di</strong> costruzione della conoscenza con l’occhio<br />
critico e gli strumenti acquisiti dagli stu<strong>di</strong> in <strong>di</strong>dattica dell’informatica. Strumenti che servono anche<br />
per la valutazione del proprio <strong>lavoro</strong> compiuto in aula, in conformità con i risultati ottenuti dagli<br />
studenti, analizzando il proprio operato e ripensando in maniera critica alle proprie strategie<br />
metodologiche ed alle scelte effettuate, segmento curricolare compreso.<br />
La valutazione è dunque complessa e multi<strong>di</strong>mensionale, così come lo è l’intricato processo<br />
sistemico <strong>di</strong> insegnamento-appren<strong>di</strong>mento, per cui per valutazione non deve intendersi solamente il<br />
bilancio dell’attività svolta, essa è infatti stata attuata lungo tutto l’arco <strong>di</strong> lezioni del progetto <strong>di</strong><br />
tirocinio, è parte integrante del processo <strong>di</strong> insegnamento-appren<strong>di</strong>mento ed ha influenzato<br />
continuamente contenuti e metodologia del <strong>lavoro</strong> in aula.<br />
Si valuta anche per effettuare scelte a livello <strong>di</strong> contenuto e circa la metodologia del <strong>lavoro</strong> in aula;<br />
per prendere decisioni circa l’ambiente classe e non ultimo per comunicare agli allievi, spesso<br />
implicitamente, quel che è importante .<br />
Per quel che riguarda la valutazione dell’ambiente classe devo <strong>di</strong>re che non è facile per un<br />
tirocinante influire in maniera decisiva in ambiente forgiato da mesi e mesi <strong>di</strong> collaborazione con<br />
l’insegnante titolare che, peraltro, è presente durante le lezioni. Cambiare le abitu<strong>di</strong>ni degli studenti,<br />
infondendo il gusto per l’esplorazione e la sperimentazione, dando la giusta importanza alla<br />
risoluzione dei problemi e alla scoperta, spostando l’attenzione dai risultati ai processi, è una<br />
trasformazione ra<strong>di</strong>cale che nella prima metà <strong>di</strong> tirocinio è tuttavia parsa possibile. Nel perseguire<br />
questo cambio <strong>di</strong> prospettive, verso un’implicazione personale dello studente, obiettivo primario in<br />
un’ottica costruttivista, è fondamentale l’ambiente d’aula; infatti il superamento della semplice<br />
conoscenza verso la competenza si esplicita anche attraverso atteggiamento, volizione, gusto e<br />
stabilendo una relazione positiva tra menti, comprendendo e valorizzando le risorse emotive a<br />
<strong>di</strong>sposizione 17 .<br />
16 L.S. Beccegato-B.M. Varisco, Docimologia. Per una cultura della valutazione, Milano, Guerini, 2000.<br />
17 Pombeni, M.L., “L’adolescente e la scuola”. In A. Palmonari (a cura <strong>di</strong>), Psicologia dell’adolescenza, Bologna, Il<br />
Mulino, 1997, pp. 271-291<br />
24
E’ evidente che non si valutano gli studenti, o meglio il loro <strong>lavoro</strong>, esclusivamente allo scopo <strong>di</strong><br />
assegnare loro un voto, e questo dovrebbe essere ben chiaro anche agli stessi allievi, ma per<br />
scar<strong>di</strong>nare l’associazione del termine valutazione con “voto sul registro” occorrerebbe un <strong>lavoro</strong> a<br />
lungo termine, possibilmente in collaborazione con gli altri docenti ma anche con le famiglie e<br />
l’ambiente esterno in generale 18 .<br />
Durante tutto il periodo del tirocinio si è prestata particolare attenzione al comportamento tenuto in<br />
aula dagli studenti, il modo in cui lavorano, ascoltandoli esporre le loro idee, prendendo gli errori<br />
come spunto <strong>di</strong> partenza <strong>di</strong> <strong>di</strong>scussioni anziché semplicemente correggerli, nel tentativo <strong>di</strong> valutare<br />
per ogni allievo il grado <strong>di</strong> implicazione personale raggiunto nel processo <strong>di</strong> appren<strong>di</strong>mento.<br />
Me<strong>di</strong>amente considero sod<strong>di</strong>sfacente l’esperienza da questo punto <strong>di</strong> vista, la <strong>di</strong>sponibilità ed il<br />
coinvolgimento sincero, in generale, mi sono parsi notevoli, nettamente al <strong>di</strong> sopra delle mie<br />
aspettative. Per esempio è accaduto più volte che alcuni allievi abbiano risolto a casa esercizi non<br />
assegnati e ne abbiano poi richiesta la correzione in classe. A volte le stesse domande spontanee<br />
degli studenti hanno portato ad approfon<strong>di</strong>menti in maniera naturale, guidata dal gusto del sapere e<br />
della scoperta. Ovviamente il grado <strong>di</strong> coinvolgimento all’interno della classe ha assunto sfumature<br />
<strong>di</strong>verse, ci sono anche studenti che si sono estraniati dalle lezioni, intervenendo solo quando<br />
<strong>di</strong>rettamente chiamati in causa (chi per <strong>di</strong>sinteresse, chi per carattere, chi perché in quel momento<br />
aveva altro per la testa) o quando si accorgevano che l’insegnante li stava osservando.<br />
Nel complesso processo <strong>di</strong> valutazione rimane ad ogni modo inclusa anche l’assegnazione del voto,<br />
perseguendo non tanto la chimera dell’oggettività quanto la coerenza e l’equità. Affinché dunque un<br />
voto sia giu<strong>di</strong>cato equo occorre anche in questo caso l’implicazione personale dello studente, una<br />
responsabilizzazione molto forte <strong>di</strong>fficile da ottenere sul breve periodo. Ho pertanto potuto<br />
assicurare professionalità, chiarezza e trasparenza, godendo <strong>di</strong> una ampia fiducia da parte degli<br />
studenti derivata probabilmente anche in questo caso dal ruolo <strong>di</strong> professore “a tempo determinato”,<br />
e in quanto tale giu<strong>di</strong>cato libero da pregiu<strong>di</strong>zi che con<strong>di</strong>zionano un insegnante <strong>di</strong> lunga data.<br />
Nella verifica sommativa, sia in momenti <strong>di</strong> valutazione non istituzionalizzati, i criteri che hanno<br />
guidato, per il processo <strong>di</strong> valutazione degli studenti ho applicato i seguenti criteri:<br />
• il criterio <strong>di</strong> realizzazione: la messa in atto <strong>di</strong> strategie adeguate a fronte <strong>di</strong> situazioni<br />
problematiche. Ad esempio l’impostazione <strong>di</strong> una risoluzione adeguata, la schematizzazione<br />
della situazione, l’utilizzo <strong>di</strong> grafici, ma anche la giustificazione del comportamento seguito per<br />
giungere alla soluzione, essere in grado argomentarne e giustificarne i passaggi.<br />
• il criterio <strong>di</strong> risultato: saper condurre il processo risolutivo secondo un comportamento logico,<br />
giungendo alla risposta giusta. Ma anche saper giustificare che la via scelta è la più idonea, la<br />
più economica.<br />
• Il criterio <strong>di</strong> comprensione: saper esporre il risultato ottenuto, metterlo in relazioni<br />
con altri in situazioni <strong>di</strong>verse.<br />
Si è inoltre cercato <strong>di</strong> rendere palese, ogni volta fosse possibile, l’importanza del processo rispetto<br />
al risultato, ma sra<strong>di</strong>care convinzioni costruite in anni <strong>di</strong> scolarizzazione non è affatto banale.<br />
Per la correzione delle prove ho utilizzato la griglia <strong>di</strong> valutazione <strong>di</strong> seguito riportata, in cui ho<br />
<strong>di</strong>stinto dei livelli associandone il giu<strong>di</strong>zio <strong>di</strong> valore secondo i criteri riportati, il voto attribuito<br />
espresso in decimi può essere il risultato della combinazione <strong>di</strong> livelli <strong>di</strong>versi <strong>di</strong> conoscenze,<br />
competenze, capacità e comportamenti 19 .<br />
Dall’analisi dei risultati si evince che i gli allievi sono riusciti ad in<strong>di</strong>viduare le classi e gli oggetti<br />
necessari per la risoluzione del tema, qualcuno ha avuto problemi nello strutturarne il <strong>di</strong>agramma, le<br />
principali <strong>di</strong>fficoltà sono incontrate nell’implementazione nel linguaggio Java e nella scrittura delle<br />
procedure.<br />
18 G. Domenici, Manuale della valutazione scolastica, Bari, Laterza, 2001.<br />
19 B.M. Varisco- L. Santelli, Docimologia. Per una cultura della valutazione, Milano, Guerini e associati, 2000.<br />
25
Griglia <strong>di</strong> Valutazione<br />
Conoscenze Competenze Capacità Comportamenti Livelli<br />
Voto in<br />
decimi<br />
Complete, con<br />
approfon<strong>di</strong>menti<br />
autonomi<br />
Sostanzialmente<br />
complete<br />
Conosce gli elementi<br />
essenziali,<br />
fondamentali<br />
Complessivamente<br />
accettabili;<br />
ha ancora lacune, ma<br />
non estese e /o<br />
profonde<br />
Incerte ed<br />
incomplete<br />
Frammentarie e<br />
gravemente lacunose<br />
Affronta autonomamente anche<br />
compiti complessi, applicando<br />
le conoscenze in modo corretto<br />
e creativo<br />
Affronta compiti anche<br />
complessi in modo accettabile<br />
Esegue correttamente compiti<br />
semplici;<br />
affronta compiti più complessi<br />
pur con alcune incertezze<br />
Esegue semplici compiti senza<br />
errori sostanziali;<br />
affronta compiti più complessi<br />
con incertezza<br />
Applica le conoscenze minime,<br />
senza commettere gravi errori,<br />
ma talvolta con imprecisione<br />
Solo se guidato arriva ad<br />
applicare le conoscenze minime;<br />
commette gravi errori anche<br />
nell’eseguire semplici esercizi<br />
Nessuna Nessuna Nessuna<br />
Comunica in modo proprio,<br />
efficace ed articolato; è<br />
autonomo ed organizzato;<br />
collega conoscenze attinte da<br />
ambiti pluri<strong>di</strong>sciplinari;<br />
analizza in modo critico, con<br />
un certo rigore; documenta il<br />
proprio <strong>lavoro</strong>; cerca<br />
soluzioni adeguate per<br />
situazioni nuove<br />
Comunica in maniera chiara<br />
ed appropriata ; ha una<br />
propria autonomia <strong>di</strong> <strong>lavoro</strong>;<br />
analizza in modo<br />
complessivamente corretto e<br />
compie alcuni collegamenti,<br />
arrivando a rielaborare in<br />
modo abbastanza autonomo<br />
Comunica in modo adeguato,<br />
anche se semplice;<br />
non ha piena autonomia, ma<br />
è un <strong>di</strong>ligente ed affidabile<br />
esecutore;<br />
coglie gli aspetti<br />
fondamentali, ma incontra<br />
<strong>di</strong>fficoltà nei collegamenti<br />
inter<strong>di</strong>sciplinari.<br />
Comunica in modo semplice,<br />
ma non del tutto adeguato;<br />
coglie gli aspetti<br />
fondamentali, ma le sue<br />
analisi sono lacunose<br />
Comunica in modo non<br />
sempre coerente e proprio; ha<br />
<strong>di</strong>fficoltà a cogliere i nessi<br />
logici e quin<strong>di</strong> ha <strong>di</strong>fficoltà<br />
ad analizzare temi, questioni<br />
e problemi<br />
Comunica in modo<br />
decisamente stentato e<br />
improprio;<br />
ha <strong>di</strong>fficoltà a cogliere i<br />
concetti e le relazioni<br />
essenziali che legano tra loro<br />
i fatti anche più elementari<br />
Partecipazione : costruttiva<br />
Impegno: notevole<br />
Metodo : elaborativo<br />
Partecipazione: attiva<br />
Impegno: notevole<br />
Metodo: organizzato<br />
Partecipazione: recettiva<br />
Impegno: sod<strong>di</strong>sfacente<br />
Metodo: organizzato<br />
Partecipazione: da sollecitare<br />
Impegno : accettabile<br />
Metodo : non sempre<br />
organizzato<br />
Partecipazione: <strong>di</strong>spersiva<br />
Impegno : <strong>di</strong>scontinuo<br />
Metodo : mnemonico<br />
Partecipazione:<br />
opportunistica<br />
Impegno: debole<br />
Metodo: ripetitivo<br />
Partecipazione: <strong>di</strong> <strong>di</strong>sturbo<br />
Impegno: nullo<br />
Metodo: <strong>di</strong>sorganizzato<br />
A 9 -10<br />
B 8<br />
C 7<br />
D 6<br />
E 5<br />
F 3 - 4<br />
G 1 – 2<br />
26
Gli elaborati hanno ottenuto i risultati riportati nel grafico sottostante:<br />
La me<strong>di</strong>a complessiva dei voti è stata 6,9 e sono state assegnate cinque insufficienze. Anche a<br />
giu<strong>di</strong>zio del docente accogliente il compito ha ottenuto risultati complessivamente sod<strong>di</strong>sfacenti,<br />
ad<strong>di</strong>rittura migliori rispetto a quelli delle precedenti verifiche.<br />
Le <strong>di</strong>fficoltà che si incontrano nell'insegnamento della OOP non consistono tanto nel far apprendere<br />
i meccanismi <strong>di</strong> base (creazione <strong>di</strong> oggetti e <strong>di</strong> classi) quanto nel cambio <strong>di</strong> atteggiamento che<br />
occorre far assumere gli allievi nell'affrontare i problemi, cioè nel far loro adottare una corretta<br />
metodologia <strong>di</strong> progettazione OOP.<br />
Tipicamente gli allievi tendono a non riconoscere le classi nella descrizione a parole <strong>di</strong> una certa<br />
realtà. Anche quando le riconoscono non scelgono in modo appropriato i meto<strong>di</strong>, tralasciandone<br />
alcuni <strong>di</strong> essenziali, <strong>di</strong>menticando <strong>di</strong> applicare il principio <strong>di</strong> information hi<strong>di</strong>ng, ecc. In altre<br />
parole quella che viene spesso a mancare è la capacità <strong>di</strong> astrazione, ancora forse non troppo<br />
sviluppata a questa età.<br />
Un'altra fonte <strong>di</strong> errori frequenti, causata da questa tipica limitazione, è costituita dall'ere<strong>di</strong>tarietà:<br />
non costruiscono adeguatamente le gerarchie <strong>di</strong> classi, specie quelle in cui occorrerebbe introdurre<br />
delle classi astratte. La confusione tra relazioni is e has è un'altra delle cause <strong>di</strong> strutturazioni non<br />
appropriate.<br />
Un consistente miglioramento per l'appren<strong>di</strong>mento della adeguata metodologia <strong>di</strong> programmazione<br />
anche per i problemi comuni è stata apportato, almeno in parte, con un'adeguata scelta <strong>di</strong> alcuni<br />
item significativi che insistevano sulle lacune palesate dagli allievi durante i loro interventi, per<br />
ciascuno <strong>di</strong> essi ho proposto la soluzione ottimale mettendola a confronto con quelle proposte dagli<br />
studenti stessi.<br />
27
5. Conclusioni<br />
All’interno del percorso biennale previsto dalla Scuola <strong>di</strong> Specializzazione per l’Insegnamento<br />
Secondario, struttura <strong>di</strong>dattica interateneo che ha come obiettivo la formazione degli insegnanti<br />
della scuola secondaria, il tirocinio riveste un ruolo <strong>di</strong> primaria importanza perché in esso<br />
confluiscono tutte le conoscenze e le riflessioni metodologiche, <strong>di</strong>dattiche, epistemologiche e<br />
sociologiche acquisite nei vari corsi frequentati e perché mi ha permesso, per me che non avevo mai<br />
avuto esperienze lavorative nell’ambito della scuola, <strong>di</strong> confrontarmi con tutti gli aspetti propri<br />
dell’attività lavorativa scolastica (pratici, <strong>di</strong>dattici, collegiali, gestionali, educativi e relazionali).<br />
In questo quadro, il tirocinio non può essere pensato come momento isolato nel processo <strong>di</strong><br />
formazione del futuro docente. Questa attività permette agli specializzan<strong>di</strong> <strong>di</strong> entrare a <strong>di</strong>retto<br />
contatto con le scuole, prima nella fase osservativa e poi in quella attiva, in cui si effettua una vera e<br />
propria esperienza d’insegnamento. Il carattere formativo del tirocinio è favorito dalla pluralità dei<br />
soggetti coinvolti (docente accogliente, supervisore, relatore…) assieme a cui lo specializzando<br />
elabora il suo progetto <strong>di</strong>dattico, ne gestisce la realizzazione e ne valuta l’efficacia, permettendo un<br />
proficuo confronto tra le <strong>di</strong>verse esperienze e competenze.<br />
Con le esperienze <strong>di</strong> tirocinio attivo ho portato spesso, all’interno delle classi, innovazioni<br />
<strong>di</strong>dattiche e metodologiche apprese nei corsi e nei Laboratori SSIS che consentono anche ai docenti<br />
accoglienti <strong>di</strong> fare tesoro dell’esperienza acquisita attraverso gli specializzan<strong>di</strong>, <strong>di</strong>venendo un<br />
momento importante <strong>di</strong> crescita per il sistema d’istruzione nel suo complesso.<br />
La Scuola <strong>di</strong> Specializzazione può quin<strong>di</strong> essere pensata come il luogo <strong>di</strong> me<strong>di</strong>azione tra l’attività <strong>di</strong><br />
formazione, svolta assieme ai Supervisori per il tirocinio ed in collaborazione coi docenti<br />
accoglienti, e la ricerca nell’insegnamento e nella <strong>di</strong>dattica, che va ben al <strong>di</strong> là della trasmissione <strong>di</strong><br />
conoscenze e che permette un proficuo collegamento tra il mondo della scuola e quello<br />
dell’università.<br />
La frequenza del biennio SSIS si pone come obiettivo la formazione <strong>di</strong> docenti capaci <strong>di</strong><br />
in<strong>di</strong>viduare opportunamente i problemi teorici e operativi in campo educativo e formativo e <strong>di</strong><br />
applicarli tenuto conto delle caratteristiche cognitive dell’alunno. L’insegnante consapevole delle<br />
modalità con cui i <strong>di</strong>versi apporti delle scienze umane <strong>di</strong>ventino con<strong>di</strong>zioni per l’impostazione<br />
unitaria del progetto educativo, dovrebbe essere in grado <strong>di</strong> progettare interventi <strong>di</strong>dattici per<br />
obiettivi, per ricerca <strong>di</strong>dattica e problem solving, in<strong>di</strong>viduando le strategie più efficaci in relazione<br />
alla situazione <strong>di</strong> contorno in cui è chiamato ad operare.<br />
Allora chi è e come dovrebbe essere l’insegnante perfetto<br />
Le competenze professionali derivano dall’insieme delle attitu<strong>di</strong>ni personali, dalla motivazione, dal<br />
bagaglio culturale e dell’esperienza, pertanto, se è vero che ognuno ha una propria personalità che<br />
influenza il modo <strong>di</strong> rapportarsi col mondo esterno, è anche vero che non ci si deve adagiare e che<br />
ogni insegnante deve impegnarsi a fondo per crescere dal punto <strong>di</strong> vista professionale. Il percorso<br />
della S.I.S. penso sia tarato con i vari corsi per chiarire a noi specializzan<strong>di</strong> per fornire gli spunti e<br />
le piste da seguire per ricercare una professionalità del docente. Ritengo che per essere un buon<br />
insegnante non sia sufficiente essere preparati nella propria <strong>di</strong>sciplina, anche se questa è una<br />
con<strong>di</strong>zione da cui non è possibile prescindere. Nell’insegnamento non esistono soluzioni standard<br />
adatte ad ogni situazione, ma l’insegnante competente è un professionista che, basandosi sul proprio<br />
bagaglio <strong>di</strong> conoscenze, sa trovare il modo migliore <strong>di</strong> gestire le situazioni più <strong>di</strong>sparate. Concordo<br />
con quanto l’affermazione che “si è competenti quando si decidono le azioni mentre le si compiono,<br />
le si valuta e le si corregge seduta stante, si esplorano gli elementi impliciti nelle relazioni stesse per<br />
tenerne conto <strong>di</strong> quelle imme<strong>di</strong>atamente successive, si ristrutturano significati e fini<br />
contemporaneamente all’impiego <strong>di</strong> determinati mezzi, si scopre, si genera e si con<strong>di</strong>vide un senso<br />
che si adatta e segue ogni mo<strong>di</strong>ficazione dei dati del sistema e delle <strong>di</strong>namiche relazionali che le<br />
accompagnano” 20 .<br />
20 Dispense del corso <strong>di</strong> Didattica generale, prof.ssa Pavone, S.I.S. Piemonte, A.A. 2004-2005<br />
28
I problemi vanno affrontati tempestivamente prendendo in considerazione approcci alternativi,<br />
scegliendo opportunamente tra questi, elaborando e realizzando adeguati piani d’azione. Bisogna<br />
saper riconoscere i segnali d’allarme prima che la situazione degeneri e ciò consente <strong>di</strong> prendere<br />
tempo per adottare soluzioni risolutive o sospensive a seconda dei casi. Non si rischia <strong>di</strong> perdere il<br />
controllo perché non si ha bisogno <strong>di</strong> controllare nulla, la situazione viene gestita apparentemente<br />
senza sforzo perché è l’intero contesto che è stato organizzato funzionalmente agli obiettivi.<br />
Dovrebbero essere proposti modelli che riducano tutto l’impegno professionale nella trasmissione<br />
dei contenuti <strong>di</strong>sciplinari o che assorbano tutto l’impegno del docente nella cura clinica degli aspetti<br />
psicologici e sociali della personalità è assurdo quanto pensare che sia possibile trasmettere<br />
alcunché senza la pre<strong>di</strong>sposizione del soggetto all’appren<strong>di</strong>mento o che sia possibile risolvere i<br />
problemi della persona senza la me<strong>di</strong>azione culturale. Il valore del modello è quello d’idea guida<br />
per la costruzione non del comportamento dell’insegnante, ma dello stile d’insegnamento come<br />
atteggiamento.<br />
La conoscenza d’alcuni modelli estremi può essere utile ai fini della formazione iniziale<br />
dell’insegnante per mostrare alcuni elementi primari <strong>di</strong> una funzione altrimenti non approcciabile<br />
che per intuizione ed immedesimazione. E’ solo la comprensione che viene dall’esperienza<br />
professionale che consente <strong>di</strong> utilizzare i modelli per una riflessione critica sullo sviluppo della<br />
propria professionalità.<br />
Per muoversi nella complessità della scuola, l’insegnante dovrebbe costruirsi dei punti <strong>di</strong> attenzione<br />
che gli permettano <strong>di</strong> sorvegliare l’intera situazione, un cruscotto denso <strong>di</strong> sofisticati sensori da<br />
monitorare durante la conduzione del proprio intervento <strong>di</strong>dattico.<br />
Per l’insegnante, l’opera <strong>di</strong> pre<strong>di</strong>sposizione <strong>di</strong> strumenti e soprattutto d’attivazione degli in<strong>di</strong>catori è<br />
onore ed onere personale. Il momento della conoscenza e della decisione in educazione non<br />
possono essere delegati a nessun altro, fatte salve le ovvie e debite risorse d’apporti specialistici,<br />
che però devono sempre essere adatti al contesto ed alla situazione. In educazione non è sempre<br />
semplice o privo <strong>di</strong> conseguenze il recupero dell’errore e della <strong>di</strong>strazione.<br />
Per i comportamenti automatici, manca totalmente spazio nel concetto <strong>di</strong> insegnante, basato sulla<br />
consapevolezza e responsabilità più che sull’accensione <strong>di</strong> luci che stimolino per con<strong>di</strong>zionamento<br />
risposte automatiche.<br />
Il nostro allievo deve poter essere messo in grado <strong>di</strong> sviluppare le capacità <strong>di</strong> analizzare e risolvere<br />
problemi <strong>di</strong> varia natura, deve interpretare il problema e costruirne la soluzione, inoltre deve essere<br />
in grado <strong>di</strong> inserirsi in un <strong>lavoro</strong> <strong>di</strong> gruppo. L’insegnante dovrà aiutare l’allievo per portarlo<br />
all’acquisizione della mentalità informatica coa<strong>di</strong>uvandolo nel potenziamento delle capacità<br />
richieste (astrazione, generalizzazione, associazione, <strong>di</strong>pendenze, correlazioni), modellazione<br />
coerentemente la realtà per descrivere le entità e le relazioni che costituiranno la base dati,<br />
applicazione degli algoritmi e delle strutture in maniera ottimale senza trascurare gli aspetti<br />
organizzativi e motivazionali.<br />
Ho potuto constatare che nell’insegnamento dell’informatica bisogna saper modulare gli approcci<br />
<strong>di</strong>dattici utilizzandoli a seconda della circostanza, per creare la situazione ottimale nel processo <strong>di</strong><br />
insegnamento-appren<strong>di</strong>mento che consenta all’allievo <strong>di</strong> ampliare la propria mappa concettuale,<br />
riorganizzando i concetti e facendo sorgere un vivo interesse e un atteggiamento positivo per lo<br />
stu<strong>di</strong>o delle <strong>di</strong>scipline tecniche.<br />
L’insegnante non ha il compito <strong>di</strong> trasmettere conoscenze, ma deve possedere una serie <strong>di</strong><br />
competenze che gli permettano <strong>di</strong> guidare i suoi allievi in un cammino <strong>di</strong> vita volto a formare la<br />
loro personalità. Oggi la scuola ha assunto una nuova centralità: se un tempo poteva essere<br />
considerata l’unica agenzia <strong>di</strong> socializzazione secondaria (la primaria è rappresentata dalla<br />
famiglia), oggi ci sono nuove agenzie (i mezzi <strong>di</strong> comunicazione <strong>di</strong> massa, il gruppo dei pari) con<br />
cui la scuola non può fare a meno <strong>di</strong> rapportarsi. Anzi proprio alla scuola spetta il compito <strong>di</strong> fornire<br />
ai ragazzi gli strumenti <strong>di</strong> criticità per rapportarsi con le nuove agenzie <strong>di</strong> socializzazione. Ed è<br />
proprio questo il contesto in cui si delinea la figura del docente moderno al quale si chiede <strong>di</strong><br />
possedere competenze che vanno al <strong>di</strong> là della preparazione in ambito <strong>di</strong>sciplinare.<br />
29
Ma quali sono queste competenze Senza volendo racchiuderle in un canovaccio deterministico e<br />
fuori da compartimenti stagni, un insegnante deve compen<strong>di</strong>are in sé almeno quattro livelli <strong>di</strong><br />
competenze: <strong>di</strong>sciplinari, relazionali, metodologiche-<strong>di</strong>dattiche ed organizzative.<br />
Il tendere verso il modello del perfetto insegnante deve procedere senza <strong>di</strong>silludersi o provare<br />
frustrazione per i propri errori, anzi, l’abilità consiste proprio nel trasformare gli errori in occasione<br />
<strong>di</strong> crescita ricordando sempre che un buon motto per un insegnante può essere “mettiamoci in<br />
<strong>di</strong>scussione e cresciamo insieme con i nostri allievi”.<br />
L’insegnante perfetto è un modello, rimane una chimera, anzi un’idea che anche la mano <strong>di</strong> un<br />
consumato demiurgo platoniano farebbe fatica a plasmare.<br />
30
Bibliografia<br />
1. Roletto E., Appren<strong>di</strong>mento delle Scienze e Didattiche <strong>di</strong>sciplinari, IRiDiS, <strong>Torino</strong>, 2003<br />
2. Blan<strong>di</strong>no G., Granieri B., La <strong>di</strong>sponibilità ad apprendere. Dimensioni emotive nella scuola e<br />
formazione degli insegnanti, Ed. Raffaello Cortina, Milano 1995<br />
3. Blan<strong>di</strong>no G., Granieri B., Le risorse emotive nella scuola, Ed. Raffaello Cortina, Milano 2002<br />
4. Fischer L., Sociologia della scuola, Il Mulino, Bologna, 2003<br />
5. Damiano E., L’azione <strong>di</strong>dattica, Armando, Roma, 1993<br />
6. Damiano E., Insegnare con i concetti. Un modello <strong>di</strong>dattico fra scienza e insegnamento, Ed.<br />
SEI, <strong>Torino</strong>, 1994<br />
7. Calvani A., Elementi <strong>di</strong> <strong>di</strong>dattica, Carocci, Roma, 2000<br />
8. Mariani A. M., Dispense del corso <strong>di</strong> Pedagogia Generale, S.I.S., <strong>Torino</strong>, A.A. 2004-2005<br />
9. Pavone M., Dispense del corso <strong>di</strong> Didattica Generale, S.I.S., <strong>Torino</strong>, A.A. 2004-2005<br />
10. Borca G., Dispense del corso <strong>di</strong> Psicologia dello Sviluppo, S.I.S., <strong>Torino</strong>, A.A. 2004-2005<br />
11. Coggi C, Notti A. M., Docimologia, Pensa Multime<strong>di</strong>a, Lecce, 2002<br />
12. Domenici G., Manuale della valutazione scolastica, Laterza, Bari, 2001<br />
13. Meyer B, Object Oriented Software Construction, Prentice Hall, 1997.<br />
14. Coad P., Jill N., OOP. Programmazione dei sistemi orientati agli oggetti, Jackson Libri, 1999<br />
15. Cox B. J., Programmazione orientata agli oggetti, Ad<strong>di</strong>son Wesley Longman Italia, 2000<br />
16. Wu C. T., Introduzione alla programmazione a oggetti in Java, McGraw-Hill Libri Italia, 2000<br />
31
INTRODUZIONE AL<br />
LINGUAGGIO JAVA<br />
Introduzione al linguaggio Java 1 Introduzione al linguaggio Java 2<br />
Parte 1<br />
Parte 2<br />
Parte 3<br />
INDICE<br />
Introduzione al sistema <strong>di</strong> programmazione<br />
Java<br />
Programmazione a oggetti<br />
Il linguaggio Java<br />
PARTE 1<br />
INTRODUZIONE AL SISTEMA DI<br />
PROGRAMMAZIONE JAVA<br />
Introduzione al linguaggio Java 3<br />
Introduzione al linguaggio Java 4<br />
CHE COS’È JAVA<br />
CARATTERISTICHE<br />
• È un linguaggio (e relativo ambiente <strong>di</strong><br />
programmazione) definito dalla Sun<br />
Microsystems …<br />
• … per permettere lo sviluppo <strong>di</strong> applicazioni<br />
sicure, performanti e robuste su piattaforme<br />
multiple, in reti eterogenee e <strong>di</strong>stribuite (Internet)<br />
Introduzione al linguaggio Java 5<br />
Introduzione al linguaggio Java 6<br />
Introduzione al linguaggio Java 1<br />
1
IL LINGUAGGIO JAVA:<br />
CARATTERISTICHE<br />
SEMPLICE E OO<br />
• Semplice e orientato agli oggetti<br />
• Interpretato<br />
• Architetturalmente neutro e portabile<br />
• Robusto<br />
• Distribuito<br />
• Sicuro<br />
• Dinamico<br />
• Ad elevate prestazioni<br />
• Concorrente (multithread)<br />
• Sintassi simile a C e C++ (facile da imparare)<br />
• Elimina i costrutti più "pericolosi" <strong>di</strong> C e C++<br />
– aritmetica dei puntatori<br />
– (de)allocazione esplicita della memoria<br />
– strutture (struct)<br />
– definizione <strong>di</strong> tipi (typedef)<br />
– preprocessore (#define)<br />
• Aggiunge garbage collection automatica<br />
• Conserva la tecnologia OO <strong>di</strong> base <strong>di</strong> C++<br />
• Rivisita C++ in alcuni aspetti (C++--==)<br />
Introduzione al linguaggio Java 7<br />
Introduzione al linguaggio Java 8<br />
INTERPRETATO<br />
BYTECODE: ESEMPIO<br />
• Il compilatore produce un co<strong>di</strong>ce <strong>di</strong> tipo<br />
interme<strong>di</strong>o per una “Java Virtual Machine” (“bytecode”)<br />
...<br />
• … che viene interpretato<br />
co<strong>di</strong>ce<br />
sorgente<br />
co<strong>di</strong>ce<br />
sorgente<br />
compilatore<br />
compilatore<br />
byte<br />
byte<br />
code<br />
code<br />
interprete<br />
interprete<br />
void spin ( ) {<br />
int i;<br />
for (i = 0; i < 100; i++) {<br />
;<br />
}<br />
} 0 iconst_0 // push int constant 0<br />
1 istore_1 // store into local 1 (i=0)<br />
2 goto 8 // first time, don’t increment<br />
5 iinc 1 1 // increment local i by 1 (i++)<br />
8 iload_1 // push local 1 (i)<br />
9 bipush 100 // push int constant (100)<br />
11 if_icmplt 5 // compare, loop if < (I
ESEMPIO<br />
• Il formato dei dati è specificato esattamente, e<br />
non “<strong>di</strong> minima”, come nel C:<br />
PORTABILE<br />
• Il sistema Java (compilatore + interprete + librerie<br />
run-time) è facilmente portabile su piattaforme<br />
<strong>di</strong>verse<br />
– byte 8 bit complemento a 2<br />
– short 16 bit “<br />
– int 32 bit “<br />
– long 64 bit “<br />
– float 32 bit IEEE 754 floating<br />
– double 64 bit “<br />
– char 16 bit Unicode<br />
co<strong>di</strong>ce<br />
sorgente<br />
co<strong>di</strong>ce<br />
sorgente<br />
compilatore<br />
compilatore<br />
byte<br />
byte<br />
code<br />
code<br />
interprete<br />
interprete<br />
libreria<br />
libreria<br />
– il compilatore Java è scritto in Java<br />
– l’ambiente run-time è scritto in ANSI C con interfacce<br />
standard (POSIX) verso il sistema operativo<br />
– nessuna “implementation dependency”<br />
S.O.<br />
Introduzione al linguaggio Java 13<br />
Introduzione al linguaggio Java 14<br />
ROBUSTO<br />
DISTRIBUITO<br />
• Controlli estensivi a compile-time e a run-time,<br />
per rilevare gli errori quanto prima possibile (es.:<br />
type checking)<br />
• Per questo, le caratteristiche insicure <strong>di</strong> C e C++<br />
sono rimosse:<br />
– Nessuna gestione esplicita dei puntatori (no aritmetica dei<br />
puntatori, no malloc e free esplicite, …)<br />
– Gestione della memoria con garbage collection<br />
– Array e stringhe “veri”<br />
• Verifica del byte-code a load-time<br />
• Pensato per essere eseguito in rete<br />
• L’ambiente run-time incorpora funzioni <strong>di</strong> rete<br />
(sia <strong>di</strong> basso livello: TCP/IP, che <strong>di</strong> alto livello:<br />
HTTP, …)<br />
• La rete è facilmente accessibile (come i file locali)<br />
Introduzione al linguaggio Java 15<br />
Introduzione al linguaggio Java 16<br />
SICURO<br />
COMPILE-LOAD-RUN<br />
• L’ambiente <strong>di</strong> esecuzione si protegge da bytecode<br />
potenzialmente “ostile”<br />
Sorgente Sorgente<br />
Java Java<br />
Loader Loader<br />
delle delle classi classi<br />
Verifica Verifica del del<br />
byte-code byte-code<br />
• Esempi:<br />
– il bytecode viene verificato prima dell’interpretazione<br />
(“theorem prover”), in modo da essere certi <strong>di</strong> alcune sue<br />
caratteristiche<br />
– gli in<strong>di</strong>rizzamenti alla memoria nel bytecode sono risolti sotto il<br />
controllo dell’interprete<br />
Compilatore<br />
Compilatore<br />
Byte-code Byte-code<br />
Java Java<br />
Rete<br />
Interprete Interprete<br />
Ambiente Ambiente<br />
run-time run-time<br />
hardware hardware<br />
Introduzione al linguaggio Java 17<br />
Introduzione al linguaggio Java 18<br />
Introduzione al linguaggio Java 3<br />
3
ELEVATE PRESTAZIONI<br />
COMPILAZIONE ON-THE-FLY<br />
• La verifica del bytecode permette <strong>di</strong> saltare molti<br />
controlli a run-time: l’interprete è pertanto<br />
efficiente<br />
• Per maggiore efficienza, possibilità compilazione<br />
on-the-fly del bytecode in co<strong>di</strong>ce macchina<br />
Sorgente Sorgente<br />
Java Java<br />
Compilatore<br />
Compilatore<br />
Rete<br />
Loader Loader<br />
delle delle classi classi<br />
Interprete Interprete<br />
Verifica Verifica del del<br />
byte-code byte-code<br />
Generatore Generatore<br />
<strong>di</strong> <strong>di</strong> co<strong>di</strong>ce co<strong>di</strong>ce<br />
Byte-code Byte-code<br />
Java Java<br />
Ambiente Ambiente<br />
run-time run-time<br />
hardware hardware<br />
Introduzione al linguaggio Java 19<br />
Introduzione al linguaggio Java 20<br />
DINAMICO<br />
CONCORRENTE<br />
• Il co<strong>di</strong>ce è eseguibile anche in assenza <strong>di</strong> alcuni<br />
moduli:<br />
• … le classi necessarie per la esecuzione <strong>di</strong> un<br />
programma Java possono essere caricate e<br />
collegate <strong>di</strong>namicamente quando servono<br />
Esempio: nuove release <strong>di</strong> moduli caricabili<br />
automaticamente dalla rete quando servono<br />
• Multithrea<strong>di</strong>ng parte integrante del linguaggio:<br />
– Applicazioni interattive più facili a scriversi<br />
– Migliore "reattività" (anche se non real-time)<br />
Esempio: caricamento asincrono <strong>di</strong> immagini nei<br />
browser <strong>di</strong> rete riduce i tempi <strong>di</strong> attesa<br />
Introduzione al linguaggio Java 21<br />
Introduzione al linguaggio Java 22<br />
RICCO<br />
La Standard Library Java contiene una ricca<br />
collezione <strong>di</strong> classi e <strong>di</strong> meto<strong>di</strong> preconfezionati:<br />
– Language support<br />
– Utilities<br />
– Input/output<br />
– Networking<br />
– Abstract Window Toolkit (AWT)<br />
JAVA E INTERNET<br />
Introduzione al linguaggio Java 23<br />
Introduzione al linguaggio Java 24<br />
Introduzione al linguaggio Java 4<br />
4
WEB BROWSER E SERVER<br />
Server abc.com<br />
Server xyz.com<br />
URL: Uniform Resource Locator<br />
Client<br />
:// <br />
Hyperlink<br />
Browser<br />
program<br />
to xyz.com<br />
Esempio:<br />
http://www.dsi.unimi.it/DSI/corsi/programmi/F28005/index.html<br />
Disk<br />
Disk<br />
HTTP used over<br />
this TCP connection<br />
HTTP<br />
Server<br />
HTTP<br />
Server<br />
deve essere risolto in un<br />
in<strong>di</strong>rizzo internet (IP)<br />
con l’aiuto <strong>di</strong> un Domain<br />
Name Server (DNS)<br />
Internet<br />
Introduzione al linguaggio Java 25<br />
Introduzione al linguaggio Java 26<br />
HTML: ESEMPIO<br />
APPLET JAVA<br />
<br />
<br />
Esempio <br />
<br />
<br />
<br />
Testo<br />
DSI <br />
<br />
<br />
Esempio<br />
Testo<br />
DSI<br />
• Sono programmi Java riferiti da link in pagine<br />
HTML<br />
• Vengono caricati e interpretati dal browser (se<br />
questo supporta Java)<br />
• Permettono <strong>di</strong> “animare” le pagine web<br />
Introduzione al linguaggio Java 27<br />
Introduzione al linguaggio Java 28<br />
HTML con APPLET: ESEMPIO<br />
JAVA BROWSER<br />
rete<br />
<br />
<br />
Esempio <br />
Esempio<br />
<br />
Testo<br />
<br />
Hallo!<br />
<br />
Testo<br />
<br />
Qui c’è un applet che ti saluta<br />
<br />
<br />
<br />
testo che esce se il browser<br />
non supporta gli applet<br />
http<br />
client<br />
interprete<br />
HTML<br />
TCP / IP<br />
ftp ftp<br />
client client<br />
interprete<br />
JAVA<br />
UI library<br />
java<br />
loader<br />
I/O<br />
library<br />
local <strong>di</strong>sk<br />
Introduzione al linguaggio Java 29<br />
Introduzione al linguaggio Java 30<br />
Introduzione al linguaggio Java 5<br />
5
Approccio tra<strong>di</strong>zionale<br />
RETE<br />
UN NUOVO PARADIGMA:<br />
NETWORK COMPUTING<br />
DATI<br />
PROGRAMMI<br />
PARTE 2<br />
PROGRAMMAZIONE A OGGETTI<br />
Network computing<br />
RETE<br />
PROGRAMMI E DATI<br />
PC<br />
NC<br />
load<br />
and run<br />
Introduzione al linguaggio Java 31<br />
Introduzione al linguaggio Java 32<br />
RIFLESSIONI SULLA<br />
PROGRAMMAZIONE<br />
PARADIGMI DI<br />
PROGRAMMAZIONE<br />
Programmare è un mestiere strano:<br />
costruire cose immateriali<br />
sempre piene <strong>di</strong> <strong>di</strong>fetti,<br />
che costano un sacco <strong>di</strong> sol<strong>di</strong><br />
e sono fatte <strong>di</strong> migliaia <strong>di</strong> frasi<br />
scritte da gente particolare<br />
per macchine molto stupide<br />
che richiedono precisione assoluta<br />
e che cambiano <strong>di</strong> continuo ...<br />
Introduzione al linguaggio Java 33<br />
Introduzione al linguaggio Java 34<br />
I DUE PARADIGMI DELLA<br />
PROGRAMMAZIONE<br />
ESEMPIO: UNA MACCHINA PER<br />
SPREMERE LE ARANCE<br />
Ci sono essenzialmente due mo<strong>di</strong> <strong>di</strong>versi <strong>di</strong><br />
descrivere il mondo:<br />
• come un sistema <strong>di</strong> processi<br />
(“modello procedurale”)<br />
• come un sistema <strong>di</strong> cose<br />
(“modello a oggetti”)<br />
Rube Goldberg, Inventions of Professor Lucifer Butts, 1932<br />
Introduzione al linguaggio Java 35<br />
Introduzione al linguaggio Java 36<br />
Introduzione al linguaggio Java 6<br />
6
IL MODELLO PROCEDURALE:<br />
ALCUNI TEMI TIPICI<br />
• Processi, sequenze <strong>di</strong> esecuzione<br />
• Concetto <strong>di</strong> “controllo”<br />
• Trasformazioni, funzioni<br />
• Flow-charts<br />
• Tracciatori, program profilers<br />
• Copertura topologica<br />
• Complessità strutturale<br />
• Il problema dei goto<br />
• Linguaggi strutturati<br />
• Programmazione top-down<br />
• Astrazione procedurale<br />
• ….<br />
LA MACCHINA DI VON NEUMANN<br />
“… nel progettare una sequenza co<strong>di</strong>ficata, quello che bisogna<br />
avere innanzitutto in mente non è l’apparenza originale della<br />
sequenza, ma piuttosto il suo funzionamento e il suo continuo<br />
cambiamento mentre il processo che essa controlla procede nel<br />
suo corso. …<br />
È dunque consigliabile incominciare la progettazione dalla fine, e<br />
cioè progettare per prima cosa il corso del processo e la<br />
relazione delle sue fasi successive con il co<strong>di</strong>ce che cambia, e<br />
quin<strong>di</strong> estrarre la sequenza co<strong>di</strong>ficata come operazione successiva.”<br />
Goldstine & Von Neumann, 1947<br />
Introduzione al linguaggio Java 37<br />
Introduzione al linguaggio Java 38<br />
SPAGHETTI E STRUTTURA<br />
RIUSABILITÀ NEI LINGUAGGI<br />
PROCEDURALI<br />
Dalle librerie <strong>di</strong> “subroutines” alle librerie <strong>di</strong><br />
procedure/funzioni<br />
Esempio: C<br />
int fun (int i, float r)<br />
{intj;<br />
….<br />
}<br />
“ASTRAZIONE FUNZIONALE”<br />
Introduzione al linguaggio Java 39<br />
Introduzione al linguaggio Java 40<br />
IL MODELLO PROCEDURALE:<br />
LINGUAGGI<br />
Fortran 1956-1957<br />
Cobol 1960<br />
Basic 1963-1964<br />
Pascal 1972<br />
C 1972<br />
UN BLOCCO INTELLETTUALE<br />
“… Questi “linguaggi <strong>di</strong> Von-Neumann” creano dei<br />
blocchi stradali mentali enormi e non necessari nel<br />
pensare i programmi e nel creare le combinazioni <strong>di</strong><br />
alto livello richieste da una metodologia <strong>di</strong><br />
programmazione veramente potente. …”<br />
John Backus, 1978<br />
Introduzione al linguaggio Java 41<br />
Introduzione al linguaggio Java 42<br />
Introduzione al linguaggio Java 7<br />
7
IL MODELLO A OGGETTI:<br />
ALCUNI TEMI TIPICI<br />
IL MODELLO A OGGETTI:<br />
LINGUAGGI<br />
• Dall’astrazione funzionale alla “data abstraction”<br />
• Costruire “cose”, non processi<br />
• Società <strong>di</strong> entità attive, cooperanti, riusabili<br />
• Dalla computazione alla comunicazione e alla delega<br />
• Classificare il mondo: classi, sottoclassi, istanze<br />
(“esemplari”)<br />
• Bottom-up, non top-down<br />
Simula<br />
Smalltalk<br />
Eiffel<br />
C++<br />
Java<br />
Introduzione al linguaggio Java 43<br />
Introduzione al linguaggio Java 44<br />
OGGETTI: CHE SONO MAI<br />
• Versione informatica degli oggetti "reali"<br />
IL PARADIGMA<br />
A OGGETTI<br />
• Dotati <strong>di</strong> una loro propria "in<strong>di</strong>vidualità"<br />
• Capaci <strong>di</strong> interagire per scambio <strong>di</strong> messaggi<br />
• Caratterizzati da proprietà<br />
– dati: ne descrivono lo “stato”<br />
– funzioni: ne descrivono il “comportamento”<br />
• Un msg mo<strong>di</strong>fica stato e attiva comportamenti<br />
Un oggetto è una coppia [stato,funzioni]<br />
Introduzione al linguaggio Java 45<br />
Introduzione al linguaggio Java 46<br />
ESEMPIO: UN’AUTOMOBILE<br />
CLASSI<br />
• una classe ha un nome, e contiene due tipi <strong>di</strong> membri:<br />
campi e meto<strong>di</strong><br />
metodo<br />
metodo<br />
Funzioni<br />
Dati:<br />
- Avviati - Targa<br />
-Fermati<br />
-Colore<br />
- Accelera - Velocità<br />
- … - Livello benzina<br />
-...<br />
campi<br />
metodo metodo<br />
“Tipo <strong>di</strong> dati astratti” (ADT)<br />
Introduzione al linguaggio Java 47<br />
Introduzione al linguaggio Java 48<br />
Introduzione al linguaggio Java 8<br />
8
OGGETTI<br />
• Un oggetto è una istanza (“esemplare”) <strong>di</strong> una<br />
classe, che viene creato (“instanziato”) <strong>di</strong>namicamente<br />
Automobile<br />
variabili<br />
valori<br />
Due esemplari della stessa classe sono <strong>di</strong>stinguibili soltanto per il loro<br />
stato (il valore dei loro campi), mentre il comportamento è sempre<br />
identico<br />
c<br />
Introduzione al linguaggio Java 49<br />
a<br />
MIK1178<br />
MIV5678<br />
b<br />
BO8956<br />
CLASSI: ESEMPIO (JAVA)<br />
class Automobile {<br />
string targa;<br />
int velocità;<br />
color colore;<br />
…<br />
public void Avviati () {<br />
…..<br />
}<br />
public void Fermati () {<br />
}<br />
}<br />
Introduzione al linguaggio Java 50<br />
nome classe<br />
campi<br />
meto<strong>di</strong><br />
OGGETTI: ESEMPIO (JAVA)<br />
INCAPSULAMENTO<br />
class Automobile {<br />
….<br />
}<br />
….<br />
Automobile a, b, c;<br />
a = new Automobile();<br />
b = new Automobile();<br />
c = new Automobile();<br />
….<br />
a.Avviati();<br />
….<br />
<strong>di</strong>chiara, non crea<br />
crea<br />
• Alcuni attributi (dati e meto<strong>di</strong>) sono pubblici (cioè<br />
visibili "all'esterno")<br />
• Altri attributi sono privati dell'oggetto, e quin<strong>di</strong><br />
“nascosti” all’esterno (“information hi<strong>di</strong>ng”)<br />
• Le parti private sono mo<strong>di</strong>ficabili senza effetti per gli<br />
interlocutori dell'oggetto<br />
• Propagazione delle mo<strong>di</strong>fiche assai contenuta<br />
• Stimolo al riutilizzo <strong>di</strong> oggetti ("black-box")<br />
Introduzione al linguaggio Java 51<br />
Introduzione al linguaggio Java 52<br />
ESEMPIO: AUTOMOBILE<br />
• Parti "visibili" (interfaccia pubblica):<br />
accesso a "ciò che l'auto può fare"<br />
– volante, combinazione volante-freno (ev. a mano)<br />
– blocchetto <strong>di</strong> accensione, oppure manovella<br />
– pedale dell'acceleratore, acceleratore automatico<br />
• Parti "nascoste" (implementazione):<br />
"come l'auto fa ciò che si può fare"<br />
– meccanica dello sterzo e dell'alimentazione<br />
– elettromeccanica dell'avviamento<br />
– sistema <strong>di</strong> alimentazione e accensione<br />
INCAPSULAMENTO: APPROCCI<br />
• Approccio "puro"<br />
lo stato è privato, e lo si può mo<strong>di</strong>ficare solo<br />
attraverso quei meto<strong>di</strong> che sono stati <strong>di</strong>chiarati<br />
pubblici .<br />
Esempio: Fermati()<br />
• Approccio <strong>di</strong> Java<br />
anche le componenti dello stato possono essere<br />
<strong>di</strong>chiarate pubbliche e mo<strong>di</strong>ficate dall'esterno<br />
Esempio: velocita=0<br />
Introduzione al linguaggio Java 53<br />
Introduzione al linguaggio Java 54<br />
Introduzione al linguaggio Java 9<br />
9
INTERAZIONI TRA OGGETTI<br />
ESEMPIO: UN'AUTOVETTURA<br />
• Gli oggetti possono comunicare e interagire<br />
me<strong>di</strong>ante scambio <strong>di</strong> messaggi attraverso le loro<br />
interfacce pubbliche (stato o funzioni)<br />
• Per mezzo <strong>di</strong> un messaggio un oggetto può chiedere<br />
un'informazione a un altro oggetto, causarne un<br />
cambiamento <strong>di</strong> stato, oppure delegargli un'attività<br />
• Un messaggio in arrivo viene trattato dal metodo<br />
omonimo del ricettore, il quale "si attiva" per<br />
rispondere, per cambiare <strong>di</strong> stato, oppure per<br />
intraprendere un'attività<br />
• Il sistema antiskid durante una frenata invia<br />
perio<strong>di</strong>camente un messaggio alle ruote per<br />
"leggere" la loro velocità <strong>di</strong> rotazione<br />
• Il galleggiante nel serbatoio del carburante invia<br />
messaggi all'in<strong>di</strong>catore <strong>di</strong> livello sul cruscotto per<br />
"scrivervi" un nuovo stato<br />
• Il volante tornando alla posizione <strong>di</strong> riposo invia un<br />
messaggio al comando meccanico dell'in<strong>di</strong>catore <strong>di</strong><br />
<strong>di</strong>rezione per delegargli il compito <strong>di</strong> interrompere<br />
l'eventuale segnale lampeggiante (i.e. <strong>di</strong> "togliere la<br />
freccia")<br />
Introduzione al linguaggio Java 55<br />
Introduzione al linguaggio Java 56<br />
OGGETTI COMPOSTI<br />
Un oggetto può essere costituito da altri oggetti<br />
UN SISTEMA A OGGETTI<br />
chiamata <strong>di</strong> un metodo <strong>di</strong> b<br />
main<br />
b<br />
d<br />
automobile<br />
a<br />
c<br />
e<br />
ruota<br />
carrozzeria<br />
motore<br />
g<br />
f<br />
Introduzione al linguaggio Java 57<br />
Introduzione al linguaggio Java 58<br />
SISTEMI A OGGETTI<br />
ESEMPIO: ARTIFICIAL LIFE<br />
• Società <strong>di</strong> entità attive, cooperanti, riusabili<br />
• Bottom-up, non top-down<br />
• Visione locale, non globale<br />
• “Comportamento emergente”<br />
Introduzione al linguaggio Java 59<br />
Introduzione al linguaggio Java 60<br />
Introduzione al linguaggio Java 10<br />
10
UNA DOMANDA IMPORTANTE<br />
I computer possono fare <strong>di</strong> più <strong>di</strong> quanto venga<br />
loro in<strong>di</strong>cato<br />
EREDITARIETÀ<br />
• È il meccanismo che consente <strong>di</strong> derivare una<br />
sottoclasse da una classe data<br />
• Una sottoclasse si ottiene per aggiunta, per<br />
occultamento o per ridefinizione <strong>di</strong> uno o più membri<br />
rispetto alla classe <strong>di</strong> partenza (che <strong>di</strong>venta una<br />
superclasse della nuova classe)<br />
Esempio:<br />
automobile<br />
taxi<br />
StartTassametro<br />
EndTassametro<br />
Licenza<br />
Introduzione al linguaggio Java 61<br />
Introduzione al linguaggio Java 62<br />
ESEMPIO<br />
class Taxi extends Automobile {<br />
int licenza;<br />
public void StartTassametro() {<br />
…<br />
}<br />
public void EndTassametro () {<br />
…<br />
}<br />
}<br />
nuovo campo<br />
nuovi meto<strong>di</strong><br />
ESEMPI<br />
• Implementazione <strong>di</strong> un'interfaccia grafica<br />
– classe "finestra": attributo privato "sfondo" e metodo "cambia-sfondo"<br />
– sottoclasse "finestra-nera": attributo privato "sfondo" ridefinito con il<br />
valore costante "nero", metodo "cambia-sfondo" occultato<br />
• Libreria <strong>di</strong> algebra lineare:<br />
– classe "matrice": metodo "determinante" generico<br />
– sottoclasse "matrice-<strong>di</strong>agonale": metodo "determinante" che<br />
moltiplica tra <strong>di</strong> loro gli elementi sulla <strong>di</strong>agonale<br />
• Dichiarazione dei red<strong>di</strong>ti<br />
– classe "contribuente": quadri del modello 740 base<br />
– classe "autonomi": aggiunta del membro "quadro-E"<br />
Introduzione al linguaggio Java 63<br />
Introduzione al linguaggio Java 64<br />
GERARCHIA DI CLASSI<br />
ESEMPIO<br />
obiect<br />
obiect<br />
Veicolo<br />
Veicolo<br />
Generalizzazione<br />
Specializzazione<br />
VeicoloSenza<br />
VeicoloSenza<br />
Motore<br />
Motore<br />
Veicolo<br />
Veicolo<br />
A<br />
A<br />
Motore<br />
Motore<br />
Motocicletta<br />
Motocicletta<br />
Automobile<br />
Automobile<br />
instanziazione<br />
Taxi<br />
Taxi<br />
Introduzione al linguaggio Java 65<br />
Introduzione al linguaggio Java 66<br />
Introduzione al linguaggio Java 11<br />
11
AGGIUNGERE SOTTOCLASSI<br />
RIDEFINIZIONE DEI METODI<br />
obiect<br />
obiect<br />
Veicolo<br />
Veicolo<br />
Veicolo<br />
Veicolo<br />
A Motore<br />
Motore<br />
Noleggia<br />
VeicoloSenza<br />
VeicoloSenza<br />
Motore<br />
Motore<br />
Veicolo<br />
Veicolo<br />
A<br />
A<br />
Motore<br />
Motore<br />
Motocicletta<br />
Motocicletta<br />
Automobile<br />
Automobile<br />
Altro<br />
Altro<br />
Motocicletta<br />
Motocicletta<br />
Automobile<br />
Automobile<br />
Aereo<br />
Aereo<br />
Noleggia<br />
Taxi<br />
Taxi<br />
ere<strong>di</strong>tano il metodo<br />
utilizza la versione locale<br />
Introduzione al linguaggio Java 67<br />
Introduzione al linguaggio Java 68<br />
POLIMORFISMO<br />
VISIBILITÀ DEI NOMI<br />
“Ciò che vale per una classe, vale anche per le sue<br />
sottoclassi.<br />
Se una proprietà viene ridefinita, quando la uso<br />
viene selezionata la versione corretta”<br />
nome<br />
gerarchia <strong>di</strong> classi<br />
Esempio:<br />
Quando uso un metodo <strong>di</strong> un oggetto, non so:<br />
• a quali livelli è definito<br />
• quale tra i meto<strong>di</strong> omonimi nella gerarchia verrà<br />
usato<br />
Il msg inviato all’oggetto<br />
risale nella gerarchia fino<br />
a trovare una definizione<br />
b.nome<br />
oggetto b<br />
oggetto a<br />
Introduzione al linguaggio Java 69<br />
Introduzione al linguaggio Java 70<br />
PROGRAMMAZIONE A OGGETTI E<br />
TASSONOMIA<br />
ESEMPI ALTERNATIVI<br />
Nel para<strong>di</strong>gma a oggetti, l’attenzione del<br />
programmatore è spostata dalla creazione <strong>di</strong><br />
processi <strong>di</strong> computazione alla creazione <strong>di</strong><br />
tassonomie del sistema in esame<br />
Spider<br />
Automobile<br />
Berlina<br />
Benzina<br />
Automobile<br />
Diesel<br />
Osservazioni:<br />
• Per descrivere un sistema sono possibili<br />
tassonomie <strong>di</strong>verse, a seconda degli obbiettivi<br />
Segmento A<br />
Segmento B<br />
Segmento C<br />
• La tassonomia è un’arte <strong>di</strong>fficile<br />
Introduzione al linguaggio Java 71<br />
Introduzione al linguaggio Java 72<br />
Introduzione al linguaggio Java 12<br />
12
EREDITARIETÀ MULTIPLA<br />
• Meccanismo che consente <strong>di</strong> derivare sottoclassi<br />
da due o più classi<br />
Automobile<br />
Mezzo<br />
Pubblico<br />
RIUSO<br />
Classi specifiche<br />
Classi specializzate<br />
sviluppo interno<br />
dal fornitore <strong>di</strong> classi<br />
Taxi<br />
• Il problema degli omonimi<br />
• Java non implementa ere<strong>di</strong>tarietà multipla<br />
Classi generali<br />
Linguaggio<br />
col linguaggio<br />
Introduzione al linguaggio Java 73<br />
Introduzione al linguaggio Java 74<br />
PARTE 3<br />
IL LINGUAGGIO JAVA<br />
INDICE<br />
• Caratteristiche lessicali<br />
• Tipi<br />
• Strutture <strong>di</strong> controllo<br />
• Classi<br />
• Ere<strong>di</strong>tarietà<br />
• Interfacce<br />
• Packages<br />
• Struttura <strong>di</strong> un’applicazione<br />
• Multithrea<strong>di</strong>ng<br />
Introduzione al linguaggio Java 75<br />
Introduzione al linguaggio Java 76<br />
ALFABETO<br />
CARATTERISTICHE LESSICALI<br />
• I sorgenti Java utilizzano il co<strong>di</strong>ce standard<br />
internazionale a 16 bit Unicode, che comprende<br />
gli alfabeti più <strong>di</strong>ffusi:<br />
arabo, greco, ebraico, cirillico, thai, katakana,<br />
hiragana, cinese, coreano, e molti altri<br />
(http://www.unicode.org)<br />
• I programmi Java possono essere scritti con altre<br />
co<strong>di</strong>fiche (es. ASCII), ma devono essere convertiti<br />
in Unicode prima <strong>di</strong> essere compilati<br />
• Sequenze <strong>di</strong> escape: /udddd (d: 0-9, a-f, A-F)<br />
Introduzione al linguaggio Java 77<br />
Introduzione al linguaggio Java 78<br />
Introduzione al linguaggio Java 13<br />
13
FORMATO<br />
COMMENTI<br />
• Il formato <strong>di</strong> un sorgente Java è libero: gli spazi<br />
(blank, tab, newline, form feed) non sono<br />
significativi, tranne che per separare i token fra<br />
loro, o nei letterali<br />
Tre <strong>di</strong>versi stili:<br />
• /* Commento tra<strong>di</strong>zionale, eventualmente su più<br />
linee, non ni<strong>di</strong>ficato */<br />
• // Commento su <strong>di</strong> una sola linea<br />
• /** Commento <strong>di</strong> documentazione". */<br />
Solo imme<strong>di</strong>atamente prima <strong>di</strong> una <strong>di</strong>chiarazione<br />
<strong>di</strong> classe, interfaccia, metodo o campo, e viene<br />
incluso nella documentazione generabile automaticamente<br />
a partire dal co<strong>di</strong>ce sorgente (es.: javadoc)<br />
Introduzione al linguaggio Java 79<br />
Introduzione al linguaggio Java 80<br />
ESEMPIO<br />
TAGS<br />
/** Questo è un esempio <strong>di</strong> commento <strong>di</strong><br />
documentazione per una classe “Automobile”<br />
* @see Ruota<br />
* @see Carrozzeria<br />
* @author Roberto<br />
* @version 1.0<br />
*/<br />
Tag Descrizione Si applica a<br />
@see Nome <strong>di</strong> classe Classe, metodo, campo<br />
collegata<br />
@author Nome autore Classe<br />
@version Versione Classe<br />
@param Nome e descrizione Metodo<br />
parametro<br />
@return Descrizione del valore Metodo<br />
<strong>di</strong> ritorno<br />
@exception Nome e descrizione Metodo<br />
eccezione<br />
Introduzione al linguaggio Java 81<br />
Introduzione al linguaggio Java 82<br />
IDENTIFICATORI<br />
• Sono composti da “lettere Java” e “cifre Java”, e<br />
devono iniziare con una “lettera Java”<br />
• Possono essere <strong>di</strong> qualsiasi lunghezza<br />
• Attenzione:<br />
– sono lettere e cifre Unicode!<br />
– _ e $ sono considerate lettere<br />
– caratteri con co<strong>di</strong>fica <strong>di</strong>versa (es. maiuscole e minuscole) sono<br />
considerati <strong>di</strong>versi (anche se hanno la stessa rappresentazione)<br />
PAROLE CHIAVE<br />
Le seguenti keywords non possono essere usate come identificatori:<br />
abstract double int super<br />
boolean else interface switch<br />
break extends long synchronized<br />
byte final native this<br />
case finally new throw<br />
catch float package throws<br />
char for private transient<br />
class (goto) protected try<br />
(const) if public void<br />
continue implements return volatile<br />
default import short while<br />
do instanceof static<br />
Note: - const e goto sono riservate, ma non usate<br />
- anche i letterali null, true, false sono riservati<br />
Introduzione al linguaggio Java 83<br />
Introduzione al linguaggio Java 84<br />
Introduzione al linguaggio Java 14<br />
14
struct union enum<br />
signed unsigned<br />
extern<br />
auto register<br />
sizeof typedef<br />
KEYWORDS JAVA E C<br />
C<br />
char int short<br />
long float double<br />
void<br />
if else for while do<br />
switch case default<br />
break continue<br />
return goto°°<br />
volatile<br />
static const°°<br />
Java<br />
byte boolean<br />
final<br />
try catch finally throw<br />
throws<br />
private public protected<br />
transient synchronized<br />
native abstract<br />
import class extends<br />
instanceof implements<br />
interface package<br />
this super new<br />
TIPI<br />
° letterali, non keywords<br />
°° riservate ma non usate in Java<br />
true° false° null°<br />
Introduzione al linguaggio Java 85<br />
Introduzione al linguaggio Java 86<br />
TIPI: SINTESI<br />
TIPI (segue)<br />
TIPI KEYWORD NOTE<br />
Primitivi<br />
Reference<br />
boolean:<br />
numerici<br />
classi<br />
interfacce<br />
array<br />
interi<br />
floating-point<br />
boolean<br />
byte<br />
short<br />
int<br />
long<br />
char<br />
float<br />
double<br />
class<br />
interface<br />
true, false<br />
8 bit interi in compl. a 2<br />
16 bit<br />
32 bit<br />
64 bit<br />
16 bit Unicode<br />
32 bit IEEE 754<br />
64 bit<br />
• Linguaggio fortemente tipato:<br />
il tipo <strong>di</strong> una espressione è sempre noto a<br />
compile-time<br />
• Linguaggio a oggetti non puro:<br />
non tutti i tipi sono classi<br />
• Rispetto al C, non esistono:<br />
signed, unsigned, long double, enum, puntatori,<br />
struct, union, typedef<br />
Null<br />
Introduzione al linguaggio Java 87<br />
Introduzione al linguaggio Java 88<br />
TIPI PRIMITIVI: ESEMPI<br />
CLASSI<br />
• Dichiarazioni: int i, float f;<br />
• Inizializzazioni: double d = 3.14;<br />
• Espressioni: i + 5<br />
j = i++<br />
Nota:<br />
byte e short vengono sempre promossi a int prima<br />
<strong>di</strong> essere valutati<br />
• Assegnamenti: i = j + 5;<br />
Essenzialmente, gli<br />
stessi operatori del C<br />
<strong>di</strong>chiarazione <strong>di</strong> classe:<br />
class Automobile {<br />
<br />
<br />
}<br />
<strong>di</strong>chiarazione <strong>di</strong> oggetto:<br />
Automobile a;<br />
a<br />
creazione <strong>di</strong> oggetto:<br />
a<br />
a = new Automobile();<br />
uso dell’oggetto:<br />
… a.campo … … a.metodo(…) ...<br />
nul<br />
heap<br />
I campi vengono<br />
inizializzati<br />
Introduzione al linguaggio Java 89<br />
Introduzione al linguaggio Java 90<br />
Introduzione al linguaggio Java 15<br />
15
CLASSI: ESEMPIO<br />
CLASSI “WRAPPER”<br />
class Safe {<br />
public int doorNumber = 123;<br />
private boolean locked = true;<br />
private int combination = 456;<br />
public boolean isLocked() {<br />
return (locked)<br />
}<br />
public void unLock (int thisCombination) {<br />
if (thisCombination == combination) unLock();<br />
}<br />
private void unLock() {<br />
locked = false;<br />
}<br />
private void setCombination(int setting) {<br />
combination = setting;<br />
}<br />
Safe() { } /* costruttore */<br />
}<br />
Safe (int door) { /* altro costruttore (overloa<strong>di</strong>ng) */<br />
doorNumber = door;<br />
setCombination(doorNumber);<br />
}<br />
Introduzione al linguaggio Java 91<br />
123<br />
Safe aSafe;<br />
aSafe = new Safe();<br />
Safe anotherSafe;<br />
anotherSafe = new Safe(1927)<br />
...<br />
aSafe.doorNumber=456;<br />
aSafe.unLock(1997);<br />
• Tutti i tipi primitivi tranne byte e short hanno una<br />
classe corrispondente nel package java.lang:<br />
Boolean, Integer, Long, Character, Float, Double,<br />
(“wrapper class”)<br />
• Tale classe definisce meto<strong>di</strong> e costanti utili per<br />
quel tipo, ad esempio:<br />
Classe: Character<br />
Costanti (static): MIN_VALUE, MAX_VALUE, …<br />
Meto<strong>di</strong> (static): isDefined, isLowerCase, IsUpperCase,<br />
isTitleCase, isDigit, isLetter, isLetterOrDigit, isSpace,<br />
isJavaLetter,isJavaLetterOrDigit, toLowerCase,<br />
toUpperCase, toTitleCase, <strong>di</strong>git, forDigit<br />
Introduzione al linguaggio Java 92<br />
INTERFACCE<br />
ESEMPIO<br />
• In sostanza, sono liste <strong>di</strong> meto<strong>di</strong> <strong>di</strong> cui non è<br />
definita l’implementazione, ma solo l’interfaccia<br />
• La loro implementazione deve essere realizzata<br />
da una classe<br />
public interface Au<strong>di</strong>oClip {<br />
void play (); /* avvia i'esecuzione */<br />
void loop (); /* esegui ciclicamente una au<strong>di</strong>o clip */<br />
void stop (); /* interrompi l'esecuzione */ }<br />
class MyAu<strong>di</strong>o implements Au<strong>di</strong>oClip {<br />
void play () { }<br />
void loop () { }<br />
void stop () { } }<br />
class YourAu<strong>di</strong>o implements Au<strong>di</strong>oClip { }<br />
I meto<strong>di</strong> possono essere public o abstract, gli attributi public, static o final<br />
Introduzione al linguaggio Java 93<br />
Introduzione al linguaggio Java 94<br />
ARRAY<br />
• In Java gli array sono oggetti<br />
• I componenti <strong>di</strong> un array:<br />
– sono tutti dello stesso tipo<br />
– possono essere <strong>di</strong> tipo primitivo o reference (inclusi altri array)<br />
– sono in<strong>di</strong>cizzati con int (in<strong>di</strong>ce primo elemento: 0), con<br />
controllo <strong>di</strong> vali<strong>di</strong>tà degli in<strong>di</strong>ci a run-time<br />
• Esempio:<br />
int[ ] a; /* <strong>di</strong>chiarazione */<br />
a null<br />
/* anche int a[ ]; */<br />
a<br />
a = new int[3]; /* creazione */<br />
heap<br />
a[0] = 0; /* uso */<br />
ARRAY (segue)<br />
• La lunghezza <strong>di</strong> un array è fissata al momento<br />
della sua creazione, e non può essere cambiata…<br />
• ... ma si può assegnare un nuovo array <strong>di</strong> <strong>di</strong>versa<br />
lunghezza all’array reference:<br />
int[ ] a = new int[3];<br />
a = new int[5];<br />
a<br />
a<br />
heap<br />
heap<br />
Introduzione al linguaggio Java 95<br />
Introduzione al linguaggio Java 96<br />
Introduzione al linguaggio Java 16<br />
16
ARRAY DI ARRAY<br />
ARRAY DI OGGETTI<br />
short [ ] [ ] a; /* array <strong>di</strong> array <strong>di</strong> short */<br />
short a[ ] [ ]; /* equivalente */<br />
a = new short [3][2];<br />
a<br />
a[2][0]<br />
class Automobile {<br />
public int targa;<br />
public int velocità;<br />
….<br />
}<br />
….<br />
Automobile[ ] a=new Automobile[3];<br />
a<br />
heap<br />
heap<br />
a = new short [3][ ];<br />
a<br />
null null null<br />
a[2].targa<br />
heap<br />
Introduzione al linguaggio Java 97<br />
Introduzione al linguaggio Java 98<br />
STRUTTURE DI CONTROLLO:<br />
SINTESI<br />
STRUTTURE DI CONTROLLO<br />
Sequenza<br />
Selezione<br />
Iterazione<br />
if<br />
switch<br />
for<br />
while<br />
do-while<br />
Salto break uscita da un blocco<br />
continue continua un loop<br />
return da un metodo<br />
Gestione ecce- try-catchzioni<br />
finally-throw<br />
Non c’è goto!<br />
Introduzione al linguaggio Java 99<br />
Introduzione al linguaggio Java 100<br />
boolean,<br />
non integer!<br />
SINTASSI<br />
if ( con<strong>di</strong>tion ) switch ( intexpr ) {<br />
statement;<br />
case intexpr : statement;<br />
[else<br />
[case intexpr : statement;<br />
statement; ] ...<br />
default : statement; ]<br />
}<br />
while ( con<strong>di</strong>tion )<br />
statement;<br />
for ( init; con<strong>di</strong>tion; increment )<br />
do<br />
statement;<br />
statement;<br />
while ( con<strong>di</strong>tion );<br />
• break [label];<br />
• continue [label];<br />
• return expr;<br />
• label: statement<br />
USCITE<br />
Introduzione al linguaggio Java 101<br />
Introduzione al linguaggio Java 102<br />
Introduzione al linguaggio Java 17<br />
17
ESEMPIO<br />
GESTIONE ECCEZIONI<br />
label: for (i =0 , j=0 ; i
DICHIARAZIONE DI CLASSI<br />
CLASSI<br />
[Doc comment] [Mo<strong>di</strong>fiers] class ClassName<br />
[ extends SuperClassName]<br />
[ implements InterfaceName [, InterfaceName] ...]<br />
{ClassBody}<br />
Doc comment commento <strong>di</strong> documentazione<br />
Mo<strong>di</strong>fiers abstract, final, public, ...<br />
extends<br />
la classe è sottoclasse <strong>di</strong> un'altra<br />
implements la classe realizza una o più interfacce<br />
ClassBody<br />
i campi e i meto<strong>di</strong> della classe<br />
Introduzione al linguaggio Java 109<br />
Introduzione al linguaggio Java 110<br />
ESEMPIO<br />
DICHIARAZIONE DI CAMPI<br />
Dichiarazione <strong>di</strong> una classe MyClass<br />
public class MyClass {<br />
int i; /* campo */<br />
public void Add_to_i (int j) { /* metodo */<br />
i = i+j;<br />
}<br />
public MyClass () {<br />
/* metodo costruttore: ha lo<br />
i = 10; stesso nome della classe */<br />
}<br />
}<br />
Creazione e uso <strong>di</strong> una istanza <strong>di</strong> MyClass<br />
MyClass mc; /* <strong>di</strong>chiarazione, non creazione */<br />
mc = new MyClass(); /* creazione: l'attributo i vale 10 */<br />
mc.i++; /* ora i vale 11 */<br />
mc.Add_to_i(10); /* e ora i vale 21 */<br />
Esempio:<br />
Doc comment<br />
Mo<strong>di</strong>fiers<br />
Type<br />
VariableDeclarator<br />
[DocComment] [Mo<strong>di</strong>fiers] Type<br />
VariableDeclarator [,VariableDeclarator]… ;<br />
static int i = 5, j = 7, a[];<br />
commento <strong>di</strong> documentazione<br />
static, public, protected,private,<br />
final, ...<br />
tipo (primitivo o reference)<br />
identificatore (anche <strong>di</strong> array), con<br />
eventuale inizializzazione<br />
Introduzione al linguaggio Java 111<br />
Introduzione al linguaggio Java 112<br />
DICHIARAZIONE DI METODI<br />
ESEMPIO<br />
[Doc comment] [Mo<strong>di</strong>fiers] ReturnType MethodName (ParameterList)<br />
[throws ClassType [,ClassType] … ] {<br />
MethodBody<br />
}<br />
Doc comment<br />
Mo<strong>di</strong>fiers<br />
ReturnType<br />
ParameterList<br />
commento <strong>di</strong> documentazione<br />
static, public,protected,private, abstract,<br />
final,native, ...<br />
può essere un tipo primitivo o reference, o<br />
void (nessun valore <strong>di</strong> ritorno). Deve essere<br />
sempre specificato (ma non per i costruttori)<br />
un metodo ha sempre un numero fisso <strong>di</strong><br />
argomenti (ma è possibile l’ overloa<strong>di</strong>ng)<br />
int base;<br />
public int power (int n) {<br />
int i, p;<br />
p=1;<br />
for (i=1; i
IL MODIFICATORE static<br />
ESEMPIO<br />
• Campi e meto<strong>di</strong> <strong>di</strong>chiarati static, sono associati alla classe e<br />
non a una particolare istanza<br />
class MyClass {<br />
static int a;<br />
…<br />
static void MyMethod() {<br />
a = a+1;<br />
}<br />
}<br />
• Pertanto: esiste una sola copia <strong>di</strong> un campo statico, con<strong>di</strong>viso da<br />
tutte le istanze della classe; non occorre istanziare un oggetto<br />
per usare un membro statico; meto<strong>di</strong> statici possono accedere<br />
solo a membri statici della classe<br />
• Sono qualificati con il nome della classe, e non della istanza<br />
MyClass.a =MyClass.a + 1;<br />
Introduzione al linguaggio Java 115<br />
class Safe {<br />
static int LastSerialNumber;<br />
Il costruttore Safe fa sì che<br />
public int SerialNumber;<br />
ogni istanza <strong>di</strong> Safe abbia un<br />
int SetCombination;<br />
SerialNumber unico<br />
….<br />
Safe(int Combination) {<br />
SerialNumber = LastSerialNumber++;<br />
SetCombination = Combination;<br />
}<br />
public static StartNewSeriesFrom (int Start) {<br />
LastSerialNumber = Start;<br />
}<br />
}<br />
….<br />
Safe.LastSerialNumber(100000); /* inizializza il numero <strong>di</strong> serie */<br />
Safe MySafe = new Safe(23456); /* crea una Safe <strong>di</strong> SerialNumber = 100001<br />
e combinazione 23456 */<br />
… MySafe.SerialNumber ….<br />
Introduzione al linguaggio Java 116<br />
VARIABILI LOCALI<br />
LA KEYWORD this<br />
• Le variabili locali a un metodo:<br />
– sono visibili solo dal corpo del metodo<br />
– vengono allocate (nello stack <strong>di</strong> run-time) alla chiamata e deallocate<br />
all’uscita del metodo<br />
– non vengono inizializzate automaticamente (<strong>di</strong>versamente dai<br />
campi <strong>di</strong> una classe)<br />
• Non si può accedere a una variabile a cui non si sia<br />
prima assegnato un valore (e viene segnalato in<br />
compilazione !)<br />
Esempio: int i;<br />
if ( cond ) { i = 55; … }<br />
i++; /* compile-time error */<br />
• Se una variabile locale ha lo stesso nome <strong>di</strong> un membro della<br />
sua classe, questo risulta invisibile (“shadowing”) …<br />
• … a meno <strong>di</strong> usare la keyword this, che denota l’oggetto<br />
corrente<br />
Esempio: class MyClass {<br />
int x, y, z; /* membri */<br />
void MyMethod (int x) { /* parametro */<br />
int y; /* variabile locale */<br />
y=x+1;<br />
/* y è la variabile locale,<br />
x è il parametro */<br />
z=this.x; /* this.x è il membro x */<br />
…<br />
}<br />
NB: Poichè this denota un oggetto, non si può usare con membri <strong>di</strong>chiarati static<br />
Introduzione al linguaggio Java 117<br />
Introduzione al linguaggio Java 118<br />
PASSAGGIO DI PARAMETRI<br />
A UN METODO<br />
COSTRUTTORI<br />
• Tutti i tipi primitivi sono passati per valore<br />
• Anche i riferimenti a oggetti <strong>di</strong> tipo reference sono<br />
passati per valore<br />
Es: int i;<br />
SomeObject obj = new SomeObject();<br />
i<br />
obj<br />
MyMethod( i, obj );<br />
….<br />
Void MyMethod (int j, SomeObject o) {<br />
j o<br />
j = j+1; /* non altera i, passato per valore */<br />
o = null; /* non altera obj, che si riferisce ancora<br />
all’oggetto */<br />
}<br />
heap<br />
• Sono meto<strong>di</strong> che vengono chiamati quando si crea<br />
una istanza <strong>di</strong> una classe; non ritornano alcun valore<br />
• Se non definisco alcun costruttore, per default viene<br />
fornito il costruttore vuoto:<br />
class MyClass {<br />
…<br />
MyClass() { }<br />
}<br />
• Possono essere overloaded; non ha senso che siano<br />
static<br />
Introduzione al linguaggio Java 119<br />
Introduzione al linguaggio Java 120<br />
Introduzione al linguaggio Java 20<br />
20
ESEMPIO: OVERLOADING<br />
DISTRUZIONE DI OGGETTI<br />
Dichiarazione <strong>di</strong> una classe MyNewClass<br />
public class MyNewClass {<br />
int i;<br />
public MyNewClass () {<br />
i = 10;<br />
}<br />
publicMyNewClass(intj) {<br />
i = j;<br />
} .....<br />
Overloa<strong>di</strong>ng: meto<strong>di</strong> omonimi devono essere<br />
<strong>di</strong>stinguibili per la quantità e/o per il tipo degli<br />
argomenti<br />
}<br />
Creazione <strong>di</strong> una istanza <strong>di</strong> MyNewClass<br />
MyNewClass mc0, mc1; /* <strong>di</strong>chiarazione, non creazione */<br />
mc0 = new MyNewClass(); /* creazione: l'attributo i vale 10 */<br />
mc0.i++; /* ora i vale 11 */<br />
mc1= new MyNewClass(20); /* creazione: l'attributo i vale 20 */<br />
mc1.i++; /* ora i vale 21 */<br />
Introduzione al linguaggio Java 121<br />
• Java non supporta <strong>di</strong>struttori <strong>di</strong> oggetti: gli oggetti non<br />
possono essere <strong>di</strong>strutti esplicitamente<br />
• Un oggetto privo <strong>di</strong> riferimenti incidenti non è più<br />
accessibile, e la memoria che esso occupa può<br />
essere "riciclata" dal garbage collector, che opera in<br />
un thread in<strong>di</strong>pendente a bassa priorità<br />
String s; /* <strong>di</strong>chiarazione, non creazione */<br />
s = new String ("abc"); /* creazione: s punta a "abc" */<br />
s = "def"; /* "abc" non è più puntata da s */<br />
Introduzione al linguaggio Java 122<br />
FINALIZZATORI DI OGGETTI<br />
IL MODIFICATORE native<br />
• Un oggetto "riciclabile" (cioè privo <strong>di</strong> puntatori<br />
incidenti) potrebbe trovarsi in uno stato poco "pulito"<br />
(ad es. potrebbe aver aperto dei file che non sono<br />
stati ancora chiusi)<br />
• Prima <strong>di</strong> riciclarlo, il garbage collector invoca il<br />
metodo finalize dell’oggetto, es.:<br />
protected void finalize () throws Throwable {<br />
...<br />
super.finalize(); /* meglio metterlo sempre */<br />
}<br />
• Il metodo finalize esiste sempre: se non è stato<br />
definito, viene ere<strong>di</strong>tato da Object;<br />
• Un metodo è <strong>di</strong>chiarato native quando il suo co<strong>di</strong>ce è<br />
<strong>di</strong>pendente dalla piattaforma (ad esempio, è scritto in<br />
un altro linguaggio)<br />
Esempio:<br />
public native void seek(long pos) throws IOException ;<br />
non deve essere<br />
specificato il body<br />
Introduzione al linguaggio Java 123<br />
Introduzione al linguaggio Java 124<br />
SOTTOCLASSI<br />
EREDITARIETA’<br />
• In Java, una classe può estendere una sola altra<br />
classe (ere<strong>di</strong>tarietà singola)<br />
• Una sottoclasse ere<strong>di</strong>ta i campi e i meto<strong>di</strong> della sua<br />
superclasse che non siano <strong>di</strong>chiarati private e che<br />
non siano costruttori, e li può usare come se fossero<br />
<strong>di</strong>chiarati al suo interno<br />
• Un oggetto <strong>di</strong> una sottoclasse può essere usato<br />
ovunque può essere usato un oggetto della sua<br />
superclasse<br />
Introduzione al linguaggio Java 125<br />
Introduzione al linguaggio Java 126<br />
Introduzione al linguaggio Java 21<br />
21
ESEMPIO<br />
“COME”<br />
ESTENDERE UNA CLASSE<br />
class Animale {<br />
float Peso;<br />
…<br />
void Mangia () { … }<br />
…<br />
}<br />
class Mammifero extends Animale {<br />
int BattitoCar<strong>di</strong>aco;<br />
// ere<strong>di</strong>ta Peso<br />
…<br />
void Respira() { … }<br />
// ere<strong>di</strong>ta mangia<br />
…<br />
}<br />
class Gatto extends Mammifero {<br />
// ere<strong>di</strong>ta BattitoCar<strong>di</strong>aco, Peso, Mangia, Respira<br />
void FaLeFusa() { … }<br />
}<br />
Gatto Fufi = new Gatto();<br />
Animale creatura = Fufi;<br />
lecito, perchè “gatto”<br />
è una sottoclasse<br />
<strong>di</strong> “animale”<br />
• Attenzione alla <strong>di</strong>fferenza fra la relazione “è un”e la<br />
relazione “ha un” : solo la prima può definire una<br />
sottoclasse<br />
Esempio:<br />
Un cerchio può essere definito me<strong>di</strong>ante il suo centro e il suo<br />
raggio, ma sarebbe scorretto definire una classe cerchio come<br />
sottoclasse <strong>di</strong> punto:<br />
class punto { class cerchio extends punto {<br />
double x; int y; double raggio;<br />
… ...<br />
} }<br />
Introduzione al linguaggio Java 127<br />
Introduzione al linguaggio Java 128<br />
SHADOWING E OVERRIDING<br />
POLIMORFISMO<br />
• shadowing<br />
• overri<strong>di</strong>ng<br />
un campo <strong>di</strong> una sottoclasse può “nascondere”<br />
un campo omonimo <strong>di</strong> una sua<br />
superclasse<br />
un metodo <strong>di</strong> una sottoclasse può “sovrascrivere”<br />
un metodo <strong>di</strong> ugual “segnatura”<br />
e ugual ReturnType <strong>di</strong> una sua superclasse<br />
Esempio: class SuperClass {<br />
nasconde<br />
int i;<br />
sovrascrive<br />
void m(int k) {…}<br />
… }<br />
class Subclass extends Superclass {<br />
long i:<br />
void m(int n) {…}<br />
… }<br />
class Animale {<br />
…<br />
void Mangia () { … }<br />
…<br />
}<br />
class Mammifero extends Animale {<br />
…<br />
}<br />
class Gatto extends Mammifero {<br />
…<br />
void Mangia() { … }<br />
...<br />
}<br />
Gatto Fufi = new Gatto();<br />
Animale creatura =Fufi;<br />
creatura.Mangia();<br />
viene eseguito il metodo<br />
Mangia della classe Gatto!<br />
(bin<strong>di</strong>ng <strong>di</strong>namico: il metodo<br />
da chiamare viene selezionato<br />
a run-time)<br />
Introduzione al linguaggio Java 129<br />
Introduzione al linguaggio Java 130<br />
LA KEYWORD super<br />
CASTING<br />
• per denotare un membro nascosto (campo shadowed<br />
o metodo overridden non static), si può usare la<br />
keyword super<br />
Esempio: class SuperClass {<br />
int i;<br />
…<br />
}<br />
class Subclass extends SuperClass {<br />
long i:<br />
…<br />
i = super.i +1;<br />
…<br />
}<br />
Gatto Fufi = new Gatto();<br />
Animale creatura;<br />
...<br />
creatura = Fufi; /* ok */<br />
Fufi = creatura;<br />
/* errore <strong>di</strong> compilazione:<br />
tipi incompatibili */<br />
Fufi = (Gatto)creatura; /* ok, ma solo perchè<br />
creatura è un gatto: se<br />
non lo fosse, il controllo a<br />
run-time segnalrebbe una<br />
eccezione */<br />
Introduzione al linguaggio Java 131<br />
Introduzione al linguaggio Java 132<br />
Introduzione al linguaggio Java 22<br />
22
COSTRUTTORI NELLE<br />
SOTTOCLASSI<br />
IL MODIFICATORE abstract<br />
Nel costruttore <strong>di</strong> una sottoclasse, è corretto,<br />
come prima cosa, chiamare il costruttore della<br />
superclasse<br />
Esempio:<br />
class SubClass extends SuperClass {<br />
SubClass() {<br />
super();<br />
<br />
}<br />
}<br />
• Una classe è <strong>di</strong>chiarata abstract quando contiene<br />
almeno un metodo abstract (cioè senza body)<br />
• Una classe abstract non può essere instanziata:<br />
occorre sovrascrivere tutti i meto<strong>di</strong> abstract<br />
in una sottoclasse, e istanziare la sottoclasse<br />
Esempio: abstract class a {<br />
…<br />
abstract int m(int k);<br />
}<br />
class b extends a {<br />
...<br />
int m(int n) { … }<br />
}<br />
sovrascrive, fornendo<br />
la implementazione del<br />
metodo<br />
Introduzione al linguaggio Java 133<br />
Introduzione al linguaggio Java 134<br />
IL MODIFICATORE final<br />
METODI final: ESEMPIO<br />
final ha tre significati <strong>di</strong>versi:<br />
• campo final<br />
• metodo final<br />
• classe final<br />
non può essere mo<strong>di</strong>ficato: è un<br />
campo costante (deve essere<br />
inizializzato)<br />
Esempio: final int i = 5;<br />
non può essere sovrascritto<br />
non può avere sottoclassi (quin<strong>di</strong> i<br />
suoi meto<strong>di</strong> sono implicitamente<br />
final)<br />
class Password {<br />
private int passwd;<br />
final boolean validatePassword(String s) {<br />
…..<br />
}<br />
...<br />
}<br />
se non fosse final ,<br />
potrebbe essere sovrascritto !<br />
Introduzione al linguaggio Java 135<br />
Introduzione al linguaggio Java 136<br />
INTERFACCE<br />
INTERFACCE<br />
Una interface è una struttura sintattica dotata <strong>di</strong><br />
nome, che racchiude la specifica della segnatura<br />
e del ReturnType dei meto<strong>di</strong> <strong>di</strong> una classe non<br />
ancora implementata<br />
Esempio: interface Driveable {<br />
boolean startEngine();<br />
void stopEngine();<br />
float accelerate(float acc);<br />
boolean turn(Direction <strong>di</strong>r);<br />
}<br />
Introduzione al linguaggio Java 137<br />
Introduzione al linguaggio Java 138<br />
Introduzione al linguaggio Java 23<br />
23
IMPLEMENTAZIONE DI UNA<br />
INTERFACCIA<br />
Una interfaccia può essere implementata da una<br />
(o più) classi:<br />
interface Driveable {<br />
boolean startEngine();<br />
...<br />
}<br />
interface Automobile implements Driveable {<br />
boolean startEngine() { ... } // una particolare implementazione<br />
….<br />
}<br />
interface Motorcycle implements Driveable {<br />
boolean startEngine() { ... } // un’altra implementazione<br />
….<br />
}<br />
Esempio:<br />
Driveable vehicle;<br />
POLIMORFISMO<br />
/* variabile <strong>di</strong> tipo interfaccia; le possiamo<br />
assegnare qualunque oggetto <strong>di</strong> una classe<br />
che implementa l’interfaccia */<br />
Automobile auto = new Automobile();<br />
Motorcycle moto = new Motorcycle();<br />
...<br />
vehicle = auto;<br />
vehicle.startEngine(); /* polimorfismo: è il metodo <strong>di</strong> Automobile */<br />
…<br />
vehicle = moto;<br />
vehicle.startEngine(); /* polimorfismo: è il metodo <strong>di</strong> Motorcycle */<br />
Introduzione al linguaggio Java 139<br />
Introduzione al linguaggio Java 140<br />
EREDITARIETA’ MULTIPLA<br />
SUPERINTERFACCE<br />
Una classe può implementare più <strong>di</strong> una interfaccia<br />
interface Driveable { interface Rentable {<br />
void startEngine();<br />
void startRental();<br />
void stopEngine();<br />
void endRental();<br />
float accelerate(float acc);<br />
int book(Date start, Date end);<br />
boolean turn(Direction <strong>di</strong>r); }<br />
}<br />
• Una interfaccia può estendere una o più altre<br />
interfacce, es.:<br />
interface a extends b, c, d {<br />
….<br />
}<br />
class AvisCar implements Driveable, Rentable {<br />
void startEngine() { … }<br />
void startRental() { … }<br />
…<br />
}<br />
• Ogni classe che implementa un’interfaccia deve<br />
estendere anche tutte le sue superinterfacce<br />
Introduzione al linguaggio Java 141<br />
Introduzione al linguaggio Java 142<br />
INTERFACCE vs CLASSI abstract<br />
• Le interfacce sono simili a classi che abbiano<br />
soltanto:<br />
– meto<strong>di</strong> abstract<br />
– campi static e final (cioè costanti)<br />
• A <strong>di</strong>fferenza delle classi, le interfacce permettono<br />
<strong>di</strong> realizzare una forma <strong>di</strong> ere<strong>di</strong>tarietà multipla<br />
PACKAGES<br />
Introduzione al linguaggio Java 143<br />
Introduzione al linguaggio Java 144<br />
Introduzione al linguaggio Java 24<br />
24
PACKAGES<br />
• Più classi o interfacce interrelate possono essere<br />
riunite in un package, dotato <strong>di</strong> nome<br />
Esempio:<br />
MyPackage<br />
classe o<br />
interfaccia<br />
NOMI DI CLASSI<br />
• Il nome <strong>di</strong> una classe (o <strong>di</strong> una interfaccia) va<br />
sempre qualificato con il nome del package a cui<br />
appartiene, tranne quando viene usato all’interno<br />
dello stesso package<br />
a<br />
b<br />
c<br />
Esempio:<br />
aaa.bbb.ccc.MyClass<br />
d<br />
e<br />
all’interno <strong>di</strong> aaa.bbb.ccc basta questo<br />
Introduzione al linguaggio Java 145<br />
Introduzione al linguaggio Java 146<br />
NOMI DI PACKAGE<br />
PACKAGES STANDARD<br />
• Il nome <strong>di</strong> un package può essere composto da<br />
più identificatori separati da “.”:<br />
roberto.utilities.internet<br />
• Per evitare che package <strong>di</strong> produttori <strong>di</strong>versi<br />
abbiano lo stesso nome, si suggerisce <strong>di</strong> far<br />
iniziare il nome del package con il dominio<br />
Internet del produttore (invertito, e con il nome <strong>di</strong><br />
più alto livello tutto maiuscolo):<br />
IT.unimi.dsi.roberto.utilities.internet<br />
nome <strong>di</strong> dominio<br />
java.lang<br />
java.io<br />
java.util<br />
java.net<br />
java.applet<br />
java.awt<br />
classi base del linguaggio<br />
(Object, Thread, Throwable, System, String,<br />
Math, wrapper classes, …)<br />
classi <strong>di</strong> I/O<br />
(FileInputStream, FileOutputStream, )<br />
classi <strong>di</strong> utilità<br />
(Date, Random, …)<br />
classi <strong>di</strong> supporto alle applicazioni <strong>di</strong><br />
rete (socket, URL, …)<br />
classe Applet, …<br />
Abstract Windowing Toolkit<br />
Introduzione al linguaggio Java 147<br />
Introduzione al linguaggio Java 148<br />
LO STATEMENT package<br />
LO STATEMENT import<br />
• Specifica che le classi che seguono appartengono<br />
a un certo package<br />
• Deve apparire (una sola volta) all’inizio <strong>di</strong> una<br />
unità <strong>di</strong> compilazione<br />
Esempio:<br />
a.java<br />
package p;<br />
class a {..<br />
le classi a,b,c appartengono<br />
al package p<br />
• Per evitare <strong>di</strong> usare sempre nomi completi <strong>di</strong><br />
classi, si può usare lo statement import<br />
Esempio:<br />
import java.util.Date;<br />
class MyClass { class MyClass {<br />
java.util.Date today;<br />
Date today;<br />
… ...<br />
} }<br />
class b {...<br />
class c {..<br />
Se lo statement è omesso,<br />
la classe appartiene al<br />
package anonimo<br />
Note:<br />
• import java.util.* importa tutte le classi del package java.util<br />
• java.lang.* è sempre importato implicitamente<br />
Introduzione al linguaggio Java 149<br />
Introduzione al linguaggio Java 150<br />
Introduzione al linguaggio Java 25<br />
25
PACKAGE E DIRECTORY<br />
CLASS PATH<br />
• Molti ambienti Java mappano i nomi dei package<br />
sui pathname del file system (compilatore e class<br />
loader)<br />
• Per in<strong>di</strong>care al class loader da quale <strong>di</strong>rectory<br />
partire per la mappatura può essere usata la<br />
variabile <strong>di</strong> ambiente CLASSPATH<br />
Esempio:<br />
aaa.bbb.ccc.MyClass<br />
aaa/bbb/ccc/MyClass<br />
Esempio (Unix):<br />
setenv CLASSPATH /classi : /usr/roberto/classi : .<br />
package classe <strong>di</strong>rectories file<br />
java.lang.Math<br />
/java.lang.Math.class<br />
pathname<br />
nome completo della classe<br />
pathname assoluto<br />
Introduzione al linguaggio Java 151<br />
Introduzione al linguaggio Java 152<br />
VISIBILITA’<br />
VISIBILITA’ DI CAMPI E METODI<br />
Classi e interfacce<br />
• sono visibili all’interno del package in cui sono<br />
<strong>di</strong>chiarate; sono visibili all’esterno del package solo<br />
se <strong>di</strong>chiarate public<br />
public class a { …<br />
public interface b { …<br />
più visibile<br />
Mo<strong>di</strong>ficatore<br />
private<br />
nessuno (default)<br />
protected<br />
public<br />
Visibilità<br />
solo nella classe in cui è definito<br />
solo nelle classi del package<br />
classi nel package e sottoclassi<br />
(stesso package o altri package)<br />
tutte le classi<br />
Membri (campi e meto<strong>di</strong>)<br />
• sono visibili quando:<br />
– la loro classe è visibile e<br />
– il loro mo<strong>di</strong>ficatore li rende visibili<br />
NB: I membri <strong>di</strong> una interfaccia sono sempre pubblici<br />
Introduzione al linguaggio Java 153<br />
Introduzione al linguaggio Java 154<br />
ESEMPIO<br />
PROGETTARE LA VISIBILITA’<br />
package pac<br />
class a {...<br />
class b {<br />
private int i;<br />
private void m( ) {…}<br />
int j;<br />
visibile<br />
void n( ) {…}<br />
public int k;<br />
public p( ){…}<br />
protected int i;<br />
protected void m( ){…}<br />
class c {...<br />
Quando progettiamo una classe dobbiamo pensare<br />
a due tipi <strong>di</strong> utenti:<br />
• quelli che utilizzeranno la classe per realizzare<br />
delle applicazioni<br />
• quelli che estenderanno la classe per realizzare<br />
sottoclassi<br />
class d extends b {...<br />
class e extends d {...<br />
• I primi useranno i membri public; i secon<strong>di</strong> anche i<br />
membri protected<br />
• Le interfacce public e protected vanno progettate<br />
con cura<br />
Introduzione al linguaggio Java 155<br />
Introduzione al linguaggio Java 156<br />
Introduzione al linguaggio Java 26<br />
26
DUE TIPI DI UTENTI<br />
PACKAGES: RIASSUNTO<br />
USA<br />
class a {<br />
private int i;<br />
private void m( ) {…}<br />
int j;<br />
void n( ) {…}<br />
public int k;<br />
public p( ){…}<br />
protected int i;<br />
protected void m( ){…}<br />
package pac<br />
ESTENDE<br />
I packages:<br />
• permettono <strong>di</strong> creare gruppi <strong>di</strong> classi e interfacce<br />
fra loro in relazione<br />
• definiscono uno spazio <strong>di</strong> nomi locale per classi e<br />
interfacce evitando conflitti con classi e interfacce<br />
<strong>di</strong> altri packages<br />
• permettono <strong>di</strong> avere classi, interfacce e membri<br />
(campi e meto<strong>di</strong>) non visibili all’esterno del<br />
package<br />
• possono essere organizzati gerarchicamente<br />
interfaccia<br />
interfaccia<br />
Introduzione al linguaggio Java 157<br />
Introduzione al linguaggio Java 158<br />
UNITA’ DI COMPILAZIONE:<br />
RIASSUNTO<br />
MyClass.java<br />
package Roberto.util; /* opzionale */<br />
import java.util.* ; /* opzionale */<br />
public class MyClass {<br />
…<br />
}<br />
class MyOtherClass { /* opzionale */<br />
…<br />
}<br />
interface MyInterface { /* opzionale */<br />
…<br />
}<br />
STRUTTURA DI UN’APPLICAZIONE<br />
Introduzione al linguaggio Java 159<br />
Introduzione al linguaggio Java 160<br />
STRUTTURA DI<br />
UN’APPLICAZIONE<br />
• Affinchè un sistema a oggetti “parta”, devo avere<br />
una classe con un metodo statico e pubblico <strong>di</strong><br />
nome main<br />
main<br />
a<br />
g<br />
b<br />
c<br />
f<br />
d<br />
e<br />
Hello.java<br />
HELLO WORLD<br />
class Hello {<br />
public static void main (String args []) {<br />
System.out.println("Hello World!");<br />
}<br />
}<br />
obbligatorio in questa forma<br />
Introduzione al linguaggio Java 161<br />
Introduzione al linguaggio Java 162<br />
Introduzione al linguaggio Java 27<br />
27
SPIEGAZIONI<br />
public static void main (String args [])<br />
– void in<strong>di</strong>ca che main non ritorna nulla, il che è necessario per<br />
superare il type-checking del compilatore<br />
– args[] sono gli argomenti passati a main dalla shell quando si<br />
<strong>di</strong>gita: java Hello arg1 arg2 ... argn<br />
– String <strong>di</strong>ce che gli argomenti sono <strong>di</strong> classe String<br />
– public rende il metodo main visibile alle altre classi - e al<br />
comando java (interprete)<br />
– static associa main alla classe Hello, e non alle sue istanze<br />
UNITA’ DI COMPILAZIONE<br />
• Il sorgente <strong>di</strong> un’applicazione consiste <strong>di</strong> uno o più file<br />
(“unità <strong>di</strong> compilazione”)<br />
• Ogni file contiene una o più <strong>di</strong>chiarazioni <strong>di</strong> classi (o <strong>di</strong><br />
interfacce), <strong>di</strong> cui al più una <strong>di</strong>chiarata public<br />
• Il nome del file deve essere uguale a quello della sua classe<br />
public , con estensione .java:<br />
file a.java<br />
public class a {...<br />
stesso nome<br />
System.out.println("HelloWorld!")<br />
– invoca il metodo println dell’oggetto out della classe System,<br />
che stampa la stringa sul file stdout<br />
class b {...<br />
class c {..<br />
Introduzione al linguaggio Java 163<br />
Introduzione al linguaggio Java 164<br />
COMPILAZIONE ED ESECUZIONE<br />
COMPILAZIONE ED ESECUZIONE<br />
a.java<br />
public class a {…<br />
public main (..)<br />
{….<br />
class b {…<br />
…uso <strong>di</strong> c...<br />
javac a.java<br />
a.class<br />
<br />
b.class<br />
<br />
java a args<br />
La classe a deve<br />
contenere un metodo<br />
pubblico e statico <strong>di</strong><br />
nome main<br />
Verificare le le caratteristiche<br />
del sistema <strong>di</strong> <strong>di</strong> programmazione<br />
utilizzato<br />
c.class<br />
<br />
il compilatore crea<br />
file <strong>di</strong> nome<br />
classname.class<br />
classe c, usata da<br />
b, compilata in<br />
precedenza<br />
Introduzione al linguaggio Java 165<br />
Introduzione al linguaggio Java 166<br />
Introduzione al linguaggio Java 28<br />
28
La programmazione orientata agli oggetti in Java<br />
Cosa identifica la OOP<br />
Oggetti e classi : identità, stato, classe, creazione, meto<strong>di</strong> che osservano e che mo<strong>di</strong>ficano, notazione punto<br />
Information hi<strong>di</strong>ng : ruolo e modalità <strong>di</strong> occultamento<br />
Ere<strong>di</strong>tarietà : cosa si ere<strong>di</strong>ta ere<strong>di</strong>tarietà semplice e multipla<br />
Polimorfismo : quale perché è così importante classi astratte, definizione e ridefinizione <strong>di</strong> meto<strong>di</strong><br />
Genericità : classi generiche, downcasting, genericità vincolata<br />
Aspetti avanzati : copia e uguaglianza, asserzioni, eccezioni, contenitori e iteratori,<br />
<strong>di</strong>struttori, persistenza<br />
1. Cosa identifica la OOP <br />
L'acronimo OOP in informatica sta per Object Oriented Programming (Programmazione Orientata<br />
agli Oggetti) e vuole denotare l'insieme delle caratteristiche a fondamento del para<strong>di</strong>gma della<br />
programmazione ad oggetti. Storicamente, le prime idee fondanti <strong>di</strong> questo para<strong>di</strong>gma sono sorte<br />
con il Simula '67, un linguaggio <strong>di</strong> simulazione <strong>di</strong>screta <strong>di</strong> scuola scan<strong>di</strong>nava, e sono state poi<br />
riscoperte negli USA negli anni '70-'80 con il linguaggio Smalltalk. Buona parte del gergo della<br />
OOP si deve a questi due linguaggi.<br />
Dalla metà degli anni '80 esiste un generale accordo sulle caratteristiche che devono essere presenti<br />
in un linguaggio per poterlo classificare come OOPL, cioè per affermare che mette a <strong>di</strong>sposizione il<br />
para<strong>di</strong>gma della OOP:<br />
1. insieme <strong>di</strong> operazioni astratte, associate ad un tipo<br />
2. stato locale<br />
3. ere<strong>di</strong>tarietà<br />
La prima caratteristica, spesso associata all'acronimo ADT (Abstract Data Type), stabilisce che<br />
l'unico modo per agire sugli oggetti <strong>di</strong> un certo tipo è quello <strong>di</strong> invocare delle operazioni (nel gergo<br />
OOP chiamate meto<strong>di</strong>) prestabilite e note agli utenti in modo astratto, cioè in<strong>di</strong>pendente dalla<br />
rappresentazione prescelta per la loro concreta implementazione (realizzazione).<br />
La seconda caratteristica stabilisce che ogni oggetto ha un proprio stato locale che può cambiare<br />
per effetto dell'esecuzione <strong>di</strong> alcuni meto<strong>di</strong>. In pratica il valore dello stato locale ad un certo istante<br />
è stabilito dal contenuto <strong>di</strong> un insieme <strong>di</strong> celle <strong>di</strong> memoria associate all'oggetto, dette campi o<br />
attributi dell'oggetto.<br />
L'ere<strong>di</strong>tarietà stabilisce infine che il linguaggio deve prevedere un meccanismo per stabilire delle<br />
relazioni IS-A ("è-un") tra classi <strong>di</strong> oggetti. Questo meccanismo consente in definitiva il riuso e il<br />
polimorfismo, due dei principali fattori alla base del successo della OOP.<br />
1
2. Oggetti e classi<br />
Un oggetto (software) è un'entità dotata <strong>di</strong>:<br />
• identità, che permette sempre <strong>di</strong> <strong>di</strong>stinguere un oggetto da un altro (un "numero <strong>di</strong> serie")<br />
• stato, quin<strong>di</strong> in grado <strong>di</strong> "ricordare" qualcosa<br />
• comportamento, che si traduce nella possibilità <strong>di</strong> osservare (in tutto o in parte) lo stato e/o<br />
<strong>di</strong> mo<strong>di</strong>ficare lo stato, tramite l'invocazione dei meto<strong>di</strong> sull'oggetto.<br />
Le metafore più pertinenti per gli oggetti della programmazione sono probabilmente le<br />
apparecchiature <strong>di</strong> tipo elettrico/elettronico riportando un numero <strong>di</strong> serie (l'identità), avendo<br />
degli in<strong>di</strong>catori <strong>di</strong> vario genere che descrivono (parte) dello stato interno ed esibendo dei<br />
comportamenti, in seguito all'azionamento <strong>di</strong> alcune leve, pulsanti, ecc.<br />
Un modo corretto <strong>di</strong> pensare ad un oggetto è rappresentato nella seguente figura:<br />
I blocchi P1, P2, ... ed F1, F2, ... rappresentano i "meccanismi interni" dell'oggetto: in pratica<br />
sono dei sottoprogrammi (i meto<strong>di</strong>) che realizzano le operazioni previste dall'oggetto. Seguendo<br />
una metodologia <strong>di</strong> progetto ampiamente con<strong>di</strong>visa i meto<strong>di</strong> vengono spesso <strong>di</strong>visi in in due<br />
categorie:<br />
• coman<strong>di</strong>, cioè meto<strong>di</strong> che mo<strong>di</strong>ficano lo stato dell'oggetto. Sono procedure proprie, cioè<br />
che non restituiscono valori ma che producono degli effetti collaterali, generalmente limitati<br />
allo stato locale dell'oggetto.<br />
• osservatori ( queries), cioè meto<strong>di</strong> che si limitano ad osservare lo stato dell'oggetto. Sono<br />
procedure <strong>di</strong> tipo funzionale che restituiscono un valore ottenuto come elaborazione<br />
(solitamente molto semplice) dello stato corrente dell'oggetto.<br />
2
Questa separazione, anche se può comportare qualche inefficienza, favorisce in genere la leggibilità<br />
e la trasparenza referenziale del co<strong>di</strong>ce.<br />
Per creare gli oggetti la tecnica più seguita è quella <strong>di</strong> definire prima una classe, cioè uno schema<br />
<strong>di</strong> creazione che definisca i possibili stati e i comportamenti, e <strong>di</strong> invocare un'operazione <strong>di</strong><br />
istanziazione della classe, detta costruttore o creatore, che determina univocamente l'identità <strong>di</strong> un<br />
oggetto e che ne stabilisce lo stato iniziale. Una possibile sintassi <strong>di</strong> creazione potrebbe essere:<br />
variabile nuovo [ nome_costruttore ( parametri_attuali_se_previsti ) ]<br />
In pratica una classe sarà definita da un nome a cui viene associato un elenco <strong>di</strong> costruttori,<br />
attributi e meto<strong>di</strong>, che collettivamente chiameremo proprietà della classe. Nei linguaggi OOP<br />
tipizzati, la definizione <strong>di</strong> una classe comporta generalmente anche quella <strong>di</strong> un tipo con lo stesso<br />
nome. Si ammette che dall'elenco possano mancare i costruttori: in tal caso viene usato<br />
implicitamente un costruttore <strong>di</strong> default (senza parametri).<br />
Per accedere al valore <strong>di</strong> un attributo o per invocare un metodo su un oggetto la maggior parte dei<br />
linguaggi fa uso della notazione punto:<br />
espressione_oggetto.nome_attributo<br />
espressione_oggetto.nome_metodo( eventuali_parametri_attuali_se_previsti )<br />
3
Esercizio 1<br />
Realizzare una classe che permetta <strong>di</strong><br />
effettuare le operazioni <strong>di</strong> somma e<br />
prodotto tra numeri reali e <strong>di</strong> restituirne il<br />
risultato. Si utilizzi una variabile che<br />
contenga il risultato dell’operazione<br />
secondo la logica dell’incapsulamento<br />
(information hi<strong>di</strong>ng) dando la possibilità <strong>di</strong><br />
impostare tale risultato.<br />
class Calcolatrice {<br />
public Calcolatrice() {<br />
accumulatore=0.0f;<br />
}<br />
public Calcolatrice(float val){<br />
}<br />
accumulatore=val;<br />
protected float accumulatore;<br />
public void somma(float x){<br />
accumulatore += x;<br />
}<br />
public void moltiplica(float x){<br />
accumulatore *= x;<br />
}<br />
public float risultato() {<br />
return accumulatore;<br />
}<br />
}<br />
Esempio <strong>di</strong> creazioni:<br />
...<br />
//Usando il costruttore <strong>di</strong> default<br />
Calcolatrice c1 = new Calcolatrice();<br />
//Usando il costruttore overloaded che inizializza<br />
Calcolatrice c2 = new Calcolatrice(3.0);<br />
...<br />
//Esempi d'uso<br />
c1.somma(5.0);<br />
c2.somma(1.0);<br />
c1.moltiplica(C2.risultato());<br />
System.out.println(scrivi C1.risultato());<br />
/* scrive 20.0 */<br />
3. Information hi<strong>di</strong>ng<br />
4
Il concetto <strong>di</strong> information hi<strong>di</strong>ng (che potremmo tradurre con "occultamento <strong>di</strong> informazione")<br />
nella OOP è implicito in quello <strong>di</strong> ADT e consiste nell'idea che l'utente <strong>di</strong> un servizio è tenuto a<br />
conoscere solo le informazioni strettamente necessarie per usufruire del servizio. Ogni altra<br />
informazione può confondere l'utente e/o mettere a rischio l'integrità dell'oggetto stesso.<br />
Tecnicamente si afferma che l'utente deve conoscere solo l' interfaccia della classe, cioè il suo<br />
nome e l'interfaccia <strong>di</strong> ciascuna proprietà pubblica.<br />
Alcuni sistemi sono in grado <strong>di</strong> estrarre/documentare automaticamente l'interfaccia <strong>di</strong> classe dalla<br />
definizione completa <strong>di</strong> un classe.<br />
In realtà esiste un altro importante vantaggio dell'information hi<strong>di</strong>ng: l'implementatore <strong>di</strong> una classe<br />
potrà ritenersi libero <strong>di</strong> effettuare delle migliorie senza che questo comporti delle mo<strong>di</strong>fiche ai<br />
programmi clienti, cioè che usino i servizi offerti da quella classe. L'information hi<strong>di</strong>ng è quin<strong>di</strong><br />
determinante non solo per semplificare la vita ai programmatori, ma anche per la manutenzione e il<br />
"riuso del software".<br />
In particolare, nella OOP, l'informazione da nascondere è la rappresentazione dello stato<br />
dell'oggetto, cioè l'insieme degli attributi. A rigore, quin<strong>di</strong>, tutti gli attributi dovrebbero essere<br />
nascosti: l'utente deve potervi accedere solo in<strong>di</strong>rettamente attraverso i meto<strong>di</strong>. Tuttavia, per motivi<br />
<strong>di</strong> efficienza, alcuni linguaggi ad oggetti (tra cui C++, Java e Delphi) permettono l'accesso agli<br />
attributi (sia in lettura che in scrittura). Il problema dell'information hi<strong>di</strong>ng viene risolto in questi<br />
linguaggi permettendo l'accesso solo ad alcuni attributi classificati come pubblici (tipicamente<br />
saranno quelli presenti in tutte le possibili rappresentazioni). Oltre agli attributi si possono<br />
nascondere anche meto<strong>di</strong>. Tipico è il caso dei meto<strong>di</strong> ausiliari, cioè utilizzati per implementare i<br />
meto<strong>di</strong> pubblici, e più in generale, <strong>di</strong> tutti quei meto<strong>di</strong> la cui esistenza è legata alla<br />
rappresentazione scelta.<br />
In generale, ogni linguaggio propone proprie soluzioni al problema della visibilità, cioè <strong>di</strong> come<br />
stabilire a quali classi rendere visibili le proprietà (sia attributi che meto<strong>di</strong>) <strong>di</strong> una classe. A titolo<br />
puramente in<strong>di</strong>cativo possiamo citare la soluzione a tre livelli del linguaggio Java:<br />
proprietà pubbliche: tutte le classi possono accedervi<br />
proprietà protette: solo le sottoclassi possono accedervi<br />
proprietà private: nessuna classe può accedervi<br />
Infatti, per questioni <strong>di</strong> flessibilità ed efficienza, si sente la necessità <strong>di</strong> poter definire <strong>di</strong>versi<br />
"livelli" <strong>di</strong> visibilità. L'ideale è poter decidere per ogni proprietà, quali sono le classi che possono<br />
accedervi. L'ere<strong>di</strong>tarietà, in particolare, pone un problema che occorre risolvere <strong>di</strong> volta in volta:<br />
quali proprietà ere<strong>di</strong>tate <strong>di</strong> una classe devono essere nascoste alle sue sottoclassi alcuni linguaggi<br />
(ad es. C++ e Java) danno questa risposta: quelle pubbliche e quelle <strong>di</strong>chiarate appunto come<br />
"protette". Altri (ad es. Eiffel) sostengono la tesi che tutto quello che è visibile all'implementatore<br />
<strong>di</strong> una classe deve essere visibile anche agli implementatori delle sue sottoclassi. Inoltre Eiffel non<br />
permette la modalità "private", sostenendo il punto <strong>di</strong> vista secondo cui l'implementatore <strong>di</strong> una<br />
classe non può decidere arbitrariamente che alcuni attributi non siano utili agli implementatori delle<br />
sottoclassi.<br />
4. Ere<strong>di</strong>tarietà<br />
L'ere<strong>di</strong>tarietà risulta in<strong>di</strong>spensabile per processi <strong>di</strong> modellazione molto importanti nella moderna<br />
costruzione del software quali la specializzazione e la generalizzazione.<br />
Nella sua forma più semplice, l'ere<strong>di</strong>tarietà (inheritance) è un meccanismo che consente ad una<br />
5
classe <strong>di</strong> considerarsi erede <strong>di</strong> un'altra, detta classe padre o genitore (parent class), con una<br />
<strong>di</strong>chiarazione che possiamo assumere del tipo:<br />
classe ere<strong>di</strong>ta da <br />
...<br />
Così facendo la classe , detta classe figlia (o classe derivata), ere<strong>di</strong>ta tutte le proprietà della<br />
specificata : tutti gli attributi e i meto<strong>di</strong> (anche quelli nascosti).<br />
Sono state proposte varie notazioni grafiche per rappresentare una relazione <strong>di</strong> ere<strong>di</strong>tarietà tra classi.<br />
Una delle più semplici è la seguente, in cui la relazione è rappresentata da un arco <strong>di</strong>retto dalla<br />
classe figlia alla classe padre. Rappresentando l'insieme delle relazioni <strong>di</strong> questo genere si ottiene il<br />
grafo <strong>di</strong> ere<strong>di</strong>tarietà<br />
Da un punto <strong>di</strong> vista pratico si può ere<strong>di</strong>tare da qualsiasi classe, a patto <strong>di</strong> non introdurre cicli nel<br />
grafo <strong>di</strong> ere<strong>di</strong>tarietà. Tuttavia, come suggerito dai nomi delle classi della figura, da un punto <strong>di</strong> vista<br />
metodologico è opportuno e consigliato ere<strong>di</strong>tare X da Y solo quando si è certi che tra Y e X<br />
esiste una relazione Y IS-A X ("Y è un X"), o in altri termini, quando la classe figlia è una<br />
specializzazione <strong>di</strong> quella padre.<br />
Oltre a ere<strong>di</strong>tare, la classe figlia può:<br />
• aggiungere propri attributi o meto<strong>di</strong><br />
• ridefinire (overri<strong>di</strong>ng) meto<strong>di</strong> ere<strong>di</strong>tati<br />
In questo caso il metodo ere<strong>di</strong>tato (metodo precursore) e quello ridefinito hanno lo stesso nome. I<br />
linguaggi devono pre<strong>di</strong>sporre meccanismi linguistici opportuni per consentire all'implementatore<br />
della classe <strong>di</strong> accedere ai precursori <strong>di</strong> un metodo <strong>di</strong> qualsiasi livello. Si intende che gli utenti della<br />
classe si riferiranno a quello ridefinito.<br />
Si osservi che per ogni classe rimane definito l'insieme dei sui <strong>di</strong>scendenti (supertipi) e dei sui<br />
<strong>di</strong>scendenti (sottotipi).<br />
Molti linguaggi ad oggetti consentono solo l'ere<strong>di</strong>tarietà semplice: ogni classe ha al massimo un<br />
padre. La classificazione degli oggetti è quin<strong>di</strong> strettamente gerarchica.<br />
Se esiste un'unica ra<strong>di</strong>ce questa ha nomi come Object o ANY.<br />
I linguaggi ad oggetti più evoluti consentono l'ere<strong>di</strong>tarietà multipla: cioè la possibilità per una<br />
classe <strong>di</strong> ere<strong>di</strong>tare da più <strong>di</strong> una classe (cioè <strong>di</strong> avere più padri). Sorgono però problemi non banali<br />
<strong>di</strong> ere<strong>di</strong>tarietà ripetuta: esiste cioè la possibilità <strong>di</strong> ere<strong>di</strong>tare più <strong>di</strong> un metodo con lo stesso nome e<br />
occorre risolvere in qualche modo le ambiguità che si vengono a creare.<br />
6
Esercizio 2<br />
Realizzare una classe che permetta <strong>di</strong><br />
effettuare oltre alle operazioni <strong>di</strong> somma<br />
e prodotto tra numeri reali anche quella<br />
<strong>di</strong> sottrazione. Il risultato dell’operazione<br />
va restituito in valore assoluto.<br />
public class CalcolatriceLusso<br />
extends Calcolatrice{<br />
public void sottrazione(float x){<br />
accumulatore -= x;<br />
}<br />
public float risultato() {<br />
if(accumulatore
a) la possibilità <strong>di</strong> usare variabili polimorfe, cioè che possono riferirsi ad oggetti <strong>di</strong> tipi <strong>di</strong>versi<br />
(generalmente "inclusi" in una certa gerarchia). In pratica basta permettere ad una variabile <strong>di</strong> tipo T<br />
<strong>di</strong> ricevere un oggetto <strong>di</strong> un qualsiasi sottotipo <strong>di</strong> T.<br />
b) la possibilità <strong>di</strong> effettuare chiamate polimorfe, cioè <strong>di</strong> in<strong>di</strong>care con lo stesso nome dei meto<strong>di</strong><br />
che appartengono a classi <strong>di</strong>verse e che sono quin<strong>di</strong> generalmente <strong>di</strong>versi ("polimorfo" = "avente<br />
più forme").<br />
A <strong>di</strong>fferenza <strong>di</strong> altre forme <strong>di</strong> polimorfismo, come l'overloa<strong>di</strong>ng (sovraccarico o sovrapposizione)<br />
degli operatori, il polimorfismo <strong>di</strong> inclusione universale prevede che la decisione su quale debba<br />
essere la routine da richiamare viene presa a tempo <strong>di</strong> esecuzione a seconda della classe effettiva<br />
(più stretta) <strong>di</strong> appartenenza dell'oggetto rispetto a cui viene fatta la chiamata. Questa tecnica è nota<br />
come collegamento <strong>di</strong>namico (late o dynamic bin<strong>di</strong>ng) dei nomi al co<strong>di</strong>ce che deve essere<br />
effettivamente eseguito. Esso si contrappone al tra<strong>di</strong>zionale collegamento statico (early o static<br />
bin<strong>di</strong>ng) deciso dal compilatore, <strong>di</strong> norma, nel caso <strong>di</strong> chiamate non polimorfe.<br />
Spesso il polimorfismo viene introdotto con le classe astratte, vale a <strong>di</strong>re classi in cui compaiono<br />
uno o più meto<strong>di</strong> la cui definizione viene rinviata alle sottoclassi (meto<strong>di</strong> astratti). Tipico è<br />
l'esempio rappresentato nella figura qui sotto, in cui la classe ANIMALE ha un metodo astratto<br />
fai_verso() che trova una concreta realizzazione (definizione) solo nei <strong>di</strong>scendenti "concreti" (ad<br />
es. CANE, GATTO, ecc. ).<br />
Il polimorfismo trova applicazione soprattutto in schemi simili a quello esemplificato dal seguente<br />
frammento:<br />
per ogni a : ANIMALE in S esegui<br />
a.fai_verso()<br />
fineperogni<br />
Si immagina che la variabile a assuma <strong>di</strong> volta in volta i vari oggetti (<strong>di</strong> tipo ANIMALE) che si<br />
trovano in un insieme o in un array S. Alla variabile a verrà quin<strong>di</strong> <strong>di</strong> volta in volta associato un<br />
animale potenzialmente <strong>di</strong>verso e a priori sconosciuto. Quin<strong>di</strong>, per il compilatore, la chiamata<br />
a.fai_verso() è polimorfa e, come tale, soggetta al collegamento <strong>di</strong>namico.<br />
6. Genericità<br />
Un'altra delle caratteristiche desiderabili del linguaggi OOP tipizzati è la genericità, cioè la<br />
possibilità <strong>di</strong> definire delle classi con uno o più parametri <strong>di</strong> tipo "tipo". Questa possibilità è utile<br />
soprattutto quando si vogliono definire delle classi <strong>di</strong> tipo contenitore <strong>di</strong> dati: array, pile, code,<br />
alberi, ecc.<br />
8
L'idea è quella <strong>di</strong> estendere la possibilità <strong>di</strong> <strong>di</strong>chiarare il tipo degli elementi presente per il tipo<br />
predefinito array (ad es. array of integer, array of string, ecc. ) ai contenitori definiti dall'utente<br />
(pila of integer, pila of string, ecc. ).<br />
In assenza <strong>di</strong> questo strumento (ad es. Java ne è sprovvisto) si è costretti a definire una classe <strong>di</strong><br />
oggetti "qualsiasi" (ANY o Object) e fare quin<strong>di</strong> un downcasting, cioè una conversione forzata al<br />
sottotipo che ci interessa <strong>di</strong> volta in volta.<br />
Il ricorso al downcasting si rivela comunque necessario in altre occasioni, come quelle che si<br />
presentano quando dobbiamo elaborare una collezione <strong>di</strong> oggetti <strong>di</strong> varie classi utilizzando le loro<br />
operazioni specifiche (non polimorfe).<br />
A volte esiste la necessità <strong>di</strong> restringere i possibili parametri attuali <strong>di</strong> tipo "tipo" a quelli che<br />
possiedono determinate operazioni (tipico è il caso dell'operazione <strong>di</strong> confronto : , ecc.). Alcuni<br />
linguaggi (ad es. Eiffel e Sather) mettono a <strong>di</strong>sposizione a tale proposito la cosiddetta genericità<br />
vincolata: solo le classi <strong>di</strong>scendenti <strong>di</strong> una certa classe specificata possono essere sostituite al posto<br />
del parametro.<br />
7. Aspetti avanzati<br />
7.1 Copia e uguaglianza<br />
La semantica <strong>di</strong> default per le operazioni <strong>di</strong> assegnamento e <strong>di</strong> confronto per = fra oggetti prevede<br />
che vengano coinvolte solo le identità degli oggetti (in pratica, spesso, dei puntatori <strong>di</strong> memoria).<br />
Nel caso dell'assegnamento questo può creare degli spiacevoli effetti collaterali dovuti alla<br />
con<strong>di</strong>visione <strong>di</strong> strutture <strong>di</strong>namiche che si viene a creare. Per evitarli occorre effettuare<br />
l'assegnamento con operazioni del tipo a:=copia(b) che ha l'effetto <strong>di</strong> creare in a un puntatore ad<br />
una copia dell'oggetto in<strong>di</strong>cato in b.<br />
Nel confronto x = y tra oggetti, se si vuole che il confronto non venga fatto sulle identità (questo è<br />
quasi sempre il caso) ma bensì sullo stato dei due oggetti, è necessario usare operatori <strong>di</strong>versi<br />
come, ad es., uguale(x,y) .<br />
In genere i linguaggi mettono a <strong>di</strong>sposizione del programmatore la possibilità <strong>di</strong> ridefinire copia e<br />
uguale classe per classe.<br />
7.2 Asserzioni<br />
Le asserzioni in un linguaggio <strong>di</strong> programmazione sono delle espressioni booleane valutabili a<br />
tempo <strong>di</strong> esecuzione che possono assolvere a <strong>di</strong>versi scopi:<br />
• forma primitiva <strong>di</strong> specifica e <strong>di</strong> documentazione<br />
• prevenzione contro possibili malfunzionamenti del software; in particolare nella OOP come<br />
precon<strong>di</strong>zioni e postcon<strong>di</strong>zioni dei meto<strong>di</strong><br />
• strumento <strong>di</strong> verifica durante la fase <strong>di</strong> testing<br />
• possibili clausole <strong>di</strong> uno stile <strong>di</strong> programmazione noto come progetto per contratto<br />
I linguaggi OOP si <strong>di</strong>fferenziano notevolmente rispetto al supporto e alla varietà <strong>di</strong> tipi <strong>di</strong> asserzioni<br />
che mettono a <strong>di</strong>sposizione del programmatore.<br />
7.3 Eccezioni<br />
Per aumentare la robustezza <strong>di</strong> un'applicazione, tutti i più recenti linguaggi OOP mettono a<br />
<strong>di</strong>sposizione la possibilità definire, sollevare e trattare eccezioni, cioè eventi causati da<br />
malfunzionamenti o imprevisti hardware o software che si possono sempre verificare. In particolare<br />
il programmatore <strong>di</strong> ogni metodo ha la possibilità <strong>di</strong> catturare un'eccezione, riconoscerla e prendere<br />
9
le necessarie azioni <strong>di</strong> recupero almeno per mantenere l'oggetto in uno stato interno consistente. Il<br />
trattamento standard <strong>di</strong> default è quello <strong>di</strong> propagare l'eccezione al chiamante, fino eventualmente a<br />
raggiungere il metodo avviato per primo, facendolo abortire.<br />
7.4 Contenitori e iteratori<br />
Una volta definito come classe un contenitore astratto <strong>di</strong> dati (ad es. una pila, una lista, una<br />
tabella, ecc.) si può presentare il problema <strong>di</strong> attraversare uno <strong>di</strong> questi contenitori, cioè <strong>di</strong><br />
costruire cicli del tipo<br />
portati sul primo elemento<br />
finché non sei giunto all'ultimo e non hai trovato una con<strong>di</strong>zione <strong>di</strong> arresto<br />
elabora l'elemento corrente<br />
passa all'elemento successivo<br />
finefinché<br />
La soluzione più generale, flessibile e astratta a questo problema prevede il ricorso a degli oggetti<br />
chiamati iteratori la cui classe <strong>di</strong> appartenenza viene definita in "simbiosi" a quella dei contenitori<br />
che li attraversano. In pratica essi assolvono ad un ruolo molto simile a quello rivestito dagli in<strong>di</strong>ci<br />
dei "for" per l'attraversamento degli array. La <strong>di</strong>fferenza è che viene completamente nascosta la<br />
rappresentazione dei cursori. Il cursore è l'oggetto che all'interno <strong>di</strong> un iteratore "punta"<br />
all'elemento del contenitore in corso <strong>di</strong> attraversamento. Questo permette un domani <strong>di</strong> cambiare sia<br />
la rappresentazione dei contenitori che quella degli iteratori senza cambiare il co<strong>di</strong>ce delle<br />
applicazioni "clienti".<br />
7.5 Distruttori<br />
Oltre ai costruttori può essere talvolta necessario che il programmatore definisca dei meto<strong>di</strong>,<br />
chiamati spesso <strong>di</strong>struttori, che assolvono al compito <strong>di</strong> svolgere delle azioni finali prima che<br />
l'oggetto venga completamente <strong>di</strong>strutto e le sue aree <strong>di</strong> memoria rese <strong>di</strong>sponibili per operazioni <strong>di</strong><br />
allocazione <strong>di</strong> nuovi oggetti. In particolare, in C++, i <strong>di</strong>struttori hanno spesso l'onere <strong>di</strong> recuperare<br />
parte della memoria occupata dall'oggetto. Da questo onere sono liberi tutti i linguaggi che<br />
prevedono il garbage collector, cioè quel processo della macchina virtuale del linguaggio che<br />
assolve appunto al compito <strong>di</strong> in<strong>di</strong>viduare e recuperare le aree occupate da oggetti che si rendono<br />
inaccessibili ("garbage", appunto).<br />
7.6 Persistenza<br />
La persistenza nella OOP è la proprietà <strong>di</strong> un oggetto <strong>di</strong> sopravvivere al processo che l'ha creato.<br />
Un modo per implementare la persistenza è tipicamente quello <strong>di</strong> "salvarlo" su un supporto <strong>di</strong><br />
memoria persistente, come il <strong>di</strong>sco. I linguaggi OOP adottano varie tecniche per fornire questo tipo<br />
<strong>di</strong> servizio all'utenza. Il più semplice e primitivo è quello <strong>di</strong> mettere a <strong>di</strong>sposizione delle primitive<br />
<strong>di</strong> salvataggio e recupero <strong>di</strong> un oggetti su un file con un certo nome. Il più sofisticato (ma anche il<br />
più semplice da usarsi) è quello <strong>di</strong> prevedere la possibilità <strong>di</strong> <strong>di</strong>chiarare come persistenti alcune<br />
classi: gli oggetti creati saranno automaticamente resi persistenti.<br />
10
ITIS “A.Avogadro”<br />
Compito in classe V A del 29-11-2005<br />
Durata: 3h<br />
Realizzare un programma Java che utilizzi la classe Automobile e due sottoclassi AutoDaCorsa ed<br />
Utilitaria. Le sottoclassi ere<strong>di</strong>tano automaticamente le variabili <strong>di</strong> istanza e i meto<strong>di</strong> della<br />
superclasse. Le proprietà che devono essere gestite ed impostate sono la velocità, la tenuta <strong>di</strong> strada<br />
e la temperatura massima.<br />
Le utilitarie e le auto da corsa devono avere comportamenti <strong>di</strong>versi per la rilevare la temperatura,<br />
le utilitarie se riscontrano che la temperatura del motore ha superato la temperatura massima devono<br />
segnalare a schermo il messaggio <strong>di</strong> fermata alla prima sosta e controllare la temperatura dell’acqua<br />
del ra<strong>di</strong>atore, mentre le auto da corsa i messaggio <strong>di</strong> controllo strumentazione e fermata ai box.<br />
Utilizzare una classe <strong>di</strong> Test per verificare il funzionamento.<br />
Si realizzi il <strong>di</strong>agramma delle classi, evidenziandone proprietà e meto<strong>di</strong>.
ITIS “A. Avogadro ”<br />
Soluzione proposta<br />
• Diagramma delle classi<br />
• Implementazione delle classi<br />
//Classe auto generica, file Automobile.java<br />
package auto;<br />
class Automobile { // Classe auto generica<br />
int velocita = 0; // variabili <strong>di</strong> istanza<br />
float tenutaStrada = 0f;<br />
int temperaturaMax = 100;<br />
void setVelocita(int velocita) { //metodo imposta velocità<br />
}<br />
this.velocita = velocita;<br />
int getVelocita() { //metodo velocità
}<br />
System.out.println(this.velocita);<br />
return this.velocita;<br />
void getTenutaStrada() { //metodo tenutastrada<br />
}<br />
System.out.println("metodo getTenutaStrada <strong>di</strong> automobile");<br />
void temperaturaAlta(int temperatura) { //metodo temperatura<br />
if (temperatura > temperaturaMax)<br />
System.out.println("attenzione temperatura alta");<br />
}<br />
}<br />
//Classe auto da corsa, file AutoDaCorsa.java<br />
package auto;<br />
class AutoDaCorsa<br />
extends Automobile { // Classe auto da corsa ( extends fa ere<strong>di</strong>tare )<br />
void temperaturaAlta(int temperatura) { // metodo temperatura<br />
if (temperatura > temperaturaMax) {<br />
System.out.println("Controllo strumentazione");<br />
System.out.println("Fermata ai box");<br />
}<br />
}<br />
void getTenutaStrada() { // metodo tenutastrada<br />
float coeff_asfalto = 0.001f;<br />
this.tenutaStrada = coeff_asfalto * this.velocita;<br />
System.out.println(this.tenutaStrada);<br />
}<br />
}<br />
//Classe utilitaria, file Utilitaria.java<br />
package auto;<br />
class Utilitaria<br />
extends Automobile { // Classe utilitaria (extends fa ere<strong>di</strong>tare )<br />
void temperaturaAlta(int temperatura) { // metodo temperatura<br />
if (temperatura > temperaturaMax) {<br />
System.out.println("Ferma alla prima sosta");<br />
System.out.println("Controllo temperatura acqua ra<strong>di</strong>atore");<br />
}<br />
}<br />
void getTenutaStrada(int mantoStradale) { // metodo tenutastrada
float coeff_terra = 0.034f;<br />
float coeff_asfalto = 0.03f;<br />
if (mantoStradale == 0) {<br />
this.tenutaStrada = coeff_asfalto * this.velocita;<br />
}<br />
else {<br />
this.tenutaStrada = coeff_terra * this.velocita;<br />
}<br />
System.out.println(this.tenutaStrada);<br />
}<br />
}<br />
//Classe <strong>di</strong> test, file Test.java<br />
package auto;<br />
public class Test { // classe auto che contiene il metodo main<br />
public static void main(String[] args) {<br />
AutoDaCorsa ferrari = new AutoDaCorsa();<br />
Utilitaria cinquecento = new Utilitaria();<br />
ferrari.setVelocita(200);<br />
cinquecento.setVelocita(100);<br />
ferrari.getTenutaStrada();<br />
cinquecento.getTenutaStrada(1);<br />
ferrari.getVelocita();<br />
cinquecento.getVelocita();<br />
ferrari.temperaturaAlta(123);<br />
cinquecento.temperaturaAlta(119);<br />
}<br />
}