SCUOLA INTERATENEO DI SPECIALIZZAZIONE

PER LA FORMAZIONE DEGLI INSEGNANTI DELLA SCUOLA SECONDARIA SIS

Via Carlo Alberto 10 – 10123 TORINO –

tel. 011.6702887 Fax 011.6702888 e-mail: sis@dm.unito.it

Un approccio didattico per la programmazione orientata agli oggetti in linguaggio Java in una Va I.T.I.S.

Relazione finale per l’abilitazione all’insegnamento secondario

Anno Accademico

2005-2006

Indirizzo

Tecnologico

Classe di Abilitazione

A042 – Informatica

Candidato

CANDIDO Abramo

Supervisore

prof. BELOTTI Pierangelo

Quando insegni, insegna allo stesso tempo a dubitare di ciò che insegni. Ortega y Gasset

2

CONTENUTI 1. Introduzione ................................................................................................... 4 2. Il Riferimento didattico metodologico ......................................................... 5

2.1. Le scelte didattiche ........................................................................................................................ 5 2.2. Verso la competenza informatica................................................................................................ 7 2.3. Insegnare Informatica................................................................................................................... 8 2.4. Didattica dell’informatica............................................................................................................. 9 2.5. Scelta degli strumenti e delle metodologie................................................................................. 11

3. Il progetto ..................................................................................................... 12 3.1. Il contesto dell’intervento didattico ........................................................................................... 12 3.2. Scelta dei contenuti in relazione alla disciplina e alle sue caratteristiche .............................. 12 3.3. Descrizione sintetica del progetto............................................................................................... 13 3.3.1. Programmazione didattica ......................................................................................................... 14

4. Analisi del processo ..................................................................................... 16 4.1. Lo svolgimento dell’intervento didattico................................................................................... 16 4.1.1. Didattica e software libero.......................................................................................................... 17 4.2. Gli aspetti emotivi e relazionali .................................................................................................. 18 4.3. Riflessioni ..................................................................................................................................... 20 4.4. Progettazione della verifica ........................................................................................................ 22 4.5. Valutazione del lavoro fatto dagli studenti ............................................................................... 24

5. Conclusioni ................................................................................................... 28 Bibliografia................................................................................................................. 31

Supporti Didattici:

Supporto Didattico A ........................................................ Trasparenze usate nell’I.D. all’Itis Avogadro Supporto Didattico B .............................................Dispense didattiche usate nell’I.D. all’Itis Avogadro Supporto Didattico C .....................................................Verifica sommativa per l’I.D. all’Itis Avogadro

Allegati:

Allegato A ............................................................................................ P.O.F Itis Avogadro A.A. 2005-06

3

1. Introduzione I corsi frequentati alla SSIS, con la bibliografia suggerita dalla stessa istituzione, e le esperienze di tirocinio hanno rappresentato una ghiotta opportunità e un osservatorio privilegiato per utilizzare le chiavi di lettura fornite per indagare e comprendere i processi cognitivi degli allievi, le strategie da loro messe in atto nella risoluzione di problemi, le convinzioni e le emozioni con le quali affrontano e si rapportano allo studio dell’informatica. L’ingresso in aula come insegnante, con al seguito le nozioni pedagogico-psicologiche e i vari modelli didattici, si è rivelata una tappa fondamentale del percorso di costruzione della ricetta del “buon insegnante”, e ha permesso di confutare o constatare come trovano realizzazione pratica le teorie e i modelli didattici di riferimento che non possono prescindere dal considerare gli aspetti emotivi e relazionali. Questo lavoro nasce da un approccio didattico adottato durante l’esperienza di tirocinio attivo svoltasi nell’anno scolastico 2005-06 presso l’Istituto Tecnico Industriale “A. Avogadro”. Lo scopo dell’intervento didattico, stabilito con i docenti accoglienti e unitamente al supervisore, ha riguardato l’introduzione alla programmazione ad oggetti tramite il linguaggio Java. Si è cercato di porre gli allievi in una situazione non solo “di fare”, e quindi di “acquisire facendo”, ma anche di collaborare all’interno del gruppo e di comprendere le dinamiche e le fasi di progettazione di artefatti software. Attraverso la modellazione si sono aiutati i ragazzi a fare proprie le teorie presentate, e si è facilitata la comprensione dei processi che sono alla base della nascita di una applicazione informatica. La formazione a cui mira la mia proposta tende a spostare l’attenzione dall’impostazione teorica e disciplinare ad una didattica e pratica che implica una particolare attenzione ai bisogni degli allievi, bisogni che ho “imparato ad imparare” e che proprio per questi motivi, sarò certamente in grado di apprezzare. Non mi sono accontentato di un’osservazione dei fenomeni nella loro individualità e peculiarità ma ho cercato di cogliere l’aspetto globale e dinamico delle situazioni, evidenziando correlazioni (aspetti fondamentali nell’ambito dell’osservazione di situazioni educative); né mi sono limitato a rilevare i dati cercando di dare una lettura di ciò che vedevo avendo la necessità di cogliere caratteristiche e/o dinamiche interne, senza pregiudizi, al fine di comprendere in modo oggettivo. Il presente lavoro è organizzato per sezioni, ho cercato di collocarlo in un quadro unitario analizzando la grande quantità di elementi raccolti e riprendendo le piste e spunti di riflessione che sono germogliate copiose durante questo cammino formativo del biennio alla SSIS. In questo lavoro di “scomposizione” degli eventi sono stati estremamente preziosi gli strumenti di preparazione all’intervento didattico, materiale didattico, presentazioni, griglie di valutazione e liste di controllo degli aspetti da monitorare, perché mi hanno aiutato ad individuare le singole variabili atomiche del processo di apprendimento-insegnamento. La presenza in classe è stata un piacevole ritorno tra una dimensione scolastica innovata in cui il ruolo degli attori si è evoluto assumendo caratteristiche nuove.

4

2. Il Riferimento didattico metodologico L’intervento in classe e la sua conduzione diretta ha rappresentato, grazie alle esperienze di tirocinio, il momento per applicare, sperimentare, valutare e far sorgere una riflessione critica in itinere degli insegnamenti appresi durante la frequenza dei corsi disciplinari e trasversali della SIS. La consapevolezza dell’esistenza di diversi approcci didattici per presentare agli allievi un dato argomento è necessaria e funzionale per operare delle scelte di impostazione della didattica, e per delineare una strategia di apprendimento. A tal proposito sono state fonti di ispirazione per come presentare la materia agli studenti i corsi del macroesame di Didattica dell’informatica e Storia ed epistemologia della scienza dai quali ho apprezzato l’importanza di contestualizzare il sapere scientifico e di bandire l’approccio epistemologico empirista-positivista che tende a trasmettere la concezione della scienza come un prodotto confezionato e sinonimo di verità, commettendo un delitto intellettuale e occultando il processo della scienza, il turbinio e l’affanno che si cova dietro alla corrente e momentaneamente adottata teoria, e i tratti propri del sapere scientifico (ipotetico, contingente, storicamente determinato, non oggettivo, non riflessivo della realtà). Le conseguenze della concezione positivista sull’insegnamento vanno a sancire il primato dell’osservazione e l’evidenza come fonte di conoscenza, e si ripercuotono sul modello didattico d’apprendimento che è quello trasmissivo con i lati negativi (natura innaturale della scienza, neutralità concettuale dell’allievo, rappresentazioni concettuali difformi degli allievi, rottura epistemologica).

2.1. Le scelte didattiche Oggi, invece, non si può fare a meno di pensare a un ruolo attivo degli studenti nella costruzione del loro sapere; non solo, quindi “educare”, ma anche “educere” [dal latino educere = trarre fuori]. Alla luce di questo significato ambivalente che assume il termine educazione, si delinea un nuovo ruolo per l’insegnante che, come sostiene Gordon, “non è più colui che trasferisce il suo sapere agli studenti ma colui che sa essere con gli studenti in modo funzionale al loro processo di apprendimento o ,meglio ancora, al processo attraverso il quale gli studenti educano sè stessi”1. Alla base del metodo trasmissivo vi è l’idea di uno studente paragonabile ad un “bicchiere vuoto”, che l’insegnante ha il compito di riempire di contenuti: le conoscenze vengono semplicemente trasmesse dall’insegnante all’allievo tramite le classiche lezioni frontali in cui il docente spiega e gli allievi ascoltano; gli studenti hanno poi il dovere di studiare e rielaborare da soli sul libro di testo gli argomenti illustrati in classe. Il metodo socio-costruttivista parte invece da un presupposto profondamente diverso, cioè dall’idea di studente come soggetto pensante. Le conoscenze non possono essere trasmesse, ma devono essere costruite da colui che apprende a partire dalle concezioni che ha, con l’aiuto dell’insegnante e la collaborazione del gruppo classe: gli studenti, pertanto, diventano protagonisti del processo di apprendimento. Il modello costruttivista2 sostiene, infatti, che un apprendimento efficace presupponga un cambiamento metodologico nella costruzione del sapere e che, dunque, non si possa fare a meno di tenere in considerazione le concezioni iniziali degli studenti, spesso costituite da conoscenze accettate senza alcun spirito critico. In particolare, nell’ambito delle discipline scientifiche, questo tipo di approccio comporta l’avvicinarsi degli allievi alla metodologia scientifica nei suoi aspetti essenziali: formalizzare un problema, proporre delle ipotesi, verificare le ipotesi, ecc. Per poter mettere in atto un insegnamento basato su questo approccio, è molto utile proporre situazioni problematiche che possono suscitare interesse negli studenti coinvolgendoli

1 T. Gordon, “Insegnanti efficaci. Il metodo Gordon: pratiche educative per insegnanti, genitori e studenti”, ed. Giunti Lisciani, pag.7 2 D.W. Johnson, R. T. Johnson, E.J. Holubec, Apprendimento cooperativo in classe, Trento, Erickson, 1996, pp. 17-35.

5

emotivamente ed è altrettanto utile dare spazio a lavori di gruppo in cui gli allievi, guidati dall’insegnante, possano confrontarsi tra loro. Ma dopo aver trovato un modello di riferimento, quale metodologia didattica mettere in atto? Forte delle esperienze di tirocinio del biennio S.I.S. non ci sono stati dubbi: non esiste una metodologia perfetta e un insegnante non può mettere in atto solo ed esclusivamente un tipo di didattica. In ogni insegnante coesistono diverse metodologie (che in parte ne rispecchiano la personalità) e l’abilità sta proprio nell’adattare la metodologia di lavoro al contesto e alle caratteristiche della classe in cui si va ad operare. In relazione a questo aspetto, nello svolgimento del presente intervento didattico, si è adoperata una metodologia, difficilmente ascrivibile ad una determinata categoria, che raccoglie spunti principalmente da tre tipologie di didattica:

• Didattica per concetti • Didattica per problemi • Didattica per obiettivi

Il tutto coordinato dall’approccio costruttivista: i ragazzi devono costruire il loro sapere e non si può pensare di trasmettere conoscenza. Per fare un breve cenno sulle caratteristiche principali di questi tipi di didattica, si può cominciare con il mettere in evidenza che le tre metodologie in questione concentrano la loro attenzione su aspetti diversi: la didattica per problemi dà rilievo soprattutto ai processi dell’apprendimento, la didattica per obiettivi ai risultati, mentre la didattica per concetti considera entrambi gli aspetti. Quello che mi prefiggevo, progettando il mio intervento didattico, era di tenere in considerazione tutti questi aspetti, pertanto, nell’analisi del lavoro condotto si potranno identificare aspetti relativi a tutte e tre le metodologie didattiche. L’integrazione di diverse metodologie didattiche ha permesso di impostare il lavoro in modo più flessibile, adeguandolo di volta in volta alle necessità del momento. Pertanto, non si è esclusa a priori alcuna metodologia, ma si è cercato di utilizzare il bagaglio accumulato durante la frequenza S.I.S. e durante la breve esperienza di insegnamento per adattare l’intervento al contesto di lavoro. Nel delineare un modello di riferimento, non si può fare a meno di considerare gli aspetti relazionali, che certamente non sono di secondaria importanza. Purtroppo, la scuola trascura la dimensione emotiva3 che entra in gioco nel processo di insegnamento-apprendimento; come ha evidenziato Winnicott nell’ambito di un ampio discorso sulla società in generale, la scuola spesso paga a caro prezzo, dal punto di vista dell’insuccesso e dell’inefficienza, la sua disattenzione nei confronti dei fattori emotivo-affettivi. Ripensando ai vecchi programmi ministeriali, si rende conto di come la scuola, fino a poco tempo fa, considerasse separatamente la dimensione cognitiva da quella emotiva, dando spesso per scontata la buona situazione emotiva degli allievi. Gli insegnanti si trovano di fronte a vissuti di ansia, di aggressività e di insuccesso che riguardano non allievi con problemi di handicap, ma studenti normodotati o addirittura dotati di una creatività fuori dal comune. Di fronte a ciò non esiste la “ricetta del buon insegnante” ma è già un passo avanti se il docente tiene conto del fatto che con il proprio atteggiamento nei confronti degli studenti può influenzare il modo in cui i ragazzi si rapporteranno alla disciplina. Non è sufficiente, quindi, che un insegnante sia molto preparato, né tanto meno, che sia innamorato della propria materia, per stimolare gli allievi e far nascere in loro il desiderio di apprendere è necessario impostare un buon rapporto prima di tutto dal punto di vista umano e una relazione positiva tra menti che favorisca la crescita mentale e promuova la “pensabilità”4. In definitiva un insegnamento può diventare interessante se impartito da un insegnante che abbia appreso il modo corretto di rapportarsi con gli studenti, instaurando una relazione di reciproco rispetto. Alla luce di queste considerazioni, è nata una consapevolezza: l’ ”arma” principale di ogni 3 G. Blandino, B. Granieri , Le risorse emotive nella scuola, 2004, Cortina, Milano 4 A.R.Colasanti, Star bene a scuola: la promozione di comportamenti sociali positivi , in “Orientamenti pedagogici”, vol. n. 49, n.4 (292), luglio-agosto, 2002, pp. 595-610.

6

insegnante è la riflessione, che porta a considerare la molteplicità di aspetti che entrano in gioco nel processo di apprendimento e a tenerne conto nell’organizzazione del lavoro. L’insegnante diviene un mediatore ed è evidente che la condivisione di obiettivi e finalità sia un elemento imprescindibile per realizzare un buon intervento in classe5, gli allievi hanno il diritto di conoscere quale sarà il percorso didattico che affronteranno, avere la possibilità di modificarlo in base ai loro bisogni e esigenze. Grazie al tirocinio ho utilizzato le chiavi di lettura fornite nel corso di Didattica dell’Informatica6: la necessità di indagare e comprendere i processi cognitivi degli allievi, le strategie da loro messe in atto nella risoluzione di problemi, le convinzioni ed emozioni con le quali affrontano lo studio dei sistemi informatici; ma è un’opportunità che naturalmente nasce solo se si tiene conto delle esigenze di chi, docente e studenti, mette a disposizione il proprio tempo, il proprio lavoro e nel caso degli studenti…se stessi.

2.2. Verso la competenza informatica Se la competenza diventa nell’ambito teorico un senso possibile, é importante chiarire il significato di alcuni termini propri del linguaggio cognitivo utilizzato in didattica della informatica, termini utilizzati in riferimento sia agli oggetti di insegnamento (contenuti) che all’apprendimento degli studenti (conoscenze, competenze): Contenuto: una porzione limitata di sapere; Conoscenza: è, allo stesso tempo, la rielaborazione di contenuti in modo autonomo per raggiungere una meta, e il risultato di tale elaborazione; una conoscenza può coinvolgere uno o più contenuti; Competenza: è un concetto complesso e dinamico. Complesso poiché si tratta dell’insieme di due componenti, uso (esogeno) e padronanza (endogena), di conoscenze che collegano contenuti diversi; concetto dinamico, in quanto la competenza non si esprime solo attraverso l’uso e la padronanza, la competenza racchiude in sé anche fattori metacognitivi, affettivi, il desiderio di completare conoscenze e quindi di aumentare competenze. Come insegnante ho cercato di orientarmi e di considerare lo studente come colui che deve raggiungere competenza e non “semplice” conoscenza. La competenza implica necessariamente il “voler fare”, dunque chiama immediatamente in causa fatti affettivi come volizione e atteggiamento. I mezzi che ci permettono di passare dalle capacità alle competenze sono le conoscenze che maturiamo e le abilità di cui ci impadroniamo e che usiamo nelle diverse situazioni. Nessuno può dichiarare di essere più o meno competente fino a quando non è posto nelle condizioni di poterlo dimostrare, fino a quando, cioè, non fa esercizio delle proprie capacità. Le capacità se non esercitate si atrofizzano, non si sviluppano e non diventano mai competenze; è un bene se queste capacità atrofizzate riguardano la parte meno nobile del nostro essere, è un male se riguardano ciò che ci rende migliori. La competenza in informatica è al centro della disciplina, riconosciuta come scienza costituita, come oggetto proprio, specifico, di conoscenza. L’allievo entra in contatto con saperi specifici, saperi che la società ha inglobato nelle conoscenze riconosciute come base per un dignitoso ingresso nel suo interno; si appropria di una parte di tali saperi, tanto formalmente quanto informalmente. La competenza informatica si riconosce quando un individuo vede, interpreta e si comporta nel mondo in un senso informatico. Ci sono buoni risolutori di problemi che possono riconoscere, delimitare e risolvere situazioni problematiche; il che, viceversa, a volte, non è facile da evidenziare in persone che trattano bene algoritmi. Poiché la competenza informatica comporta la capacità e disponibilità a guardare il mondo in modo informatico e dato che ciò non si apprende spontaneamente in modo implicito, si rende necessario pensare che deve far parte del curricolo,

5 A. Calvani, Elementi di didattica, Roma, Carocci, 2000. 6 Corso di Didattica dell’Informatica e Laboratorio di Informatica, A.A. 2004-05, prof. B. Montrucchio

7

proprio questo processo di insegnamento–apprendimento specificamente rivolto a “saper vedere informaticamente” il mondo. In virtù della complessità racchiusa nel termine competenza, la valutazione di competenze non può ridursi ad un test tradizionale (tipicamente compito in classe o interrogazione), per verificare la padronanza in qualche cosa di specifico. La valutazione, in vista di una didattica volta a far raggiungere competenze si presenta come un processo di analisi dell’aula, ovvero delle sue varie componenti: il curricolo, l’efficacia dell’insegnante e l’allievo.

2.3. Insegnare Informatica L’informatica come disciplina ha una duplice valenza: quella di essere considerata come una scienza che studia le regole generali della trasmissione, della rappresentazione e della conservazione di informazioni, con una propria epistemologia, e può essere inserita tra le nuove tecnologie che stanno cambiando radicalmente il nostro modo di vivere. Anche se risulta riduttivo confinarla solo all’uso del calcolatore o di applicazioni per calcolatori, in essa confluiscono la matematica, la logica, la fisica, la teoria dell’informazione, l’elettronica. Le tecnologie informatiche si occupano della elaborazione delle informazioni in segnali elettrici in grado di essere trattati dai calcolatori e quindi produce i “linguaggi” e le istruzioni che i calcolatori capiscono. Credo che sia utile conoscere quali siano gli obiettivi dell’insegnamento di Informatica e di Sistemi di elaborazione e trasmissione dell’informazione (classe di abilitazione A042). Il corso di informatica ha come fine principale quello di mettere l’allievo in condizioni di affrontare la soluzione di un problema, posto dalla richiesta di un ipotetico committente, scegliendo le metodologie e gli strumenti software più idonei, offrendo all’allievo la formazione necessaria per seguire con una certa autonomia l’evoluzione delle tecnologie informatiche senza assumere un carattere nozionistico-sintattico e ridursi ad una collezione di parata sistematica sui vari tecnicismi riguardanti la nicchia dei linguaggi di programmazione o dei sistemi di gestione delle base dati. L’allievo deve sviluppare le capacità di analizzare e risolvere problemi di varia natura, deve interpretare il problema e costruirne la soluzione, acquisire la capacità di lavorare in gruppo sviluppando capacità relazionali, superando la competizione ed imparando a criticare e ad essere criticati. L’insegnante ha il compito di aiutare l’allievo per portarlo all’acquisizione della mentalità informatica coadiuvandolo nel potenziamento delle capacità richieste (astrazione, generalizzazione, associazione, dipendenze, correlazioni, modellazione coerente con la realtà per descrivere le entità e le relazioni che costituiranno la base dati, applicazione degli algoritmi e delle strutture in maniera ottimale) senza trascurare gli aspetti organizzativi e motivazionali Il corso di sistemi di elaborazione e trasmissione dell’informazione si pone la finalità di contribuire alla formazione di un adeguato bagaglio di precise conoscenze tecniche e di capacità operative riguardanti i calcolatori e le reti di trasmissione dell’informazione. L’allievo deve acquisire capacità di analisi dei sistemi informatici, e strategie specifiche di risoluzione dei problemi. Bisogna evitare di ridurre la trattazione della disciplina a puro nozionismo descrittivo, per privilegiare, invece, le semplici realizzazioni alla portata degli allievi, in laboratorio; ciò consente di preparare gli alunni alla risoluzione pratica di piccoli problemi di dimensionamento di sistemi informatici. E’ infatti attraverso la sperimentazione sulla macchina che lo studente è in grado in comprendere e interiorizzare i costrutti del linguaggio o gli schemi sistemistici presentati a lezione. Dopo ogni modulo deve essere possibile pensare ad una attività di laboratorio, dove da un lato si presenti l’ambiente di sviluppo (sistema operativo, editor, compilatore, ecc.) e dall’altro si consenta allo studente la compilazione di programmi già scritti, l’identificazione di errori sintattici in programmi già scritti e la scrittura di semplici programmi nuovi dal nulla o partendo da schemi da completare.

8

2.4. Didattica dell’informatica Si potrebbe pensare che – essendo l’informatica una disciplina fondata sulla matematica discreta – molte delle proposte formulate in didattica della matematica si trasferiscano allo studio dell’informatica. Questo è vero solo parzialmente, e per varie ragioni. La ragione principale sta nel fatto che insegnare informatica vuol dire non solo insegnare concetti e metodologie, ma anche tecnologia. La necessità di mettere gli studenti in grado di risolvere problemi concreti, e cioè di analizzarli, di progettare soluzioni e di implementarle utilizzando il calcolatore, pone in molti casi problemi didattici non trascurabili. Questi sono riassumibili a mio avviso come segue:

• il primo problema è quello di stabilire il rapporto corretto tra i diversi ambiti di insegnamento – per l’appunto concetti, metodologie e tecnologie – per evitare sbilanciamenti pericolosi, e in un senso – corsi eccessivamente teorici, dai quali gli studenti apprendono molti concetti ma senza essere in grado di metterli concretamente in pratica – e nell’altro – corsi eccessivamente tecnologici, dai quali gli studenti apprendono solo competenze prettamente operative, senza la dovuta ampiezza metodologica;

• il secondo problema, una volta stabilito il giusto equilibrio tra teoria e pratica, è rappresentato dal modo in cui le nozioni dei diversi ambiti devono essere insegnate; è difficile immaginare che i principi di una disciplina e le sue metodologie possano essere insegnate allo stesso modo in cui si insegnano le regole della sintassi di un linguaggio o i comandi per l’amministrazione dei sistemi informatici, ovvero nozioni di minore rilevanza dal punto di vista concettuale e metodologico e prevalentemente di carattere mnemonico.

Fino a qualche anno fa per gli insegnanti di informatica non era previsto alcun percorso di preparazione specifico; conseguita la laurea gli insegnanti affrontavano senza filtri l’esperienza di insegnamento, contando su sé stessi, sulle proprie capacità, e sulla propria volontà e applicando l’unico modo di insegnare conosciuto, ovvero quello che avevano vissuto dalla parte di studenti durante il periodo pre-universitario. Questo modo di concepire l’insegnamento è proprio della didattica della informatica di tipo tradizionale in cui “lo sforzo del didatta è tutto teso a trasformare un discorso specialistico (e dunque complesso in quanto si fa uso di un linguaggio tecnico non naturale) in uno più comprensibile e più consono alla natura dell’allievo”. La didattica tradizionale tende a dare per scontato che un allievo, una volta appreso un concetto in un determinato ambiente, o per mezzo di un dato strumento, sarà in grado di trasferire la conoscenza acquisita in situazioni simili ma in ambienti diversi in maniera del tutto spontanea: questo non sempre accade, anzi sovente le capacità cognitive e procedurali restano ancorate all’ambito in cui sono state imparate. Il problema principale di questo tipo di didattica, intesa come divulgazione di idee è proprio questo: operando esclusivamente sull’insegnamento non possiamo essere certi che avvenga (effettivamente e completamente) il cosiddetto “transfer cognitivo”. L’attenzione deve quindi spostarsi dal processo di insegnamento a quello di apprendimento, effettuando prove empiriche, con opportuni e ben studiati dispositivi sperimentali, sui risultati cognitivi ottenuti, passando così alla ricerca considerata sperimentale, entrando nel campo dell’epistemologia dell’apprendimento. In tale ottica è l’apprendimento il fine ultimo della didattica, la meta sulla quale si concentrano e si riassumono gli sforzi, le riflessioni, le ricerche. Per quel che concerne la didattica dell’informatica, esistono in ogni modo riflessioni comuni alle varie correnti di pensiero che la pervadono, a cui corrispondono inevitabilmente le parole chiave della disciplina: trasposizione, contratto, ostacolo, immagine, modello. Innanzi tutto è necessaria una breve riflessione sul rapporto tra insegnamento ed apprendimento. In questi due processi sono coinvolti insegnante, allievo e l’oggetto dell’insegnamento, come schematizzato dal celebre triangolo della didattica di Chevallard. Occorre porre particolare attenzione al termine “sapere” che si trova ben al di fuori del rapporto diretto insegnante-allievo. Un sapere dunque esterno al fenomeno di insegnamento apprendimento e perciò (se inteso come sapere accademico, il cosiddetto savoir savant, quello formale, quello dei programmi ministeriali) un

9

sapere momentaneamente inutilizzabile per una didattica efficace. Ovviamente si deve tentare di portare questo sapere all’interno della didattica, si tratta quindi di agire sul sapere accademico per trasformarlo in sapere da insegnare, facendo passare l’insegnamento dal vertice del triangolo in cui è individuato il sapere e contemporaneamente richiedere un analogo adattamento agli allievi, cosa tutt’altro che facile da ottenere. Per tentare di ottenere questo si deve agire sulle caratteristiche del nostro insegnamento e, soprattutto, sul sapere stesso: non è pensabile che un allievo possa apprendere contenuti informatici direttamente espressi in forma accademica, senza che essi siano adeguatamente plasmati, resi accessibili. La trasposizione didattica è proprio questa indispensabile operazione di preventivo adattamento del sapere alle caratteristiche del dialogo educativo che avviene tra l’insegnante e l’allievo. Ovviamente l’insegnante deve anche tener conto del sistema didattico e dell’ambiente sociale e culturale in cui si trova ad agire. L’ambiente in cui è “immerso” il triangolo della didattica è chiamato noosfera, che può essere definita come il luogo dei dibattiti di idee significative sull’insegnamento, le finalità della scuola, gli scopi della formazione, le attese della società, i programmi ministeriali; la noosfera è l’intermediario tra il sistema scolastico e l’ambiente sociale più esteso ed esterno alla scuola. Il complesso di interazioni e di comportamenti che si instaura tra allievo ed insegnante, che deve avere quale prodotto finale l’apprendimento, è formato da una serie di fasi e di momenti che caratterizzano l’attività d’aula quotidiana.

Il rapporto allievo-insegnante è basato su regole non scritte, su convenzioni sottintese, accettate implicitamente tanto dal discente quanto dal docente. Queste regole, seppure mai dichiarate, sono ben conosciute da entrambe le parti in causa, come se costituissero una sorta di contratto mai firmato la cui validità è però indiscutibilmente nota e chiara a tutti: questo “contratto didattico” influenza in termini decisivi il processo di insegnamento-apprendimento. Esistono vari approcci ed accezioni del contratto didattico ma la definizione di riferimento rimane quella di Brousseau che lo definisce come “l’insieme dei comportamenti dell’insegnante che sono attesi dall’allievo e l’insieme dei comportamenti dell’allievo che sono attesi dall’insegnante”.

10

2.5. Scelta degli strumenti e delle metodologie

Alla luce di quanto detto finora, si sono utilizzati per tutta la durata dell’intervento didattico strumenti che permettano di essere coerenti con il modello di riferimento. Ovviamente, nella scelta degli strumenti, non si può fare a meno di tenere in considerazione, oltre alle caratteristiche della disciplina, anche la tipologia di allievi con cui ci si rapporta.

Strumenti e metodologie Motivazioni

Continua discussione in classeLa continua interazione con i ragazzi permette di guidarli nella costruzione di nuovi concetti richiamando quelli già emersi ed è utile inoltre per mantenere viva l’attenzione

Proiezione di presentazioni (videoproiettore)

La proiezione di presentazioni appositamente preparate per ogni lezione permette di fare continuo uso del linguaggio visivo, indispensabile per spiegare con più semplicità i fenomeni di cui si parla, convinti che il linguaggio visivo sia di fondamentale importanza nello studio delle scienze e che questo sia particolarmente vero per ragazzi per cui l’esclusivo uso del linguaggio scientifico corretto potrebbe risultare difficoltoso. L’utilizzo dei lucidi risulta poi utile anche per guidare i ragazzi nel prendere appunti: si ritiene infatti, che uno dei compiti dell’insegnante sia quello di aiutare gli allievi nello sviluppo di capacità di sintesi.

Attività pratiche di gruppo

Le attività pratiche permettono ai ragazzi di riprodurre i fenomeni di cui si è parlato a lezione e quindi di comprenderli meglio. Inoltre il confronto con i compagni durante lo svolgimento del lavoro è fonte continua di stimoli.

Mappe riassuntiveL’utilizzo di mappe riassuntive al termine di un percorso didattico può facilitare lo studio individuale degli allievi, perché permettono di riepilogare i principali concetti emersi durante le lezioni.

11

3. Il progetto

3.1. Il contesto dell’intervento didattico Il contesto dell’intervento didattico è quello dei moduli di tirocinio attivo svolti all’ITIS “A. Avogadro7” di Torino, che nell’anno successivo alla ricorrenza del bicentenario della sua fondazione, è considerato per serietà degli studi un piccolo Politecnico. La riconosciuta considerazione di cui gode l’istituto nasce dal continuo aggiornamento tecnologico e didattico sia sul piano dei contenuti formativi, che sul piano delle strutture ambientali e delle attrezzature tecnico scientifiche. Lo stile educativo e le iniziative che tendono a rendere comunitaria e condivisa la presenza e permanenza nell'Istituto, sono in assonanza con un coinvolgente rapporto con l’ambiente studentesco, perché solo una scuola che va oltre la scuola diventa una vera scuola, nella sua missione civile e nella sua valenza sociale. Gli indirizzi di studio attivi per la sezione diurna sono Elettrotecnica ed Automazione, Informatica, Meccanica, Liceo Scientifico Tecnologico mentre per la sezione serale (Progetto Sirio) sono Elettrotecnica ed Automazione, Informatica, Meccanica; per l’indirizzo informatico si adotta la programmazione “Abacus8”. L’intervento didattico si è svolto nella classe VA dell’indirizzo informatico, composta da ventidue alunni, il contesto è stimolante; nella fase osservativa si è potuto notare come la classe sia abituata a discutere, il docente accogliente, infatti, incentiva al confronto, stimola al ragionamento, e lascia spazio a interventi e domande e nel corso dell’attuazione del progetto si è continuato a dare rilevanza a questi aspetti e la risposta ottenuta dagli allievi è stata confortante. La disciplina di insegnamento è stata Sistemi di elaborazione e trasmissione delle informazioni. Il corso di Sistemi, disciplina ponte fra l’Informatica e l’Elettronica, si occupa dello studio delle architetture dei computer, delle situazioni che si possono rappresentare e utilizzare attraverso la programmazione in linguaggi di programmazione dal basso livello (Assembler e C) all’alto livello (Java, C++), nonché della progettazione e gestione delle reti locali e geografiche, attraverso lo conoscenza dei protocolli di comunicazione e dello sviluppo di applicazioni internet.

3.2. Scelta dei contenuti in relazione alla disciplina e alle sue caratteristiche Il corso di informatica ha come fine principale quello di mettere il perito informatico in grado di affrontare (dall’analisi fino alla documentazione) la soluzione di un problema, posto dalla richiesta di un ipotetico committente, scegliendo le metodologie e gli strumenti software più idonei, ed inoltre fornirgli la formazione di base che gli consenta di seguire con una certa autonomia l’evoluzione delle tecnologie informatiche. La disciplina fornisce all’alunno le conoscenze e le abilità necessarie per l’uso di un sistema di elaborazione ai più alti livelli della gerarchia che lo modella (linguaggi ad alto o altissimo livello, linguaggi applicativi). Essa deve essere intesa soprattutto come l’ambiente in cui si sviluppano le capacità di analizzare e risolvere problemi (anche di una certa complessità) di varia natura, e dove di volta in volta vengono proposti i paradigmi e gli strumenti linguistici più idonei alla natura del problema. Si ricorre ripetutamente al concetto di paradigma che, in questo contesto, si intende come chiave di interpretazione dei problemi e come modello di costruzione delle soluzioni (imperativo, logico, funzionale, rivolto agli oggetti, agli eventi, alle basi di dati). Lo studente, allo scopo di raggiungere una certa flessibilità e la capacità di affrontare nuove prospettive, deve acquisire alcune di queste chiavi e la capacità di impiegarle nei contesti appropriati. Si cerca quindi di privilegiare gli aspetti concettuali ed applicativi della materia riducendo al minimo quelli nozionistico sintattici.

7 Vedi POF Avogadro pp. 1-4 8 Il Progetto ABACUS è un corso sperimentale che il Ministero della P.I. ha varato nell'anno 92/93 per adeguare le competenze richieste al Perito informatico alle "innovazioni" avvenute nel settore negli ultimi anni.

12

Il fascino nello studio dell’Informatica è rappresentato dalla possibilità di comprendere le complessità tecnologica di un mondo che diventa sempre più digitale e passibile di elaborazione e dall’attualità con cui i nuovi mezzi di comunicazioni cambiano i modi abituali di vita. A dispetto di ciò, uno dei rischi che si corrono più frequentemente nell’insegnamento delle materie scientifiche è quello di lasciarsi trascinare dalle necessità didattiche e suddividere le discipline in “capitoli di libro” trascurando le importanti relazioni tra fenomeni studiati. L’argomento scelto per l’intervento didattico riguarda la programmazione orientata agli oggetti e il linguaggio Java, rappresenta un argomenti di notevole interesse per illustrare come i linguaggi di programmazione intervengono nella realizzazione di applicazioni. Con questo tema si toccano importanti concetti portanti delle discipline informatiche:

L’esigenza di modellazione della realtà per trattare un problema Il ciclo di vita del software Il paradigma di programmazione orientata agli oggetti La capacità di razionalizzare e di tradurre i concetti astratti in implementazioni fisiche

In relazione a ciò, uno degli obiettivi più importanti dell’intervento in esame è stato quello di favorire negli allievi la consapevolezza che prima di implementare meccanicamente legandosi vi è un'attività di modellazione che coinvolge le tre fasi (concettuale, logica, fisica), allo stesso modo in cui esulando dalla tecnologia corrente dei linguaggi di programmazione ad oggetti è importante carpire le dinamiche e i ragionamenti per l’individuazione di un diagramma astratto di classi che soddisfano le specifiche. Per poter tenere considerazione questi aspetti e affinché l’intervento didattico puntasse in tale direzione, in accordo con il docente accogliente, ho tracciato il percorso per l’introduzione alla programmazione ad oggetti che potesse confluire ed essere raccordato in un’applicazione dando un taglio squisitamente pratico e realizzativo, anche per dare una visione completa agli allievi dalla progettazione alla realizzazione fisica con l’apporto di modifiche o di revisioni in initere, finalizzate al continuo miglioramento seguendo i canoni del ciclo di vita del software. Nella scelta di questi contenuti ho cercato di dosare il livello di difficoltà in maniera opportuna a seconda dei casi, e contemporaneamente, motivare gli studenti rendendo interessante la materia, adeguandola ai tempi, proponendo ed evidenziando situazioni problematiche direttamente connesse alla vita reale. Il linguaggio di programmazione Java si presta in maniera eccellente a tali scopi e rappresenta uno stimolo decisamente intenso per gli allievi per una serie di motivi tra cui: • può essere insegnato a diversi livelli di approfondimento • oltre ad essere un linguaggio è una tecnologia condivisa dalla comunità scientifica • è estremamente diffuso e utilizzato in ambiti lavorativi • la sua conoscenza è direttamente spendibile nell’immediato

3.3. Descrizione sintetica del progetto La progettazione dell’intervento didattico è finalizzata ad introdurre i concetti di base della programmazione orientata agli oggetti, illustrando come un linguaggio evoluto come Java implementa il paradigma orientato agli oggetti. Nella preparazione del progetto, avvenuta ovviamente dopo le ore di osservazione della classe, la preoccupazione principale è stata quella di organizzare il lavoro in modo da renderlo il più possibile adatto e ‘accattivante’ per i ragazzi. Ho deciso, consigliandomi anche col docente accogliente di ridurre all’osso le lezioni frontali nel senso più tradizionale del termine, a favore di lezioni più interattive e partecipate.

13

3.3.1. Programmazione didattica Le tappe proposte a livello di progettazione e poi effettivamente seguite in tutta l’organizzazione e lo svolgimento del lavoro rientrano in un percorso di lungo periodo, ho tenuto conto di quali fossero gli obiettivi da raggiungere nel breve periodo suddividendoli in obiettivi cognitivi e obiettivi trasversali (da conseguire prevalentemente tramite attività di gruppo) come si evince dallo schema riportato di seguito.

1. Descrizione degli obiettivi che si vogliono conseguire

A breve termine A medio termine A lungo termine Comprendere i concetti di classe, oggetto, ereditarietà, polimorfismo, overriding e overloading, interfaccia

Capacità di rielaborare i contenuti trasmessi dall’insegnante

Progettazione e realizzazione di architetture di classi per il problema da risolvere

Comprendere il paradigma orientato agli oggetti

Capacità di analisi e valutazione delle problematiche nel progetto di applicazioni

Acquisizione del metodo di studio che rifletta il metodo scientifico

Acquisire la sintassi e semantica delle strutture primitive del linguaggio Java

Capacità di modellare con le classi gli spaccati del mondo reale

Autonomia e senso di responsabilità

Implementare le classi e usare gli oggetti in Java

Capacità di esposizione Acquisizione di un linguaggio appropriato

Capacità di allestire installare e configurare l’ambiente di sviluppo

Acquisizione di un linguaggio appropriato

Capacità di confrontare le proprie opinioni con quelle degli altri

Realizzare i diagrammi delle classi per un dato problema

Stimolare interesse Capacità di collaborare con i compagni

Saper implementare e documentare la realizzazione di applicativi Java che usano le classi

Capacità di collaborare con l’insegnante

2. Descrizione dei prerequisiti che gli allievi devono possedere • Dimestichezza nell’utilizzo dei semplici operatori (aritmetici, logici, relazionali),

comprendendone la priorità nel loro utilizzo associativo • Concetti base di programmazione (variabile, costante) e dei tipi di dato • Conoscenza delle strutture logiche di controllo (condizionali e iterative) utilizzate nella

programmazione procedurale

3. Predisposizione di materiale da adottare Per la preparazione dei lucidi da proiettare durante la lezione ho scelto e organizzato i contenuti attentamente affinché ogni concetto nuovo introdotto fosse accompagnato da illustrazioni e esempi tratti dal mondo reale, con un linguaggio minimale semplice e diretto. Ho fornito delle dispense come sussidio didattico ad integrazione del libro di testo utilizzato.

4. Predisposizione di un’attività di gruppo volta a collaudare e a rinforzare l’apprendimento

teorico favorendo lo scambio di informazioni e il dialogo tra studenti L’attività è stata pensata per aiutare i ragazzi a far propri i concetti presentati, stimolandoli a sviluppare o potenziare l’apprendimento tra pari e le capacità espositive. Il lavoro condotto in gruppi di due o tre persone consiste nel creare su un cartellone il diagrammi delle classi

14

stabilendone le gerarchie e le dipendenze, e riconoscendo i metodi e le proprietà partendo da un problema di modellazione preso dalla realtà. In seguito si è cercato di promuovere una discussione in cui gli allievi potessero riflettere e scambiare opinioni circa il diagramma realizzato valutando quale soluzione fosse la migliore, e quindi procedere all’implementazione su calcolatore. Si è cercato di responsabilizzare il gruppo affidando delle consegne ben delimitate e delle regole circa la produzione di documentazione relativa alla realizzazione del progetto, l’organizzazione delle classi e dei sorgenti e il formalismo UML da utilizzare.

5. Allestimento di una prova di verifica sommativa per verificare il raggiungimento degli

obiettivi prefissati La verifica deve essere costituita da un fatto problematico che deve essere realizzato e implementato su elaboratore in linguaggio Java in modo da permettere la valutazione del raggiungimento degli obiettivi indicati (con particolare attenzione agli obiettivi a breve-medio termine). Alcuni quesiti sono mirati a valutare la conoscenza, altri le competenze acquisite e le capacità di applicazione dei concetti costruiti durante il percorso. Per la modalità di correzione della verifica si attribuisce un punteggio a ciascun quesito in funzione della difficoltà; il punteggio attribuito ai quesiti che valutano l’applicazione dei concetti deve essere superiore a quello degli items che valutano la semplice conoscenza dei contenuti. 6. Prospetto dell’intervento didattico

Attività Tempo previsto Osservazione della classe 2 h Lezione introduttiva

• Illustrazione obiettivi • Analisi dei pre-requisiti • Introduzione al linguaggio Java

3h 20 min 40 min

2 h La programmazione orientata agli oggetti

• Introduzione alla programmazione orientata agli oggetti • Il concetto di classe e oggetto • Attività in laboratorio (Installazione e configurazione

dell’ambiente di sviluppo integrato)

3 h 40 min

2 h 20 min

La programmazione orientata agli oggetti • L’incapsulamento e interazioni tra oggetti • Ereditarietà (Classi e Sottoclassi) • Attività in laboratorio (Implementazione di una classe)

3 h 1 h 1 h 1 h

La programmazione orientata agli oggetti • Ridefinizione dei metodi e polimorfismo • L’ ereditarietà multipla (Interfacce) • Attività in laboratorio (Realizzazione di un diagramma di

classi)

3 h 1 h 1 h 1 h

Il linguaggio Java • Caratteristiche lessicali, tipi, strutture di controllo • Classi, ereditarietà, interfacce, packages, gestione delle

eccezioni • Attività in laboratorio (Implementazione di un diagramma di

classi)

3 h 1 h 1 h 1 h

Verifica in classe 3 h

15

4. Analisi del processo L’intervento didattico si è svolto in quindici ore di lezione, di cui un quarto in laboratorio, più la prova di verifica sommativa. I cambiamenti apportati al progetto iniziale sono stati di piccola entità, di seguito si riportano schematicamente i tratti salienti che sono emersi nelle diverse lezioni, per i contenuti delle trasparenze utilizzate nell’intervento didattico e per il materiale didattico fornito agli allievi come compendio didattico integrativo si rimanda rispettivamente agli allegati B e C

4.1. Lo svolgimento dell’intervento didattico Il giorno iniziale dell’intervento didattico, ho dedicato un’ora ad una lezione introduttiva durante la quale sono stati presentati oralmente agli allievi gli argomenti che avremmo trattato e gli obiettivi da raggiungere nel percorso; mi sono ritagliato altresì pochi minuti per contestualizzare la programmazione orientata agli oggetti e la genesi del linguaggio Java recuperandone l’epistemologia. Nel procedimento di accertamento dei prerequisiti mi sono sincerato che gli allievi possedessero: • la conoscenza delle nozioni elementari dell’architettura del calcolatore (architettura del

computer, tipologie di memorie, registri) • la familiarità dei tipi nativi e fondamentali messi a disposizione dal linguaggio • la conoscenza di base della struttura minima di un programma scritto in Java, e saperlo scrivere

su un foglio di testo o nell’ambiente di programmazione • il concetto di variabile e costante, come dichiararle e definirle • la dimestichezza nell’utilizzo dei semplici operatori (aritmetici, logici, relazionali),

comprendendone la priorità nel loro utilizzo associativo • conoscenza dell’ambiente di sviluppo integrato (IDE)9 Tutte le lezioni sono state condotte in modo partecipato, sono stati invitati gli allievo sin dall’inizio ad esprimersi liberamente interrompendo (chiedendo la parola per alzata di mano) ogni qual volta avessero avuto dubbi o difficoltà. Questo aspetto è stato particolarmente interessante per l’instaurazione di un buon clima di cooperazione tra insegnante e allievi basata sulla franchezza e sulla reciproca stima e considerazione. Dopo questa introduzione, sono state poste loro alcune domande in modo da suscitare una discussione che permettesse di valutare i prerequisiti. Il tutto è stato svolto in modo assolutamente informale, per evitare che i ragazzi pensassero di essere sottoposti a valutazione; lo scopo era quello di capire come portare avanti il lavoro in modo da creare un collegamento con le loro conoscenze pregresse, facilitandone l’apprendimento. Con l’ausilio delle trasparenze, ho ripercorso le strutture di controllo e i diagrammi di flusso che le governano, tale operazione di recupero dei prerequisiti è stata condotta in maniera agevole e senza sostanziali intoppi, grazie anche al fatto che gli allievi avevano studiato l’anno precedente come linguaggio di programmazione imperativo il linguaggio C la cui sintassi e semantica è analoga al linguaggio Java. Nella seconda lezione, tramite l’ausilio di trasparenze videoproiettate, si sono introdotte le caratteristiche del linguaggio orientato agli oggetti, dopo aver illustrato la necessità dell’industria del software di avere componenti riusabili (“senza dover ogni volta reinventare la ruota”), si è giunti ad affrontare il concetto di classe e oggetto la cui assimilazione rappresentava l’obiettivo finale. Grazie ad esempi tratti dalla vita reale, vedendo la classe come l’idea o la forma e presentando l’oggetto come la realizzazione dell’idea e il prendere forma si è potuto arrivare alla conclusione che un oggetto è una istanza (“esemplare”) di una classe, che viene creato (“instanziato”) dinamicamente. 9 In laboratorio per l’implementazione dei programmi sull’elaboratore si è utilizzato l’ambiente di sviluppo JBuilder X della Borland.

16

Le attività in laboratorio hanno riguardato problematiche squisitamente tecniche (installazione e configurazione dell’ambiente di sviluppo e implementazione del codice realizzato per provarlo e collaudarlo), ma anche momenti di cooperazione in lavoro di gruppo. Quello che si voleva far emergere da queste attività è che la progettazione e realizzazione del software parte dal problema di modellazione della realtà mantenendo un errore di modello contenuto in limiti che risultino accettabili per l’utenza. Dallo scambio di opinioni effettuato con qualche studente al di fuori dell’orario scolastico è emerso che questa fase di tirocinio è stata percepita da più di un allievo come qualcosa di parimenti importante, essendo composta da lezioni poco faticose, divertenti e in sostanza “utili all’ informatica”. Questo giudizio è ovviamente dettato dal modo in cui la disciplina è percepita: gli studenti di questa classe, come notato anche nel periodo di osservazione, sono fortemente condizionati dal contratto didattico per cui la lezione di informatica è poco standardizzata e non consiste nell’introduzione di un nuovo argomento, che permette di risolvere una serie di esercizi sempre più complicati col passare delle lezioni, fino al compito in classe che sancisce la chiusura di un ciclo ed il seguente passaggio a nuovo argomento.

4.1.1. Didattica e software libero Il software utilizzato nell'insegnamento delle (o con le) nuove tecnologie corrisponda ad un "libro di testo". Nel settore se ne sono affermati due: quello che si rifà alla cultura del confronto, rappresentato dai valori del software libero, e quello che possiamo ricollegare alla cultura del "monopolio privato", rappresentato dal software proprietario monopolistico che, per sua natura non ama il confronto e, appena può, lo soffoca al fine di impedire all'utente (consumatore) qualsiasi scelta. Il software libero, come "libro di testo", ha molteplici ragioni per essere adottato nella didattica perché principalmente: non discrimina i soggetti su base economica ma seleziona su base meritocratica; la gratuità delle licenze d'uso tra l'altro è conforme ai criteri stabiliti dalle varie circolari sull'adozione dei libri di testo che si preoccupano di stabilire un tetto di spesa, a seconda del tipo di scuola; permette, sia all'insegnante che all'allievo, l'assoluta libertà di copia, fondamento dello scambio della conoscenza; in questo modo si educa alla legalità non dovendo, nella scuola, ricorrere alla pirateria informatica per svolgere la normale attività educativa; è rispettoso della libertà d'insegnamento, perché permette all'insegnante di scegliere la soluzione e il fornitore che più si adatta alle sue esigenze conoscitive e didattiche; è rispettoso della libertà di parola, perché permette anche all'insegnante, e alla scuola più in generale, di "entrare in gioco" ed essere "soggetto di cultura"; educa alla consapevolezza informatica attraverso la trasparenza, la verifica e la sperimentazione; incentiva l'economia locale valorizzando le risorse umane locali. Ma la ragione avanzata dal software proprietario monopolistico che, a scuola, si debba usare il software secondo il criterio del "più diffuso", ad oggi, ha avuto la meglio, e ha messo all'angolo i valori del software libero sottraendo ai docenti la libertà di scelta nel settore informatico. Per un insegnante usare il software libero significa avere la possibilità di scegliere il proprio libro di testo ed esercitare il diritto della libertà d'insegnamento, ma per scegliere bisogna essere informati (preparati) e consapevoli; in alcuni casi bisogna anche dissentire da ciò che viene "calato dall'alto". Non stupisce perciò se oggi chi per la propria didattica sceglie di lavorare con il software libero, trovandosi isolato nell' "indifferenza generale", trasforma il proprio insegnamento in un insegnamento di libertà. Il Ministro per la Innovazione e le Tecnologie a più riprese ha indicato nell'uso del software libero (chiamandolo "software a codice sorgente aperto") una valida opportunità per la P.A. e al riguardo ha suggerito ai "decisori" di estendere i "buoni esempi". Per riappropriarci della libertà di scelta nelle nuove tecnologie ed essere al servizio della collettività e non degli interessi privati di aziende monopolistiche dobbiamo puntare: sull'autonomia scolastica (delle amministrazioni periferiche); sull'esercizio della libertà d'insegnamento (dei singoli docenti). Dobbiamo fare in modo che gli insegnanti esercitino il loro diritto della libertà di scelta nelle nuove tecnologie, togliendosi di dosso qualsiasi timore reverenziale. Al riguardo dobbiamo procedere in

17

due direzioni: dare impulso ad incontri di informazione e formazione sul software libero per creare informazione e consapevolezza e battere "l'indifferenza generale" prodotta dalle varie alfabetizzazioni del MIUR; creare esempi di didattica con il software libero, creare modelli da diffondere, creare documentazione sul software libero, in maniera da agevolarne la diffusione. Il software libero è rispettoso della libertà d'insegnamento; il software libero è rispettoso della libertà di parola, nel settore informatico; il software libero non discrimina economicamente le persone. Ma solo quando i docenti si saranno riappropriati della libertà di scelta e della libertà d'insegnamento nelle nuove tecnologie potremmo dire di avere una formazione informatica in una scuola aperta e pluralista.

4.2. Gli aspetti emotivi e relazionali L'insegnamento non consiste nella semplice trasmissione di contenuti e teorie ma ha a che fare con le relazioni che sono concomitanti all'apprendimento, quindi ne consegue che il lavoro educativo è sempre un lavoro di gestione: mentre insegna, il docente non deve occuparsi solo delle relazioni interpersonali, ma anche di relazioni di gruppo con l'intera classe, garantendo una qualità educativa che accompagni la crescita sociale e culturale dei singoli e del gruppo (dinamiche sottolineate dal progetto Brocca). La gestione educativa della classe pone il problema di integrare nel lavoro del docente una responsabilità culturale di tipo intellettuale e disciplinare e una responsabilità culturale emotiva affinché possano essere espressi entrambi i versanti dell'apprendimento: quello intellettuale e quello dinamico-emotivo, sostenendo l’allievo verso assetti mentali più adeguati al compito di apprendere. In classe si hanno gli indicatori che definiscono un insegnate capace: competenze tecniche e capacità verbali possono fallire nel lavoro con gli allievi. Occorrono capacità gestionali di contatto, di incoraggiamento e coinvolgimento rispetto agli allievi impegnati a crescere "nell'intimità" (anche scomoda) del gruppo dei pari. L’insegnante deve mantenere sempre reciprocamente attivo l'ascolto e l'empatia con gli allievi a senza scissione tra sentimenti e comportamenti professionali che possono essere percepiti dagli allievi come frapposizione di barriere comunicative. Gestire la responsabilità di un processo educativo è difficile perchè si tratta di un processo di cambiamento e di crescita. Assumersi una responsabilità educativa coinvolge una dimensione relazionale di ascolto e risposta alle domande e ai bisogni delle persone che ci sono affidate e una dimensione giuridica ed etica, dal momento che questa non può essere superficiale perchè coinvolge delle persone. La risorsa professionale più preziosa del docente è la disponibilità emotiva e profonda a incontrare e gestire, dentro e fuori di sé, le emozioni e le ansie evolutive. Gli insegnanti che hanno difficoltà a confrontarsi in modo autentico con la dinamica emotiva della classe e con i diversi stili di apprendimento degli allievi, scindono questa dimensione gestionale. Lo spazio scolastico può essere anti-educativo e anti-evolutivo, se manca la vita di relazione. Nel corso dell’intervento didattico gli allievi si sono dimostrati attenti alle lezioni, partecipativi e motivati, il clima delle lezioni era simile a quello che si instaura in un gruppo di lavoro; E’ stato possibile guidare la classe verso il raggiungimento di un obiettivo di apprendimento prefissato. Vi sono stati momenti in cui, a causa del basso livello della soglia di attenzione e concentrazione che scemava lentamente dopo la seconda ora, gli allievi instauravano un atteggiamento mentale antieducativo, infatti essi si distraevano facilmente e coglievano ogni occasione per cercare di attirare l’attenzione in modo da perdere tempo e ridurre il carico didattico; tale atteggiamento l’ho riscontrato anche quando ho dovuto affrontare la spiegazione di alcuni nozionismi (sintassi e semantica del linguaggio di programmazione Java) rifacendomi ad una didattica tradizionale. Durante le lezioni ho cercato di procedere in modo chiaro per dare la possibilità agli allievi di prendere appunti correttamente, mi sono sembrati volitivi e motivati e alcuni sono intervenuti più volte per avere chiarimenti e per approfondire gli argomenti trattati.

18

Ho potuto constatare che i ragazzi tendono a distrarsi molto facilmente, in alcuni casi intervengono nel corso della lezione in maniera infelice per il solo motivo di perdere tempo. A tal proposito è necessario non lasciarsi fuorviare dai loro interventi, mostrando autorevolezza nel condurli lungo il percorso didattico prefissato. Ho cercato di agevolare e incitare alla partecipazione i ragazzi alle lezioni, coinvolgendoli nella discussione e guidandoli nella risoluzione dei problemi proposti. In laboratorio ho avuto minore difficoltà a gestire la classe e nel contempo ho notato un maggiore impegno da parte dei ragazzi. In tale contesto è stato, infatti, possibile costituire dei gruppi di lavoro di tre soggetti al più. In questo modo è stato possibile responsabilizzare i ragazzi assegnando al gruppo un obiettivo preciso, la loro risposta è stata confortante e si sono dimostrati entusiasti dell’esperienza. Nell’ambito del gruppo è favorita la cosiddetta peer education10. L’ultima ora di ogni intervento è stata destinata alle attività nel laboratorio di informatica, sia per mantenere la soglia di attenzione su livelli decisamente accettabili sia per incentivare la collaborazione e la discussione tra gli allievi. In effetti, la lezione in laboratorio si è rivelata un momento privilegiato nel coinvolgimento degli studenti: il cambio di ambiente anche fisico, in una situazione totalmente sconosciuta, ha portato ad una percezione di una lezione inconsueta e sgravata dal peso della valutazione; si è quindi notata la maggiore disponibilità al dialogo ed al confronto (e quindi all’implicazione personale) anche di alcuni tra gli studenti solitamente più insicuri e titubanti. L’utilizzo del software ha inoltre consentito di concentrare maggiormente l’attenzione sugli aspetti qualitativi dei programmi effettuati e favorito la conversione tra registro logico e pragmatico. In questo clima estremamente positivo, disteso ed estremamente aperto al confronto, le semplici situazioni a-didattiche presentate hanno portato a lezioni dinamiche, dialogate ed estremamente costruttive. 10 J.P. Pourtois, “La ricerca-azione in pedagogia”, in E. Becchi, B. Vertecchi, Manuale critico della sperimentazione e della ricerca educativa, Milano, Angeli, 1988, pp. 134-155

19

4.3. Riflessioni L’esperienza didattica è stata articolata secondo tre momenti o fasi di cui schematicamente si riportano le attività correlate. 1. Fase Preattiva

• Presentazione ai docenti accoglienti e ai tirocinanti del modello di tirocinio da parte del supervisore

• Presentazione scuola, classe, piano di lavoro da parte dei docenti accoglienti al tirocinante • Accordo generale sull’intervento • Osservazione della classe sede di tirocinio • Progettazione dell’intervento didattico (I.D.) e presentazione al supervisore • Confronto con i docenti accoglienti sull’I.D. • Discussione con i docenti SSIS e confronto con gli altri specializzandi • Collegamento tra laboratori e tirocinio per favorire una progettazione didattica funzionale al

processo di insegnamento/apprendimento • Messa a punto dell’I.D.

2. Fase Attiva

• Svolgimento dell’I.D. • Confronto con i docenti accoglienti e il supervisore sull’andamento dell’I.D. • Preparazione degli strumenti di valutazione • Valutazione in itinere del processo di insegnamento/apprendimento • Raccolta del feedback

3. Fase PostAttiva

• Confronto finale con i docenti accoglienti • Discussione conclusiva con il supervisore • Confronto con gli altri specializzandi • Riflessione e relazione conclusiva • Valutazione del processo di formazione

La didattica è un sapere complesso che non si può semplificare, ed è complessa perché ha a che fare con l'insegnante e gli allievi, che hanno una loro personalità, un loro modo di essere e di agire. Apprendere non vuol dire sola conoscenza (sapere), ma anche competenza (saper fare), inoltre l'insegnante deve suscitare il valore formativo delle discipline (perché studiare informatica,….), per fare questo l'insegnante deve aggiornarsi sulla propria disciplina, deve capire come potenzia la capacità di pensiero così da poter motivare i ragazzi sulla epistemologia della materia. L’insegnante deve fare mediazione tra la ricerca e la disciplina in classe. L’informatica come disciplina risente ancora della profonda dicotomia tra disciplina scientifica e sapere tecnologico, è vero sia che possiede una propria epistemologia con tutto il fermento e l’affanno della ricerca scientifica condotta con rigore scientifico, ma è anche collocabile al servizio di altre discipline fornendo un modo di comunicazione alternativo. In virtù di tale considerazione, lo studio dell’informatica, se non correlato a qualcosa di tangibile, di pratico risulta essere poco efficace. Per questa ragione un approccio che proponga come punto di partenza un’ampia varietà di esempi, esercizi e progetti che prendono spunto da molte situazioni e che offrono agli studenti la possibilità di risolvere problemi reali costituisca decisamente un’ottima strategia per l’apprendimento dell’informatica.

20

Ho cercato di proporre la sintassi e l’apprendimento di tali costrutti tramite l’apprendimento per scoperta11 ponendo l’accento sull’itinerario di apprendimento e più precisamente sul suo carattere di processo indipendente e sul fatto che la conquista della verità di una proposizione avviene per conquista autonoma. La scoperta va intesa in senso relativo e cioè come se si fosse i primi a farlo. Una autentica scoperta, anche in senso relativo, richiede non solo l’enunciazione di un’ipotesi attendibile ma anche l’effettiva verifica. Il linguaggio utilizzato nelle spiegazioni non usa volutamente una terminologia accademica e complessa per rendere più accessibili i contenuti ai discenti. Gli argomenti sono corredati da esempi e piccoli progetti, a cui segue l’implementazione al personal computer del laboratorio dopo che è stato realizzata l’analisi logica del problema, la scelta dell’algoritmo, la formalizzazione secondo la terminologia dei diagrammi di flusso e la decodifica in linguaggio Java. Il tutto seguendo gli aspetti caratterizzanti la ricerca-azione, orientata verso l’azione sul campo, conferendo alla didattica un sapere in azione progettuale che si confronta con la realtà. A tal fine di grande aiuto è l’utilizzo di un approccio storico che permette di raggiungere due obiettivi importanti: in primo luogo si tratta di un’impostazione che permette di proporre gli argomenti sotto forma di situazioni problematiche, portando gli studenti nelle stesse condizioni dei ricercatori, in secondo luogo stimola negli studenti la riflessione sul ruolo delle osservazioni e sulla dinamicità e non contingenza del sapere scientifico. Questo approccio è ritenuto opportuno e percorribile in tale senso, si tiene a freno così l’esuberanza e la voglia che gli studenti manifestano di poter mettersi subito a programmare perdendosi nei tecnicismi e uscendo dall’iter teorico e di progettualità che devono adottare e fare proprio come paradigma. Durante tutto l’intervento didattico, le teorie proposte sono state presentate come interpretazioni dei fenomeni osservati, cercando di non confondere mai il livello empirico con il modello interpretativo. E’ un aspetto molto importante, perché contribuisce a smantellare la concezione di scienza come prodotto preconfezionato, che a volte viene trasmessa ai ragazzi durante i livelli inferiori di scuola secondo cui scienza e verità sono sinonimi. Troppo spesso la scuola contribuisce al perpetuarsi del pensiero empirico-realista, secondo cui il sapere scientifico è un insieme di conoscenze provate e oggettive ed è quindi sempre corrispondente al vero. Un buon insegnante di scienze debba trasmettere ai suoi studenti l’idea che le teorie scientifiche non rispecchiano la realtà, ma sono delle interpretazioni coerenti e logiche della realtà, e per far questo, il docente dovrà presentare i modelli interpretativi dei fenomeni trattati come il frutto di un lungo cammino compiuto dagli scienziati. Come materiale di supporto didattico mi sono avvalso di una presentazione in formato elettronico che ho utilizzato come preambolo di ogni lezione, per riprendere velocemente gli argomenti trattati e per introdurre i nuovi, per i contenuti delle trasparenze utilizzate si rimanda all’Allegato B. Inoltre, a compendio del libro di testo adottato dall’insegnante, ho fornito una dispensa sia in formato cartaceo che in formato elettronico con i contenuti teorici essenziali e con i testi degli esercizi con cui gli allievi si sono cimentati, per il contenuto delle lezioni si rimanda all’Allegato C. Come si evince dalla struttura di tale dispensa, il messaggio che traspare e che ho ribadito durante gli incontri, è che la programmazione, qualunque sia il linguaggio adoperato e la tecnologia scelta, consta di fasi in cui un posto di rilievo va sicuramente delegato alla riflessione sulle specifiche e sul testo del problema al fine di ricavare l’intuizione e il “modus operandi” logico che permetta in maniera efficace ed efficiente di giungere alla risoluzione voluta. In questa fase di riflessione, l’allievo deve essere in grado di capire il problema che gli è stato sottoposto dal puro punto di vista dell’intelligibilità, poi deve articolare la metodologia di riconoscimento delle strutture dati e del loro tipo da utilizzare per contenere le variabili necessarie, quindi abbozzare il diagramma di flusso contenente l’algoritmo risolutivo.

11

21

Se il collaudo su carta del diagramma porta a buon fine allora si può iniziare con la fase di transcodifica usando la sintassi e la semantica del linguaggio implementativo. E’ buona norma scrivere il codice su carta per familiarizzare con le strutture cardine del linguaggio e assimilare i tecnicismi e con le parole chiavi del linguaggio, poi l’ultimo passo è la stesura del listato in formato elettronico utilizzando l’ambiente di sviluppo e usufruendo dell’ambiente di debug integrato per il collaudo della realizzazione. La scelta di fornire agli studenti tale impostazione è stata condivisa anche dal docente accogliente, che la pensava già nel modo suddetto, in effetti quando si entra in laboratorio i computer, notevole fonte di distrazione, sono spenti e solo quando bisogna collaudare il listato è possibile l’accesso. Nonostante le difficoltà riscontrate, nel complesso ritengo comunque abbastanza soddisfacente l’esperienza di tirocinio. Gli strumenti di didattica dell’informatica si sono rivelati efficaci per un’analisi critica della natura e dei limiti dei processi di apprendimento, ma anche delle strutture e dei metodi utilizzati. E’ essenziale possedere strumenti adeguati di analisi che consentano di prenderne piena coscienza, per poi sperimentare percorsi alternativi ed effettuare ulteriori valutazioni nel continuo tentativo di migliorarsi. L’insegnante in questo senso è anche ricercatore: deve preparare materiale didattico, valutare e sperimentare approcci alternativi, tenersi informato sugli sviluppi della didattica, confrontarsi con i colleghi e con gli stessi studenti nel tentativo continuo di migliorare se stesso, la sua professionalità e competenza12. Ovviamente tutto questo avverrà, in futuro, in tempi assai più compressi rispetto a quelli riservati a questa esperienza di tirocinio ed in ambienti sicuramente meno rassicuranti e collaborativi. Tengo a sottolineare che dal punto di vista strettamente personale, ritengo l’esperienza descritta in questa trattazione estremamente formativa e coinvolgente. L’accoglienza riservatami dall’ambiente classe è stata positiva oltre ogni previsione, i ragazzi hanno accettato la mia presenza con disponibilità e sincero entusiasmo, creando un clima in classe di collaborazione e confidenza inaspettato. A questo clima ha contribuito anche il docente accogliente, entusiasta in particolare delle lezioni in laboratorio e del relativo trasporto e partecipazione con cui queste sono state accolte dagli studenti.

4.4. Progettazione della verifica La progettazione della verifica sommativa non può essere scissa dalla forma di valutazione; mi sono ispirato alla valutazione autentica13 che nasce da un’esigenza di coerenza con le caratteristiche di un “apprendimento significativo”14, tale istanza discende dal costruttivismo (Piaget): “io apprendo in quanto costruisco il mio sapere”. Le istanze di rendicontazione per la valutazione autentica impongono che bisogna valutare non solo ciò che un ragazzo “sa” (sapere riproduttivo), ma anche la costruzione e lo sviluppo delle conoscenze, la capacità di applicazione al reale di quanto si è appreso, ponendo attenzione al processo dell’apprendimento e alla capacità di applicare le conoscenze acquisite in contesti reali. Gli aspetti presi in considerazione dalla valutazione autentica15 sono:

• capacità di pensiero critico, esprimere un giudizio sulla base di criteri giustificabili;

12 M. Pellerey, Progettazione didattica, Torino, SEI, 1983. 13 Corso di Docimologia di Castoldi, Definizione di valutazione autentica secondo Wiggins (1993; 1998): “valutare ciò che lo studente sa fare con ciò che sa”. 14 Apprendimento che modifica la “struttura cognitiva” di chi apprende 15 M. Comoglio, “La valutazione autentica”, Orientamenti pedagogici, vol. 49, n. 1, gennaio-febbraio 2002.

22

• metacognizione, fa riferimento alla consapevolezza delle strategie mentali che il soggetto mette in atto e alla sua capacità di migliorarle;

• capacità di Problem Solving; • ragionamento inteso come capacità di partire da premesse e portare avanti un

ragionamento deduttivo; • capacità di lavorare in gruppo in situazione concreta di vita.

In una parola possiamo dire che la valutazione autentica serve per valutare le competenze. I test tipici richiedono solo una risposta corretta, il compito autentico invece richiede un prodotto di qualità è una giustificazione della realizzazione o processo (prodotto = frutto, processo = elaborazione). Le prove tradizionali fanno riferimento a situazioni fittizie, quelle della valutazione autentica invece si riferiscono a quelle che si creano nella realtà. La prova somministrata all’ITIS Avogadro è riportata in allegato C. Per le verifiche formative e per le prove di laboratorio in itinere ho pensato di assegnare degli items che richiedessero agli allievi capacità di comprensione dei concetti OOP: ( "cosa stampa il seguente codice OOP ... ? ", "completare le parti mancanti affinché il comportamento sia il seguente ..." ) e che capacità di progettazione o sintesi di codice OOP ("implementare una data interfaccia di classe", "proporre un'interfaccia di classe per oggetti aventi un certo comportamento",-"individuare le classi degli oggetti e le loro relazioni (is, has, uses) da una realtà descritta a parole"). Segue un esempio frutto di un’esercitazione di laboratorio.

Esempio:

Progettare la classe LISTINO_PREZZI così come viene normalmente inteso nel senso comune (sapere se c'è una certa merce e quanto costa, cambiare il prezzo, ecc. ).

a) proporre una coerente e completa interfaccia di classe, scegliendo con cura i nomi e giustificando le scelte fatte qualora ciò si renda necessario;

b) implementare l'interfaccia in un linguaggio OOP

c) proporre un esempio d'uso (ad. es. un programma principale di prova).

23

4.5. Valutazione del lavoro fatto dagli studenti La valutazione16 è l’espressione da parte del docente di un giudizio su ogni singolo allievo in riferimento ad almeno due componenti dell’educazione: l’insieme delle capacità raggiunte; il grado di implicazione personale. Il processo valutativo riguarda quindi solo in parte le competenze raggiunte dallo studente, non esclusivamente a livello dell’assegnazione di un “voto” basato sul risultato e sull’impegno, ma studiandone il lavoro di costruzione della conoscenza con l’occhio critico e gli strumenti acquisiti dagli studi in didattica dell’informatica. Strumenti che servono anche per la valutazione del proprio lavoro compiuto in aula, in conformità con i risultati ottenuti dagli studenti, analizzando il proprio operato e ripensando in maniera critica alle proprie strategie metodologiche ed alle scelte effettuate, segmento curricolare compreso. La valutazione è dunque complessa e multidimensionale, così come lo è l’intricato processo sistemico di insegnamento-apprendimento, per cui per valutazione non deve intendersi solamente il bilancio dell’attività svolta, essa è infatti stata attuata lungo tutto l’arco di lezioni del progetto di tirocinio, è parte integrante del processo di insegnamento-apprendimento ed ha influenzato continuamente contenuti e metodologia del lavoro in aula.

Si valuta anche per effettuare scelte a livello di contenuto e circa la metodologia del lavoro in aula; per prendere decisioni circa l’ambiente classe e non ultimo per comunicare agli allievi, spesso implicitamente, quel che è importante . Per quel che riguarda la valutazione dell’ambiente classe devo dire che non è facile per un tirocinante influire in maniera decisiva in ambiente forgiato da mesi e mesi di collaborazione con l’insegnante titolare che, peraltro, è presente durante le lezioni. Cambiare le abitudini degli studenti, infondendo il gusto per l’esplorazione e la sperimentazione, dando la giusta importanza alla risoluzione dei problemi e alla scoperta, spostando l’attenzione dai risultati ai processi, è una trasformazione radicale che nella prima metà di tirocinio è tuttavia parsa possibile. Nel perseguire questo cambio di prospettive, verso un’implicazione personale dello studente, obiettivo primario in un’ottica costruttivista, è fondamentale l’ambiente d’aula; infatti il superamento della semplice conoscenza verso la competenza si esplicita anche attraverso atteggiamento, volizione, gusto e stabilendo una relazione positiva tra menti, comprendendo e valorizzando le risorse emotive a disposizione17.

16 L.S. Beccegato-B.M. Varisco, Docimologia. Per una cultura della valutazione, Milano, Guerini, 2000. 17 Pombeni, M.L., “L’adolescente e la scuola”. In A. Palmonari (a cura di), Psicologia dell’adolescenza, Bologna, Il Mulino, 1997, pp. 271-291

24

E’ evidente che non si valutano gli studenti, o meglio il loro lavoro, esclusivamente allo scopo di assegnare loro un voto, e questo dovrebbe essere ben chiaro anche agli stessi allievi, ma per scardinare l’associazione del termine valutazione con “voto sul registro” occorrerebbe un lavoro a lungo termine, possibilmente in collaborazione con gli altri docenti ma anche con le famiglie e l’ambiente esterno in generale18. Durante tutto il periodo del tirocinio si è prestata particolare attenzione al comportamento tenuto in aula dagli studenti, il modo in cui lavorano, ascoltandoli esporre le loro idee, prendendo gli errori come spunto di partenza di discussioni anziché semplicemente correggerli, nel tentativo di valutare per ogni allievo il grado di implicazione personale raggiunto nel processo di apprendimento. Mediamente considero soddisfacente l’esperienza da questo punto di vista, la disponibilità ed il coinvolgimento sincero, in generale, mi sono parsi notevoli, nettamente al di sopra delle mie aspettative. Per esempio è accaduto più volte che alcuni allievi abbiano risolto a casa esercizi non assegnati e ne abbiano poi richiesta la correzione in classe. A volte le stesse domande spontanee degli studenti hanno portato ad approfondimenti in maniera naturale, guidata dal gusto del sapere e della scoperta. Ovviamente il grado di coinvolgimento all’interno della classe ha assunto sfumature diverse, ci sono anche studenti che si sono estraniati dalle lezioni, intervenendo solo quando direttamente chiamati in causa (chi per disinteresse, chi per carattere, chi perché in quel momento aveva altro per la testa) o quando si accorgevano che l’insegnante li stava osservando. Nel complesso processo di valutazione rimane ad ogni modo inclusa anche l’assegnazione del voto, perseguendo non tanto la chimera dell’oggettività quanto la coerenza e l’equità. Affinché dunque un voto sia giudicato equo occorre anche in questo caso l’implicazione personale dello studente, una responsabilizzazione molto forte difficile da ottenere sul breve periodo. Ho pertanto potuto assicurare professionalità, chiarezza e trasparenza, godendo di una ampia fiducia da parte degli studenti derivata probabilmente anche in questo caso dal ruolo di professore “a tempo determinato”, e in quanto tale giudicato libero da pregiudizi che condizionano un insegnante di lunga data. Nella verifica sommativa, sia in momenti di valutazione non istituzionalizzati, i criteri che hanno guidato, per il processo di valutazione degli studenti ho applicato i seguenti criteri: • il criterio di realizzazione: la messa in atto di strategie adeguate a fronte di situazioni

problematiche. Ad esempio l’impostazione di una risoluzione adeguata, la schematizzazione della situazione, l’utilizzo di grafici, ma anche la giustificazione del comportamento seguito per giungere alla soluzione, essere in grado argomentarne e giustificarne i passaggi.

• il criterio di risultato: saper condurre il processo risolutivo secondo un comportamento logico, giungendo alla risposta giusta. Ma anche saper giustificare che la via scelta è la più idonea, la più economica. • Il criterio di comprensione: saper esporre il risultato ottenuto, metterlo in relazioni

con altri in situazioni diverse. Si è inoltre cercato di rendere palese, ogni volta fosse possibile, l’importanza del processo rispetto al risultato, ma sradicare convinzioni costruite in anni di scolarizzazione non è affatto banale. Per la correzione delle prove ho utilizzato la griglia di valutazione di seguito riportata, in cui ho distinto dei livelli associandone il giudizio di valore secondo i criteri riportati, il voto attribuito espresso in decimi può essere il risultato della combinazione di livelli diversi di conoscenze, competenze, capacità e comportamenti19. Dall’analisi dei risultati si evince che i gli allievi sono riusciti ad individuare le classi e gli oggetti necessari per la risoluzione del tema, qualcuno ha avuto problemi nello strutturarne il diagramma, le principali difficoltà sono incontrate nell’implementazione nel linguaggio Java e nella scrittura delle procedure.

18 G. Domenici, Manuale della valutazione scolastica, Bari, Laterza, 2001. 19 B.M. Varisco- L. Santelli, Docimologia. Per una cultura della valutazione, Milano, Guerini e associati, 2000.

25

Griglia di Valutazione

Conoscenze Competenze Capacità Comportamenti Livelli Voto in decimi

Complete, con approfondimenti autonomi

Affronta autonomamente anche compiti complessi, applicando le conoscenze in modo corretto e creativo

Comunica in modo proprio, efficace ed articolato; è autonomo ed organizzato; collega conoscenze attinte da ambiti pluridisciplinari; analizza in modo critico, con un certo rigore; documenta il proprio lavoro; cerca soluzioni adeguate per situazioni nuove

Partecipazione : costruttiva Impegno: notevole Metodo : elaborativo

A 9 -10

Sostanzialmente complete

Affronta compiti anche complessi in modo accettabile

Comunica in maniera chiara ed appropriata ; ha una propria autonomia di lavoro; analizza in modo complessivamente corretto e compie alcuni collegamenti, arrivando a rielaborare in modo abbastanza autonomo

Partecipazione: attiva Impegno: notevole Metodo: organizzato

B 8

Conosce gli elementi essenziali, fondamentali

Esegue correttamente compiti semplici; affronta compiti più complessi pur con alcune incertezze

Comunica in modo adeguato, anche se semplice; non ha piena autonomia, ma è un diligente ed affidabile esecutore; coglie gli aspetti fondamentali, ma incontra difficoltà nei collegamenti interdisciplinari.

Partecipazione: recettiva Impegno: soddisfacente Metodo: organizzato

C 7

Complessivamente accettabili; ha ancora lacune, ma non estese e /o profonde

Esegue semplici compiti senza errori sostanziali; affronta compiti più complessi con incertezza

Comunica in modo semplice, ma non del tutto adeguato; coglie gli aspetti fondamentali, ma le sue analisi sono lacunose

Partecipazione: da sollecitare Impegno : accettabile Metodo : non sempre organizzato

D 6

Incerte ed incomplete

Applica le conoscenze minime, senza commettere gravi errori, ma talvolta con imprecisione

Comunica in modo non sempre coerente e proprio; ha difficoltà a cogliere i nessi logici e quindi ha difficoltà ad analizzare temi, questioni e problemi

Partecipazione: dispersiva Impegno : discontinuo Metodo : mnemonico

E 5

Frammentarie e gravemente lacunose

Solo se guidato arriva ad applicare le conoscenze minime; commette gravi errori anche nell’eseguire semplici esercizi

Comunica in modo decisamente stentato e improprio; ha difficoltà a cogliere i concetti e le relazioni essenziali che legano tra loro i fatti anche più elementari

Partecipazione: opportunistica Impegno: debole Metodo: ripetitivo

F 3 - 4

Nessuna Nessuna Nessuna Partecipazione: di disturbo Impegno: nullo Metodo: disorganizzato

G 1 – 2

26

Gli elaborati hanno ottenuto i risultati riportati nel grafico sottostante:

La media complessiva dei voti è stata 6,9 e sono state assegnate cinque insufficienze. Anche a giudizio del docente accogliente il compito ha ottenuto risultati complessivamente soddisfacenti, addirittura migliori rispetto a quelli delle precedenti verifiche. Le difficoltà che si incontrano nell'insegnamento della OOP non consistono tanto nel far apprendere i meccanismi di base (creazione di oggetti e di classi) quanto nel cambio di atteggiamento che occorre far assumere gli allievi nell'affrontare i problemi, cioè nel far loro adottare una corretta metodologia di progettazione OOP. Tipicamente gli allievi tendono a non riconoscere le classi nella descrizione a parole di una certa realtà. Anche quando le riconoscono non scelgono in modo appropriato i metodi, tralasciandone alcuni di essenziali, dimenticando di applicare il principio di information hiding, ecc. In altre parole quella che viene spesso a mancare è la capacità di astrazione, ancora forse non troppo sviluppata a questa età. Un'altra fonte di errori frequenti, causata da questa tipica limitazione, è costituita dall'ereditarietà: non costruiscono adeguatamente le gerarchie di classi, specie quelle in cui occorrerebbe introdurre delle classi astratte. La confusione tra relazioni is e has è un'altra delle cause di strutturazioni non appropriate. Un consistente miglioramento per l'apprendimento della adeguata metodologia di programmazione anche per i problemi comuni è stata apportato, almeno in parte, con un'adeguata scelta di alcuni item significativi che insistevano sulle lacune palesate dagli allievi durante i loro interventi, per ciascuno di essi ho proposto la soluzione ottimale mettendola a confronto con quelle proposte dagli studenti stessi.

27

5. Conclusioni All’interno del percorso biennale previsto dalla Scuola di Specializzazione per l’Insegnamento Secondario, struttura didattica interateneo che ha come obiettivo la formazione degli insegnanti della scuola secondaria, il tirocinio riveste un ruolo di primaria importanza perché in esso confluiscono tutte le conoscenze e le riflessioni metodologiche, didattiche, epistemologiche e sociologiche acquisite nei vari corsi frequentati e perché mi ha permesso, per me che non avevo mai avuto esperienze lavorative nell’ambito della scuola, di confrontarmi con tutti gli aspetti propri dell’attività lavorativa scolastica (pratici, didattici, collegiali, gestionali, educativi e relazionali). In questo quadro, il tirocinio non può essere pensato come momento isolato nel processo di formazione del futuro docente. Questa attività permette agli specializzandi di entrare a diretto contatto con le scuole, prima nella fase osservativa e poi in quella attiva, in cui si effettua una vera e propria esperienza d’insegnamento. Il carattere formativo del tirocinio è favorito dalla pluralità dei soggetti coinvolti (docente accogliente, supervisore, relatore…) assieme a cui lo specializzando elabora il suo progetto didattico, ne gestisce la realizzazione e ne valuta l’efficacia, permettendo un proficuo confronto tra le diverse esperienze e competenze. Con le esperienze di tirocinio attivo ho portato spesso, all’interno delle classi, innovazioni didattiche e metodologiche apprese nei corsi e nei Laboratori SSIS che consentono anche ai docenti accoglienti di fare tesoro dell’esperienza acquisita attraverso gli specializzandi, divenendo un momento importante di crescita per il sistema d’istruzione nel suo complesso. La Scuola di Specializzazione può quindi essere pensata come il luogo di mediazione tra l’attività di formazione, svolta assieme ai Supervisori per il tirocinio ed in collaborazione coi docenti accoglienti, e la ricerca nell’insegnamento e nella didattica, che va ben al di là della trasmissione di conoscenze e che permette un proficuo collegamento tra il mondo della scuola e quello dell’università. La frequenza del biennio SSIS si pone come obiettivo la formazione di docenti capaci di individuare opportunamente i problemi teorici e operativi in campo educativo e formativo e di applicarli tenuto conto delle caratteristiche cognitive dell’alunno. L’insegnante consapevole delle modalità con cui i diversi apporti delle scienze umane diventino condizioni per l’impostazione unitaria del progetto educativo, dovrebbe essere in grado di progettare interventi didattici per obiettivi, per ricerca didattica e problem solving, individuando le strategie più efficaci in relazione alla situazione di contorno in cui è chiamato ad operare. Allora chi è e come dovrebbe essere l’insegnante perfetto? Le competenze professionali derivano dall’insieme delle attitudini personali, dalla motivazione, dal bagaglio culturale e dell’esperienza, pertanto, se è vero che ognuno ha una propria personalità che influenza il modo di rapportarsi col mondo esterno, è anche vero che non ci si deve adagiare e che ogni insegnante deve impegnarsi a fondo per crescere dal punto di vista professionale. Il percorso della S.I.S. penso sia tarato con i vari corsi per chiarire a noi specializzandi per fornire gli spunti e le piste da seguire per ricercare una professionalità del docente. Ritengo che per essere un buon insegnante non sia sufficiente essere preparati nella propria disciplina, anche se questa è una condizione da cui non è possibile prescindere. Nell’insegnamento non esistono soluzioni standard adatte ad ogni situazione, ma l’insegnante competente è un professionista che, basandosi sul proprio bagaglio di conoscenze, sa trovare il modo migliore di gestire le situazioni più disparate. Concordo con quanto l’affermazione che “si è competenti quando si decidono le azioni mentre le si compiono, le si valuta e le si corregge seduta stante, si esplorano gli elementi impliciti nelle relazioni stesse per tenerne conto di quelle immediatamente successive, si ristrutturano significati e fini contemporaneamente all’impiego di determinati mezzi, si scopre, si genera e si condivide un senso che si adatta e segue ogni modificazione dei dati del sistema e delle dinamiche relazionali che le accompagnano”20. 20 Dispense del corso di Didattica generale, prof.ssa Pavone, S.I.S. Piemonte, A.A. 2004-2005

28

I problemi vanno affrontati tempestivamente prendendo in considerazione approcci alternativi, scegliendo opportunamente tra questi, elaborando e realizzando adeguati piani d’azione. Bisogna saper riconoscere i segnali d’allarme prima che la situazione degeneri e ciò consente di prendere tempo per adottare soluzioni risolutive o sospensive a seconda dei casi. Non si rischia di perdere il controllo perché non si ha bisogno di controllare nulla, la situazione viene gestita apparentemente senza sforzo perché è l’intero contesto che è stato organizzato funzionalmente agli obiettivi. Dovrebbero essere proposti modelli che riducano tutto l’impegno professionale nella trasmissione dei contenuti disciplinari o che assorbano tutto l’impegno del docente nella cura clinica degli aspetti psicologici e sociali della personalità è assurdo quanto pensare che sia possibile trasmettere alcunché senza la predisposizione del soggetto all’apprendimento o che sia possibile risolvere i problemi della persona senza la mediazione culturale. Il valore del modello è quello d’idea guida per la costruzione non del comportamento dell’insegnante, ma dello stile d’insegnamento come atteggiamento. La conoscenza d’alcuni modelli estremi può essere utile ai fini della formazione iniziale dell’insegnante per mostrare alcuni elementi primari di una funzione altrimenti non approcciabile che per intuizione ed immedesimazione. E’ solo la comprensione che viene dall’esperienza professionale che consente di utilizzare i modelli per una riflessione critica sullo sviluppo della propria professionalità. Per muoversi nella complessità della scuola, l’insegnante dovrebbe costruirsi dei punti di attenzione che gli permettano di sorvegliare l’intera situazione, un cruscotto denso di sofisticati sensori da monitorare durante la conduzione del proprio intervento didattico. Per l’insegnante, l’opera di predisposizione di strumenti e soprattutto d’attivazione degli indicatori è onore ed onere personale. Il momento della conoscenza e della decisione in educazione non possono essere delegati a nessun altro, fatte salve le ovvie e debite risorse d’apporti specialistici, che però devono sempre essere adatti al contesto ed alla situazione. In educazione non è sempre semplice o privo di conseguenze il recupero dell’errore e della distrazione. Per i comportamenti automatici, manca totalmente spazio nel concetto di insegnante, basato sulla consapevolezza e responsabilità più che sull’accensione di luci che stimolino per condizionamento risposte automatiche. Il nostro allievo deve poter essere messo in grado di sviluppare le capacità di analizzare e risolvere problemi di varia natura, deve interpretare il problema e costruirne la soluzione, inoltre deve essere in grado di inserirsi in un lavoro di gruppo. L’insegnante dovrà aiutare l’allievo per portarlo all’acquisizione della mentalità informatica coadiuvandolo nel potenziamento delle capacità richieste (astrazione, generalizzazione, associazione, dipendenze, correlazioni), modellazione coerentemente la realtà per descrivere le entità e le relazioni che costituiranno la base dati, applicazione degli algoritmi e delle strutture in maniera ottimale senza trascurare gli aspetti organizzativi e motivazionali. Ho potuto constatare che nell’insegnamento dell’informatica bisogna saper modulare gli approcci didattici utilizzandoli a seconda della circostanza, per creare la situazione ottimale nel processo di insegnamento-apprendimento che consenta all’allievo di ampliare la propria mappa concettuale, riorganizzando i concetti e facendo sorgere un vivo interesse e un atteggiamento positivo per lo studio delle discipline tecniche. L’insegnante non ha il compito di trasmettere conoscenze, ma deve possedere una serie di competenze che gli permettano di guidare i suoi allievi in un cammino di vita volto a formare la loro personalità. Oggi la scuola ha assunto una nuova centralità: se un tempo poteva essere considerata l’unica agenzia di socializzazione secondaria (la primaria è rappresentata dalla famiglia), oggi ci sono nuove agenzie (i mezzi di comunicazione di massa, il gruppo dei pari) con cui la scuola non può fare a meno di rapportarsi. Anzi proprio alla scuola spetta il compito di fornire ai ragazzi gli strumenti di criticità per rapportarsi con le nuove agenzie di socializzazione. Ed è proprio questo il contesto in cui si delinea la figura del docente moderno al quale si chiede di possedere competenze che vanno al di là della preparazione in ambito disciplinare.

29

Ma quali sono queste competenze? Senza volendo racchiuderle in un canovaccio deterministico e fuori da compartimenti stagni, un insegnante deve compendiare in sé almeno quattro livelli di competenze: disciplinari, relazionali, metodologiche-didattiche ed organizzative. Il tendere verso il modello del perfetto insegnante deve procedere senza disilludersi o provare frustrazione per i propri errori, anzi, l’abilità consiste proprio nel trasformare gli errori in occasione di crescita ricordando sempre che un buon motto per un insegnante può essere “mettiamoci in discussione e cresciamo insieme con i nostri allievi”. L’insegnante perfetto è un modello, rimane una chimera, anzi un’idea che anche la mano di un consumato demiurgo platoniano farebbe fatica a plasmare.

30

Bibliografia 1. Roletto E., Apprendimento delle Scienze e Didattiche disciplinari, IRiDiS, Torino, 2003 2. Blandino G., Granieri B., La disponibilità ad apprendere. Dimensioni emotive nella scuola e

formazione degli insegnanti, Ed. Raffaello Cortina, Milano 1995 3. Blandino G., Granieri B., Le risorse emotive nella scuola, Ed. Raffaello Cortina, Milano 2002 4. Fischer L., Sociologia della scuola, Il Mulino, Bologna, 2003 5. Damiano E., L’azione didattica, Armando, Roma, 1993 6. Damiano E., Insegnare con i concetti. Un modello didattico fra scienza e insegnamento, Ed.

SEI, Torino, 1994 7. Calvani A., Elementi di didattica, Carocci, Roma, 2000 8. Mariani A. M., Dispense del corso di Pedagogia Generale, S.I.S., Torino, A.A. 2004-2005 9. Pavone M., Dispense del corso di Didattica Generale, S.I.S., Torino, A.A. 2004-2005 10. Borca G., Dispense del corso di Psicologia dello Sviluppo, S.I.S., Torino, A.A. 2004-2005 11. Coggi C, Notti A. M., Docimologia, Pensa Multimedia, Lecce, 2002 12. Domenici G., Manuale della valutazione scolastica, Laterza, Bari, 2001 13. Meyer B, Object Oriented Software Construction, Prentice Hall, 1997. 14. Coad P., Jill N., OOP. Programmazione dei sistemi orientati agli oggetti, Jackson Libri, 1999 15. Cox B. J., Programmazione orientata agli oggetti, Addison Wesley Longman Italia, 2000 16. Wu C. T., Introduzione alla programmazione a oggetti in Java, McGraw-Hill Libri Italia, 2000

31

Introduzione al linguaggio Java 1

1

Introduzione al linguaggio Java 1 Introduzione al linguaggio Java 2

INTRODUZIONE AL LINGUAGGIO JAVA

Introduzione al linguaggio Java 3

INDICE

Parte 1 Introduzione al sistema di program-mazione Java

Parte 2 Programmazione a oggetti

Parte 3 Il linguaggio Java

Introduzione al linguaggio Java 4

PARTE 1

INTRODUZIONE AL SISTEMA DI PROGRAMMAZIONE JAVA

Introduzione al linguaggio Java 5

CARATTERISTICHE

Introduzione al linguaggio Java 6

CHE COS’È JAVA

• È un linguaggio (e relativo ambiente di programmazione) definito dalla Sun Microsystems …

• … per permettere lo sviluppo di applicazioni sicure, performanti e robuste su piattaforme multiple, in reti eterogenee e distribuite (Internet)

Introduzione al linguaggio Java 2

2

Introduzione al linguaggio Java 7

IL LINGUAGGIO JAVA: CARATTERISTICHE

• Semplice e orientato agli oggetti• Interpretato• Architetturalmente neutro e portabile• Robusto • Distribuito• Sicuro• Dinamico• Ad elevate prestazioni• Concorrente (multithread)

Introduzione al linguaggio Java 8

SEMPLICE E OO

• Sintassi simile a C e C++ (facile da imparare)• Elimina i costrutti più "pericolosi" di C e C++

– aritmetica dei puntatori– (de)allocazione esplicita della memoria– strutture (struct)– definizione di tipi (typedef)– preprocessore (#define)

• Aggiunge garbage collection automatica• Conserva la tecnologia OO di base di C++• Rivisita C++ in alcuni aspetti (C++--==)

Introduzione al linguaggio Java 9

• Il compilatore produce un codice di tipo intermedio per una “Java Virtual Machine” (“byte-code”) ...

• … che viene interpretato

INTERPRETATO

codicesorgentecodice

sorgente byte codebyte codecompilatorecompilatoreinterpreteinterprete

Introduzione al linguaggio Java 10

BYTECODE: ESEMPIO

void spin ( ) {int i;for (i = 0; i < 100; i++) {

;}

} 0 iconst_0 // push int constant 01 istore_1 // store into local 1 (i=0)2 goto 8 // first time, don’t increment5 iinc 1 1 // increment local i by 1 (i++)8 iload_1 // push local 1 (i)9 bipush 100 // push int constant (100)11 if_icmplt 5 // compare, loop if < (I<100)14 return // return void when done

Introduzione al linguaggio Java 11

ARCHITETTURALMENTE NEUTRO

• Il byte-code è indipendente dall’architettura hardware (ANDF: Architecture Neutral Distribution Format)

• Pertanto, un programma bytecode può essere eseguito su qualsiasi sistema su cui giri un ambiente run-time Java

Introduzione al linguaggio Java 12

ESEMPIOSistema tradizionale

codicesorgentecodice

sorgente

eseguibilemacchina Aeseguibile

macchina Acompilatoremacchina A

compilatoremacchina A

Sistema ANDF

eseguibilemacchina Beseguibile

macchina B

compilatoremacchina B

compilatoremacchina B

…….

codicesorgentecodice

sorgente byte codebyte code

compilatoremacchina A

compilatoremacchina A

compilatoremacchina B

compilatoremacchina B

…….

interpretemacchina Ainterprete

macchina A

interpretemacchina Binterprete

macchina B

…….

Introduzione al linguaggio Java 3

3

Introduzione al linguaggio Java 13

ESEMPIO

• Il formato dei dati è specificato esattamente, e non “di minima”, come nel C:

– byte 8 bit complemento a 2– short 16 bit “– int 32 bit “– long 64 bit “– float 32 bit IEEE 754 floating– double 64 bit “– char 16 bit Unicode

Introduzione al linguaggio Java 14

• Il sistema Java (compilatore + interprete + librerie run-time) è facilmente portabile su piattaforme diverse

PORTABILE

– il compilatore Java è scritto in Java– l’ambiente run-time è scritto in ANSI C con interfacce

standard (POSIX) verso il sistema operativo– nessuna “implementation dependency”

codicesorgentecodice

sorgente byte codebyte codecompilatorecompilatore interpreteinterprete

librerialibreria S.O.

Introduzione al linguaggio Java 15

ROBUSTO

• Controlli estensivi a compile-time e a run-time, per rilevare gli errori quanto prima possibile (es.: type checking)

• Per questo, le caratteristiche insicure di C e C++ sono rimosse:

– Nessuna gestione esplicita dei puntatori (no aritmetica dei puntatori, no malloc e free esplicite, …)

– Gestione della memoria con garbage collection– Array e stringhe “veri”

• Verifica del byte-code a load-time

Introduzione al linguaggio Java 16

DISTRIBUITO

• Pensato per essere eseguito in rete• L’ambiente run-time incorpora funzioni di rete

(sia di basso livello: TCP/IP, che di alto livello: HTTP, …)

• La rete è facilmente accessibile (come i file locali)

Introduzione al linguaggio Java 17

SICURO

• L’ambiente di esecuzione si protegge da bytecodepotenzialmente “ostile”

• Esempi:– il bytecode viene verificato prima dell’interpretazione

(“theorem prover”), in modo da essere certi di alcune sue caratteristiche

– gli indirizzamenti alla memoria nel bytecode sono risolti sotto il controllo dell’interprete

Introduzione al linguaggio Java 18

COMPILE-LOAD-RUN

CompilatoreCompilatore

Byte-codeJava

Byte-codeJava

Rete

hardwarehardware

Loaderdelle classi

Loaderdelle classi

InterpreteInterprete

Ambienterun-time

Ambienterun-time

Verifica delbyte-code

Verifica delbyte-code

SorgenteJava

SorgenteJava

Introduzione al linguaggio Java 4

4

Introduzione al linguaggio Java 19

ELEVATE PRESTAZIONI

• La verifica del bytecode permette di saltare molti controlli a run-time: l’interprete è pertanto efficiente

• Per maggiore efficienza, possibilità compilazione on-the-fly del bytecode in codice macchina

Introduzione al linguaggio Java 20

COMPILAZIONE ON-THE-FLY

CompilatoreCompilatore

Byte-codeJava

Byte-codeJava

Rete

hardwarehardware

Loaderdelle classi

Loaderdelle classi

InterpreteInterprete

Ambienterun-time

Ambienterun-time

Verifica delbyte-code

Verifica delbyte-code

SorgenteJava

SorgenteJava

Generatoredi codice

Generatoredi codice

Introduzione al linguaggio Java 21

DINAMICO

• Il codice è eseguibile anche in assenza di alcuni moduli:

• … le classi necessarie per la esecuzione di un programma Java possono essere caricate e collegate dinamicamente quando servono

Esempio: nuove release di moduli caricabili automaticamente dalla rete quando servono

Introduzione al linguaggio Java 22

CONCORRENTE

• Multithreading parte integrante del linguaggio:– Applicazioni interattive più facili a scriversi– Migliore "reattività" (anche se non real-time)

Esempio: caricamento asincrono di immagini nei browser di rete riduce i tempi di attesa

Introduzione al linguaggio Java 23

RICCO

La Standard Library Java contiene una ricca collezione di classi e di metodi preconfezionati:

– Language support– Utilities– Input/output– Networking– Abstract Window Toolkit (AWT)

Introduzione al linguaggio Java 24

JAVA E INTERNET

Introduzione al linguaggio Java 5

5

Introduzione al linguaggio Java 25

WEB BROWSER E SERVER

HTTP used overthis TCP connection

Internet

Disk Disk

Hyperlink

to xyz.com

HTTPServer

HTTPServer

Client

Server abc.com Server xyz.com

Browserprogram

Introduzione al linguaggio Java 26

URL: Uniform Resource Locator

<protocollo> :// <nome del server> <nome del file>

Esempio:http://www.dsi.unimi.it/DSI/corsi/programmi/F28005/index.html

deve essere risolto in un indirizzo internet (IP) con l’aiuto di un DomainName Server (DNS)

Introduzione al linguaggio Java 27

HTML: ESEMPIO

<HTML><HEAD>

<TITLE> Esempio </TITLE> Esempio</HEAD> Testo<BODY> DSI

<P>Testo<A HREF=“http://www.dsi.unimi.it”> DSI </A>

</BODY></HTML>

Introduzione al linguaggio Java 28

APPLET JAVA

• Sono programmi Java riferiti da link in pagine HTML

• Vengono caricati e interpretati dal browser (se questo supporta Java)

• Permettono di “animare” le pagine web

Introduzione al linguaggio Java 29

HTML con APPLET: ESEMPIO

<HTML><HEAD>

<TITLE> Esempio </TITLE> Esempio</HEAD> Testo<BODY> Hallo!

<P>Testo<APPLET CODE=“HelloWorld.class WIDTH=300 HEIGHT=80> Qui c’è un applet che ti saluta</APPLET>

</BODY></HTML>

testo che esce se il browser non supporta gli applet

Introduzione al linguaggio Java 30

JAVA BROWSER

httpclient

ftpclientftp

clientjavaloader

UI library

TCP / IP

interpreteJAVA

I/Olibrary

local disk

rete

interpreteHTML

Introduzione al linguaggio Java 6

6

Introduzione al linguaggio Java 31

UN NUOVO PARADIGMA:NETWORK COMPUTING

Approccio tradizionale

Network computing

PROGRAMMIDATI

RETE

PROGRAMMI E DATI

RETE

PC

NC

loadand run

Introduzione al linguaggio Java 32

PARTE 2

PROGRAMMAZIONE A OGGETTI

Introduzione al linguaggio Java 33

PARADIGMI DI PROGRAMMAZIONE

Introduzione al linguaggio Java 34

RIFLESSIONI SULLA PROGRAMMAZIONE

Programmare è un mestiere strano:costruire cose immaterialisempre piene di difetti,che costano un sacco di soldie sono fatte di migliaia di frasiscritte da gente particolareper macchine molto stupideche richiedono precisione assolutae che cambiano di continuo ...

Introduzione al linguaggio Java 35

I DUE PARADIGMI DELLA PROGRAMMAZIONE

Ci sono essenzialmente due modi diversi di descrivere il mondo:

• come un sistema di processi(“modello procedurale”)

• come un sistema di cose(“modello a oggetti”)

Introduzione al linguaggio Java 36

ESEMPIO: UNA MACCHINA PER SPREMERE LE ARANCE

Rube Goldberg, Inventions of Professor Lucifer Butts, 1932

Introduzione al linguaggio Java 7

7

Introduzione al linguaggio Java 37

IL MODELLO PROCEDURALE:ALCUNI TEMI TIPICI

• Processi, sequenze di esecuzione• Concetto di “controllo”• Trasformazioni, funzioni• Flow-charts• Tracciatori, program profilers• Copertura topologica• Complessità strutturale• Il problema dei goto• Linguaggi strutturati• Programmazione top-down• Astrazione procedurale• ….

Introduzione al linguaggio Java 38

LA MACCHINA DI VON NEUMANN

“… nel progettare una sequenza codificata, quello che bisogna avere innanzitutto in mente non è l’apparenza originale della sequenza, ma piuttosto il suo funzionamento e il suo continuo cambiamento mentre il processo che essa controlla procede nel suo corso. …

È dunque consigliabile incominciare la progettazione dalla fine, e cioè progettare per prima cosa il corso del processo e la relazione delle sue fasi successive con il codice che cambia, e quindi estrarre la sequenza codificata come operazione succes-siva.”

Goldstine & Von Neumann, 1947

Introduzione al linguaggio Java 39

SPAGHETTI E STRUTTURA

Introduzione al linguaggio Java 40

RIUSABILITÀ NEI LINGUAGGI PROCEDURALI

Esempio: Cint fun (int i, float r)

{ int j;….}

Dalle librerie di “subroutines” alle librerie di procedure/funzioni

“ASTRAZIONE FUNZIONALE”

Introduzione al linguaggio Java 41

IL MODELLO PROCEDURALE: LINGUAGGI

Fortran 1956-1957Cobol 1960Basic 1963-1964Pascal 1972C 1972

Introduzione al linguaggio Java 42

UN BLOCCO INTELLETTUALE?

“… Questi “linguaggi di Von-Neumann” creano dei blocchi stradali mentali enormi e non necessari nel pensare i programmi e nel creare le combinazioni di alto livello richieste da una metodologia di programmazione veramente potente. …”

John Backus, 1978

Introduzione al linguaggio Java 8

8

Introduzione al linguaggio Java 43

IL MODELLO A OGGETTI: ALCUNI TEMI TIPICI

• Dall’astrazione funzionale alla “data abstraction”• Costruire “cose”, non processi• Società di entità attive, cooperanti, riusabili• Dalla computazione alla comunicazione e alla delega• Classificare il mondo: classi, sottoclassi, istanze

(“esemplari”)• Bottom-up, non top-down

Introduzione al linguaggio Java 44

IL MODELLO A OGGETTI: LINGUAGGI

SimulaSmalltalkEiffelC++

Java

Introduzione al linguaggio Java 45

IL PARADIGMAA OGGETTI

Introduzione al linguaggio Java 46

OGGETTI: CHE SONO MAI?

• Versione informatica degli oggetti "reali"• Dotati di una loro propria "individualità"• Capaci di interagire per scambio di messaggi• Caratterizzati da proprietà

– dati: ne descrivono lo “stato”– funzioni: ne descrivono il “comportamento”

• Un msg modifica stato e attiva comportamenti

Un oggetto è una coppia [stato,funzioni]

Introduzione al linguaggio Java 47

ESEMPIO: UN’AUTOMOBILE

Funzioni Dati:- Avviati - Targa- Fermati - Colore- Accelera - Velocità- … - Livello benzina

- ...

Introduzione al linguaggio Java 48

CLASSI

campi

metodo metodo

metodo metodo

• una classe ha un nome, e contiene due tipi di membri: campi e metodi

“Tipo di dati astratti” (ADT)

Introduzione al linguaggio Java 9

9

Introduzione al linguaggio Java 49

OGGETTI• Un oggetto è una istanza (“esemplare”) di una

classe, che viene creato (“instanziato”) dinamica-mente

Due esemplari della stessa classe sono distinguibili soltanto per il loro stato (il valore dei loro campi), mentre il comportamento è sempre identico

MIV5678

MIK1178

BO8956

Automobile

a

b

c

valori

variabili

Introduzione al linguaggio Java 50

CLASSI: ESEMPIO (JAVA)

class Automobile {string targa;int velocità;color colore;…public void Avviati () {…..}public void Fermati () {}

}

campi

metodi

nome classe

Introduzione al linguaggio Java 51

OGGETTI: ESEMPIO (JAVA)class Automobile {….}….Automobile a, b, c;a = new Automobile();b = new Automobile();c = new Automobile();….a.Avviati();….

dichiara, non crea

crea

Introduzione al linguaggio Java 52

INCAPSULAMENTO• Alcuni attributi (dati e metodi) sono pubblici (cioè

visibili "all'esterno")• Altri attributi sono privati dell'oggetto, e quindi

“nascosti” all’esterno (“information hiding”)

• Le parti private sono modificabili senza effetti per gli interlocutori dell'oggetto

• Propagazione delle modifiche assai contenuta• Stimolo al riutilizzo di oggetti ("black-box")

Introduzione al linguaggio Java 53

ESEMPIO: AUTOMOBILE

• Parti "visibili" (interfaccia pubblica): accesso a "ciò che l'auto può fare"

– volante, combinazione volante-freno (ev. a mano)– blocchetto di accensione, oppure manovella– pedale dell'acceleratore, acceleratore automatico

• Parti "nascoste" (implementazione): "come l'auto fa ciò che si può fare"

– meccanica dello sterzo e dell'alimentazione– elettromeccanica dell'avviamento– sistema di alimentazione e accensione

Introduzione al linguaggio Java 54

INCAPSULAMENTO: APPROCCI

• Approccio "puro"lo stato è privato, e lo si può modificare soloattraverso quei metodi che sono stati dichiarati pubblici . Esempio: Fermati()

• Approccio di Javaanche le componenti dello stato possono essere dichiarate pubbliche e modificate dall'esterno Esempio: velocita=0

Introduzione al linguaggio Java 10

10

Introduzione al linguaggio Java 55

INTERAZIONI TRA OGGETTI

• Gli oggetti possono comunicare e interagire mediante scambio di messaggi attraverso le loro interfacce pubbliche (stato o funzioni)

• Per mezzo di un messaggio un oggetto può chiedere un'informazione a un altro oggetto, causarne un cambiamento di stato, oppure delegargli un'attività

• Un messaggio in arrivo viene trattato dal metodo omonimo del ricettore, il quale "si attiva" per rispondere, per cambiare di stato, oppure per intraprendere un'attività

Introduzione al linguaggio Java 56

ESEMPIO: UN'AUTOVETTURA

• Il sistema antiskid durante una frenata invia periodicamente un messaggio alle ruote per "leggere" la loro velocità di rotazione

• Il galleggiante nel serbatoio del carburante invia messaggi all'indicatore di livello sul cruscotto per "scrivervi" un nuovo stato

• Il volante tornando alla posizione di riposo invia un messaggio al comando meccanico dell'indicatore di direzione per delegargli il compito di interrompere l'eventuale segnale lampeggiante (i.e. di "togliere la freccia")

Introduzione al linguaggio Java 57

OGGETTI COMPOSTI

automobile

ruota carrozzeria

Un oggetto può essere costituito da altri oggetti

motore

Introduzione al linguaggio Java 58

UN SISTEMA A OGGETTI

a

b

c

d

gf

e

main

chiamata di un metodo di b

Introduzione al linguaggio Java 59

SISTEMI A OGGETTI

• Società di entità attive, cooperanti, riusabili

• Bottom-up, non top-down

• Visione locale, non globale

• “Comportamento emergente”

Introduzione al linguaggio Java 60

ESEMPIO: ARTIFICIAL LIFE

Introduzione al linguaggio Java 11

11

Introduzione al linguaggio Java 61

UNA DOMANDA IMPORTANTE

I computer possono fare di più di quanto venga loro indicato?

Introduzione al linguaggio Java 62

EREDITARIETÀ• È il meccanismo che consente di derivare una

sottoclasse da una classe data• Una sottoclasse si ottiene per aggiunta, per

occultamento o per ridefinizione di uno o più membri rispetto alla classe di partenza (che diventa una superclasse della nuova classe)

Esempio:

automobile taxi

StartTassametro

EndTassametro

Licenza

Introduzione al linguaggio Java 63

ESEMPIO

class Taxi extends Automobile {int licenza;public void StartTassametro() {…}public void EndTassametro () {…}}

nuovo campo

nuovi metodi

Introduzione al linguaggio Java 64

ESEMPI• Implementazione di un'interfaccia grafica

– classe "finestra": attributo privato "sfondo" e metodo "cambia-sfondo" – sottoclasse "finestra-nera": attributo privato "sfondo" ridefinito con il

valore costante "nero", metodo "cambia-sfondo" occultato

• Libreria di algebra lineare:– classe "matrice": metodo "determinante" generico– sottoclasse "matrice-diagonale": metodo "determinante" che

moltiplica tra di loro gli elementi sulla diagonale

• Dichiarazione dei redditi– classe "contribuente": quadri del modello 740 base– classe "autonomi": aggiunta del membro "quadro-E"

Introduzione al linguaggio Java 65

GERARCHIA DI CLASSI

Generalizzazione Specializzazione

instanziazione

Introduzione al linguaggio Java 66

VeicoloVeicolo

ESEMPIO

VeicoloSenzaMotore

VeicoloSenzaMotore Veicolo

A MotoreVeicolo

A Motore

MotociclettaMotocicletta AutomobileAutomobile

TaxiTaxi

obiectobiect

Introduzione al linguaggio Java 12

12

Introduzione al linguaggio Java 67

VeicoloVeicolo

AGGIUNGERE SOTTOCLASSI

VeicoloSenzaMotore

VeicoloSenzaMotore Veicolo

A MotoreVeicolo

A Motore

MotociclettaMotocicletta AutomobileAutomobile

TaxiTaxi

obiectobiect

AltroAltro

Introduzione al linguaggio Java 68

Veicolo A MotoreVeicolo A Motore

RIDEFINIZIONE DEI METODI

MotociclettaMotocicletta AutomobileAutomobile AereoAereo

Noleggia

Noleggia

ereditano il metodo utilizza la versione locale

Introduzione al linguaggio Java 69

POLIMORFISMO

“Ciò che vale per una classe, vale anche per le sue sottoclassi. Se una proprietà viene ridefinita, quando la uso viene selezionata la versione corretta”

Esempio:Quando uso un metodo di un oggetto, non so:• a quali livelli è definito• quale tra i metodi omonimi nella gerarchia verràusato

Introduzione al linguaggio Java 70

VISIBILITÀ DEI NOMI

oggetto b oggetto a

b.nome

nome

Il msg inviato all’oggettorisale nella gerarchia fino a trovare una definizione

gerarchia di classi

Introduzione al linguaggio Java 71

PROGRAMMAZIONE A OGGETTI E TASSONOMIA

Nel paradigma a oggetti, l’attenzione del programmatore è spostata dalla creazione di processi di computazione alla creazione di tassonomie del sistema in esame

Osservazioni: • Per descrivere un sistema sono possibili

tassonomie diverse, a seconda degli obbiettivi

• La tassonomia è un’arte difficile

Introduzione al linguaggio Java 72

ESEMPI ALTERNATIVI

Automobile

Spider Berlina

Segmento A Segmento CSegmento B

Automobile

Benzina Diesel

Introduzione al linguaggio Java 13

13

Introduzione al linguaggio Java 73

EREDITARIETÀ MULTIPLA• Meccanismo che consente di derivare sottoclassi

da due o più classi

• Il problema degli omonimi• Java non implementa ereditarietà multipla

Taxi

Automobile MezzoPubblico

Introduzione al linguaggio Java 74

RIUSO

Linguaggio

Classi generali

Classi specializzate

Classi specifiche

col linguaggio

dal fornitore di classi

sviluppo interno

Introduzione al linguaggio Java 75

PARTE 3

IL LINGUAGGIO JAVA

Introduzione al linguaggio Java 76

INDICE

• Caratteristiche lessicali• Tipi• Strutture di controllo• Classi• Ereditarietà• Interfacce• Packages• Struttura di un’applicazione• Multithreading

Introduzione al linguaggio Java 77

CARATTERISTICHE LESSICALI

Introduzione al linguaggio Java 78

ALFABETO

• I sorgenti Java utilizzano il codice standard internazionale a 16 bit Unicode, che comprende gli alfabeti più diffusi:arabo, greco, ebraico, cirillico, thai, katakana,hiragana, cinese, coreano, e molti altri (http://www.unicode.org)

• I programmi Java possono essere scritti con altre codifiche (es. ASCII), ma devono essere convertiti in Unicode prima di essere compilati

• Sequenze di escape: /udddd (d: 0-9, a-f, A-F)

Introduzione al linguaggio Java 14

14

Introduzione al linguaggio Java 79

FORMATO

• Il formato di un sorgente Java è libero: gli spazi (blank, tab, newline, form feed) non sono significativi, tranne che per separare i token fra loro, o nei letterali

Introduzione al linguaggio Java 80

COMMENTI

Tre diversi stili:

• /* Commento tradizionale, eventualmente su piùlinee, non nidificato */

• // Commento su di una sola linea• /** Commento di documentazione". */

Solo immediatamente prima di una dichiarazione di classe, interfaccia, metodo o campo, e viene

incluso nella documentazione generabile automa-ticamente a partire dal codice sorgente (es.: javadoc)

Introduzione al linguaggio Java 81

ESEMPIO

/** Questo è un esempio di commento di documentazione per una classe “Automobile”

* @see Ruota* @see Carrozzeria* @author Roberto* @version 1.0*/

Introduzione al linguaggio Java 82

TAGS

Tag Descrizione Si applica a@see Nome di classe Classe, metodo, campo

collegata@author Nome autore Classe@version Versione Classe@param Nome e descrizione Metodo

parametro@return Descrizione del valore Metodo

di ritorno@exception Nome e descrizione Metodo

eccezione

Introduzione al linguaggio Java 83

IDENTIFICATORI

• Sono composti da “lettere Java” e “cifre Java”, e devono iniziare con una “lettera Java”

• Possono essere di qualsiasi lunghezza

• Attenzione: – sono lettere e cifre Unicode!– _ e $ sono considerate lettere– caratteri con codifica diversa (es. maiuscole e minuscole) sono

considerati diversi (anche se hanno la stessa rappresentazio-ne)

Introduzione al linguaggio Java 84

PAROLE CHIAVELe seguenti keywords non possono essere usate come identificatori:abstract double int superboolean else interface switchbreak extends long synchronizedbyte final native thiscase finally new throwcatch float package throwschar for private transient class (goto) protected try(const) if public voidcontinue implements return volatiledefault import short whiledo instanceof static

Note: - const e goto sono riservate, ma non usate- anche i letterali null, true, false sono riservati

Introduzione al linguaggio Java 15

15

Introduzione al linguaggio Java 85

KEYWORDS JAVA E C

struct union enumsigned unsigned

externauto register

sizeof typedef

char int shortlong float doublevoidif else for while doswitch case defaultbreak continuereturn goto°°volatilestatic const°°

byte booleanfinal

try catch finally throwthrowsprivate public protectedtransient synchronizednative abstract

import class extendsinstanceof implementsinterface packagethis super new

true° false° null°

CJava

° letterali, non keywords°° riservate ma non usate in Java

Introduzione al linguaggio Java 86

TIPI

Introduzione al linguaggio Java 87

TIPI: SINTESITIPI KEYWORD NOTE

boolean:

Primitivi

Reference

Null

boolean true, false

numerici interi

floating-point

classi

interfacce

array

class

interface

floatdouble

byteshortintlongchar

8 bit interi in compl. a 216 bit32 bit64 bit16 bit Unicode32 bit IEEE 75464 bit

Introduzione al linguaggio Java 88

TIPI (segue)

• Linguaggio fortemente tipato:il tipo di una espressione è sempre noto a compile-time

• Linguaggio a oggetti non puro: non tutti i tipi sono classi

• Rispetto al C, non esistono:signed, unsigned, long double, enum, puntatori,struct, union, typedef

Introduzione al linguaggio Java 89

• Dichiarazioni: int i, float f;• Inizializzazioni: double d = 3.14;• Espressioni: i + 5

j = i++

Nota:byte e short vengono sempre promossi a int prima di essere valutati

• Assegnamenti: i = j + 5;

TIPI PRIMITIVI: ESEMPI

Essenzialmente, gli stessi operatori del C

Introduzione al linguaggio Java 90

CLASSI

dichiarazione di classe: class Automobile {

<campi><metodi>

}dichiarazione di oggetto:

Automobile a;

creazione di oggetto:a = new Automobile();

uso dell’oggetto:… a.campo … … a.metodo(…) ...

a nul

a

heap

I campi vengonoinizializzati

Introduzione al linguaggio Java 16

16

Introduzione al linguaggio Java 91

CLASSI: ESEMPIO

class Safe {public int doorNumber = 123;private boolean locked = true;private int combination = 456;

public boolean isLocked() {return (locked)

}public void unLock (int thisCombination) {

if (thisCombination == combination) unLock();}private void unLock() {

locked = false;}private void setCombination(int setting) {

combination = setting;}Safe() { } /* costruttore */Safe (int door) { /* altro costruttore (overloading) */

doorNumber = door;setCombination(doorNumber);

}}

123

Safe aSafe;aSafe = new Safe();

Safe anotherSafe;anotherSafe = new Safe(1927)...aSafe.doorNumber=456;aSafe.unLock(1997);

Introduzione al linguaggio Java 92

CLASSI “WRAPPER”

• Tutti i tipi primitivi tranne byte e short hanno una classe corrispondente nel package java.lang:Boolean, Integer, Long, Character, Float, Double,(“wrapper class”)

• Tale classe definisce metodi e costanti utili per quel tipo, ad esempio:

Classe: CharacterCostanti (static): MIN_VALUE, MAX_VALUE, …Metodi (static): isDefined, isLowerCase, IsUpperCase,isTitleCase, isDigit, isLetter, isLetterOrDigit, isSpace,isJavaLetter,isJavaLetterOrDigit, toLowerCase,toUpperCase, toTitleCase, digit, forDigit

Introduzione al linguaggio Java 93

INTERFACCE

• In sostanza, sono liste di metodi di cui non èdefinita l’implementazione, ma solo l’interfaccia

• La loro implementazione deve essere realizzata da una classe

Introduzione al linguaggio Java 94

ESEMPIO

public interface AudioClip {void play (); /* avvia i'esecuzione */void loop (); /* esegui ciclicamente una audio clip */void stop (); /* interrompi l'esecuzione */ }

class MyAudio implements AudioClip {void play () { <codice che implementa play> }void loop () { <codice che implementa loop> }void stop () { <codice che implementa stop> } }

class YourAudio implements AudioClip { <codice> }

I metodi possono essere public o abstract, gli attributi public, static o final

Introduzione al linguaggio Java 95

ARRAY• In Java gli array sono oggetti• I componenti di un array:

– sono tutti dello stesso tipo– possono essere di tipo primitivo o reference (inclusi altri array)– sono indicizzati con int (indice primo elemento: 0), con

controllo di validità degli indici a run-time

• Esempio:int[ ] a; /* dichiarazione */

/* anche int a[ ]; */a = new int[3]; /* creazione */

a[0] = 0; /* uso */

a

heap

a null

Introduzione al linguaggio Java 96

ARRAY (segue)

• La lunghezza di un array è fissata al momento della sua creazione, e non può essere cambiata…

• ... ma si può assegnare un nuovo array di diversa lunghezza all’array reference:

int[ ] a = new int[3];

a = new int[5];

a

heap

heap

a

Introduzione al linguaggio Java 17

17

Introduzione al linguaggio Java 97

ARRAY DI ARRAY

short [ ] [ ] a; /* array di array di short */short a[ ] [ ]; /* equivalente */

a = new short [3][2];

a = new short [3][ ];a

heap

null null null

a

heap

a[2][0]

Introduzione al linguaggio Java 98

ARRAY DI OGGETTI

class Automobile {public int targa;public int velocità;….

}….Automobile[ ] a=new Automobile[3];

a

heap

a[2].targa

Introduzione al linguaggio Java 99

STRUTTURE DI CONTROLLO

Introduzione al linguaggio Java 100

STRUTTURE DI CONTROLLO: SINTESI

SequenzaSelezione if

switch

Iterazione forwhiledo-while

Salto break uscita da un bloccocontinue continua un loopreturn da un metodo

Gestione ecce- try-catch-zioni finally-throw

Non c’è goto!

Introduzione al linguaggio Java 101

SINTASSI

if ( condition ) switch ( intexpr ) {statement; case intexpr : statement;

[else [case intexpr : statement;statement; ] ...

default : statement; ]}

while ( condition )statement;

for ( init; condition; increment )do statement;

statement;

while ( condition );

boolean, non integer!

Introduzione al linguaggio Java 102

USCITE

• break [label];• continue [label];• return expr;

• label: statement

Introduzione al linguaggio Java 18

18

Introduzione al linguaggio Java 103

ESEMPIO

label: for (i =0 , j=0 ; i<10 && j<20; i++ , j++) {for (z=0 ; z<100 ; z++) {

switch (expr) {case tag: statements; break; /* esce da switch */

.....default: statements; break label; /* esce da label */

} if (z==15) continue; /* prosegue il for z */if (z==i+j) continue label; /* prosegue da label */

}}

Introduzione al linguaggio Java 104

GESTIONE ECCEZIONI

• È una struttura di controllo che permette la gestione di condizioni di errore senza complicare la struttura del codice (codici di ritorno, flag, …)

• Quando si rileva una condizione anomale (eccezione), essa viene segnalata (throw), e il controllo viene automaticamente trasferito al gestore della eccezione, che la tratta

Introduzione al linguaggio Java 105

STRUTTURA try-catch-finally

tryblocco-0

catch (exception_type1 id)blocco-1

catch (exception_type2 id)block-2…

finallyblocco-n

blocco-1

blocco-n

blocco-0

blocco-2

exception_type1

exception_type2

qui dentro viene segnalata la eccezione, con throw e

Introduzione al linguaggio Java 106

LA SEGNALAZIONE DELLE ECCEZIONI

Le eccezioni possono venire segnalate:

• dal sistema run-time, es.:ArithmeticExceptionIndexOutOfBoundsExceptionSecurityExceptionNullPointerException ...

• dal programma:throw e;

Introduzione al linguaggio Java 107

CHE COSA SONO LE ECCEZIONI• Le eccezioni sono oggetti, di una sottoclasse

della classe Throwable:

Object

Throwable

Exception Error

RuntimeException

checked exceptions, definite dall’utente

unchecked exceptions

unchecked exceptions

Introduzione al linguaggio Java 108

LA DICHIARAZIONE throws

type method(args)throws MyException

{….throw new MyException(…)….

}

•Permette al compilatore di controllare quali eccezioni vengono segnalate

• fornisce documentazione all’utente del metodo

Introduzione al linguaggio Java 19

19

Introduzione al linguaggio Java 109

CLASSI

Introduzione al linguaggio Java 110

DICHIARAZIONE DI CLASSI

[Doc comment] [Modifiers] class ClassName[ extends SuperClassName][ implements InterfaceName [, InterfaceName] ...]{ClassBody}

Doc comment commento di documentazioneModifiers abstract, final, public, ...extends la classe è sottoclasse di un'altraimplements la classe realizza una o più interfacceClassBody i campi e i metodi della classe

Introduzione al linguaggio Java 111

ESEMPIO

Dichiarazione di una classe MyClasspublic class MyClass {

int i; /* campo */public void Add_to_i (int j) { /* metodo */

i = i+j;}public MyClass () { /* metodo costruttore: ha lo

i = 10; stesso nome della classe */}

}Creazione e uso di una istanza di MyClass

MyClass mc; /* dichiarazione, non creazione */mc = new MyClass(); /* creazione: l'attributo i vale 10 */mc.i++; /* ora i vale 11 */mc.Add_to_i(10); /* e ora i vale 21 */

Introduzione al linguaggio Java 112

DICHIARAZIONE DI CAMPI

[DocComment] [Modifiers] TypeVariableDeclarator [,VariableDeclarator]… ;

Esempio: static int i = 5, j = 7, a[];

Doc comment commento di documentazioneModifiers static, public, protected,private,

final, ...Type tipo (primitivo o reference)VariableDeclarator identificatore (anche di array), con

eventuale inizializzazione

Introduzione al linguaggio Java 113

DICHIARAZIONE DI METODI

[Doc comment] [Modifiers] ReturnType MethodName (ParameterList) [throws ClassType [,ClassType] … ] {MethodBody

}

Doc comment commento di documentazioneModifiers static, public,protected,private, abstract,

final,native, ...ReturnType può essere un tipo primitivo o reference, o

void (nessun valore di ritorno). Deve esse-re sempre specificato (ma non per i co-struttori)

ParameterList un metodo ha sempre un numero fisso di argomenti (ma è possibile l’ overloading)

Introduzione al linguaggio Java 114

ESEMPIO

int base;

public int power (int n) {int i, p;p=1;for (i=1; i<=n; ++i)

p=p*base;return p;

}

campo della classe

variabili locali

valore della funzione

Introduzione al linguaggio Java 20

20

Introduzione al linguaggio Java 115

IL MODIFICATORE static

• Campi e metodi dichiarati static, sono associati alla classe e non a una particolare istanza

class MyClass {static int a;…static void MyMethod() {

a = a+1;}

}• Pertanto: esiste una sola copia di un campo statico, condiviso da

tutte le istanze della classe; non occorre istanziare un oggetto per usare un membro statico; metodi statici possono accedere solo a membri statici della classe

• Sono qualificati con il nome della classe, e non della istanzaMyClass.a =MyClass.a + 1;

Introduzione al linguaggio Java 116

ESEMPIO

class Safe {static int LastSerialNumber;public int SerialNumber;int SetCombination;….Safe(int Combination) {

SerialNumber = LastSerialNumber++;SetCombination = Combination;

}public static StartNewSeriesFrom (int Start) {

LastSerialNumber = Start; }

}….Safe.LastSerialNumber(100000); /* inizializza il numero di serie */Safe MySafe = new Safe(23456); /* crea una Safe di SerialNumber = 100001

e combinazione 23456 */… MySafe.SerialNumber ….

Il costruttore Safe fa sì che ogni istanza di Safe abbia un

SerialNumber unico

Introduzione al linguaggio Java 117

VARIABILI LOCALI

• Le variabili locali a un metodo:– sono visibili solo dal corpo del metodo– vengono allocate (nello stack di run-time) alla chiamata e deallocate

all’uscita del metodo– non vengono inizializzate automaticamente (diversamente dai

campi di una classe)

• Non si può accedere a una variabile a cui non si sia prima assegnato un valore (e viene segnalato in compilazione !)

Esempio: int i; if ( cond ) { i = 55; … }i++; /* compile-time error */

Introduzione al linguaggio Java 118

LA KEYWORD this

• Se una variabile locale ha lo stesso nome di un membro della sua classe, questo risulta invisibile (“shadowing”) …

• … a meno di usare la keyword this, che denota l’oggetto corrente

Esempio: class MyClass {int x, y, z; /* membri */void MyMethod (int x) { /* parametro */

int y; /* variabile locale */y=x+1; /* y è la variabile locale,

x è il parametro */z=this.x; /* this.x è il membro x */…

}

NB: Poichè this denota un oggetto, non si può usare con membri dichiarati static

Introduzione al linguaggio Java 119

PASSAGGIO DI PARAMETRI A UN METODO

• Tutti i tipi primitivi sono passati per valore• Anche i riferimenti a oggetti di tipo reference sono

passati per valore

Es: int i;

SomeObject obj = new SomeObject();MyMethod( i, obj );….Void MyMethod (int j, SomeObject o) {

j = j+1; /* non altera i, passato per valore */ o = null; /* non altera obj, che si riferisce ancora

all’oggetto */}

heap

obj

o

i

j

Introduzione al linguaggio Java 120

COSTRUTTORI

• Sono metodi che vengono chiamati quando si crea una istanza di una classe; non ritornano alcun valore

• Se non definisco alcun costruttore, per default viene fornito il costruttore vuoto:

class MyClass {…MyClass() { }

}

• Possono essere overloaded; non ha senso che siano static

Introduzione al linguaggio Java 21

21

Introduzione al linguaggio Java 121

ESEMPIO: OVERLOADING

Dichiarazione di una classe MyNewClasspublic class MyNewClass {

int i;public MyNewClass () {

i = 10;}public MyNewClass (int j) {

i = j;

} .....}

Creazione di una istanza di MyNewClassMyNewClass mc0, mc1; /* dichiarazione, non creazione */mc0 = new MyNewClass(); /* creazione: l'attributo i vale 10 */mc0.i++; /* ora i vale 11 */mc1= new MyNewClass(20); /* creazione: l'attributo i vale 20 */mc1.i++; /* ora i vale 21 */

Overloading: metodi omonimi devono essere distinguibili per la quantità e/o per il tipo degli

argomenti

Introduzione al linguaggio Java 122

DISTRUZIONE DI OGGETTI

• Java non supporta distruttori di oggetti: gli oggetti non possono essere distrutti esplicitamente

• Un oggetto privo di riferimenti incidenti non è piùaccessibile, e la memoria che esso occupa può essere "riciclata" dal garbage collector, che opera in un thread indipendente a bassa priorità

String s; /* dichiarazione, non creazione */s = new String ("abc"); /* creazione: s punta a "abc" */s = "def"; /* "abc" non è più puntata da s */

Introduzione al linguaggio Java 123

FINALIZZATORI DI OGGETTI

• Un oggetto "riciclabile" (cioè privo di puntatori incidenti) potrebbe trovarsi in uno stato poco "pulito" (ad es. potrebbe aver aperto dei file che non sono stati ancora chiusi)

• Prima di riciclarlo, il garbage collector invoca il metodo finalize dell’oggetto, es.:

protected void finalize () throws Throwable { ...super.finalize(); /* meglio metterlo sempre */

}

• Il metodo finalize esiste sempre: se non è stato definito, viene ereditato da Object;

Introduzione al linguaggio Java 124

IL MODIFICATORE native

• Un metodo è dichiarato native quando il suo codice èdipendente dalla piattaforma (ad esempio, è scritto in un altro linguaggio)

Esempio:public native void seek(long pos) throws IOException ;

non deve essere specificato il body

Introduzione al linguaggio Java 125

EREDITARIETA’

Introduzione al linguaggio Java 126

SOTTOCLASSI

• In Java, una classe può estendere una sola altra classe (ereditarietà singola)

• Una sottoclasse eredita i campi e i metodi della sua superclasse che non siano dichiarati private e che non siano costruttori, e li può usare come se fossero dichiarati al suo interno

• Un oggetto di una sottoclasse può essere usato ovunque può essere usato un oggetto della sua superclasse

Introduzione al linguaggio Java 22

22

Introduzione al linguaggio Java 127

ESEMPIO

class Animale { Gatto Fufi = new Gatto();float Peso; Animale creatura = Fufi;…void Mangia () { … }…

}class Mammifero extends Animale {

int BattitoCardiaco;// eredita Peso…void Respira() { … }// eredita mangia…

}class Gatto extends Mammifero {

// eredita BattitoCardiaco, Peso, Mangia, Respiravoid FaLeFusa() { … }

}

lecito, perchè “gatto”è una sottoclasse

di “animale”

Introduzione al linguaggio Java 128

“COME”ESTENDERE UNA CLASSE

• Attenzione alla differenza fra la relazione “è un” e la relazione “ha un” : solo la prima può definire una sottoclasse

Esempio:Un cerchio può essere definito mediante il suo centro e il suo raggio, ma sarebbe scorretto definire una classe cerchio come sottoclasse di punto:

class punto { class cerchio extends punto {double x; int y; double raggio;… ...

} }

Introduzione al linguaggio Java 129

SHADOWING E OVERRIDING

• shadowing un campo di una sottoclasse può “nascon-dere” un campo omonimo di una sua superclasse

• overriding un metodo di una sottoclasse può “sovra-scrivere” un metodo di ugual “segnatura”e ugual ReturnType di una sua super-classe

Esempio: class SuperClass {int i;void m(int k) {…}… }

class Subclass extends Superclass {long i:void m(int n) {…}… }

nasconde

sovrascrive

Introduzione al linguaggio Java 130

POLIMORFISMO

class Animale { Gatto Fufi = new Gatto();… Animale creatura =Fufi;void Mangia () { … } creatura.Mangia();…

}class Mammifero extends Animale {

…}class Gatto extends Mammifero {

…void Mangia() { … }...

}

viene eseguito il metodo Mangia della classe Gatto!

(binding dinamico: il metodo da chiamare viene selezionato

a run-time)

Introduzione al linguaggio Java 131

LA KEYWORD super

• per denotare un membro nascosto (campo shadowedo metodo overridden non static), si può usare lakeyword super

Esempio: class SuperClass {int i;…}

class Subclass extends SuperClass {long i:…i = super.i +1;…

}

Introduzione al linguaggio Java 132

CASTING

Gatto Fufi = new Gatto();Animale creatura;...creatura = Fufi; /* ok */Fufi = creatura; /* errore di compilazione:

tipi incompatibili */Fufi = (Gatto)creatura; /* ok, ma solo perchè

creatura è un gatto: senon lo fosse, il controllo a run-time segnalrebbe una eccezione */

Introduzione al linguaggio Java 23

23

Introduzione al linguaggio Java 133

COSTRUTTORI NELLE SOTTOCLASSI

Nel costruttore di una sottoclasse, è corretto, come prima cosa, chiamare il costruttore della superclasse

Esempio:class SubClass extends SuperClass {

SubClass() {super();<altre operazioni>

}}

Introduzione al linguaggio Java 134

IL MODIFICATORE abstract

• Una classe è dichiarata abstract quando contiene almeno un metodo abstract (cioè senza body)

• Una classe abstract non può essere instanziata: occorre sovrascrivere tutti i metodi abstractin una sottoclasse, e istanziare la sottoclasse

Esempio: abstract class a {…abstract int m(int k);

}class b extends a {

...int m(int n) { … }

}

sovrascrive, fornendo la implementazione del metodo

Introduzione al linguaggio Java 135

IL MODIFICATORE final

final ha tre significati diversi:

• campo final non può essere modificato: è un campo costante (deve essereinizializzato)Esempio: final int i = 5;

• metodo final non può essere sovrascritto• classe final non può avere sottoclassi (quindi i

suoi metodi sono implicitamente final)

Introduzione al linguaggio Java 136

METODI final: ESEMPIO

class Password {private int passwd;final boolean validatePassword(String s) {…..}

...}

se non fosse final , potrebbe essere sovrascritto !

Introduzione al linguaggio Java 137

INTERFACCE

Introduzione al linguaggio Java 138

INTERFACCE

Una interface è una struttura sintattica dotata di nome, che racchiude la specifica della segnatura e del ReturnType dei metodi di una classe non ancora implementata

Esempio: interface Driveable {boolean startEngine();void stopEngine();float accelerate(float acc);boolean turn(Direction dir);

}

Introduzione al linguaggio Java 24

24

Introduzione al linguaggio Java 139

IMPLEMENTAZIONE DI UNA INTERFACCIA

Una interfaccia può essere implementata da una (o più) classi:interface Driveable {

boolean startEngine();...

}interface Automobile implements Driveable {

boolean startEngine() { ... } // una particolare implementazione….

}interface Motorcycle implements Driveable {

boolean startEngine() { ... } // un’altra implementazione….

}

Introduzione al linguaggio Java 140

POLIMORFISMO

Esempio:Driveable vehicle; /* variabile di tipo interfaccia; le possiamo

assegnare qualunque oggetto di una classe che implementa l’interfaccia */

Automobile auto = new Automobile();Motorcycle moto = new Motorcycle();...vehicle = auto;vehicle.startEngine(); /* polimorfismo: è il metodo di Automobile */…vehicle = moto;vehicle.startEngine(); /* polimorfismo: è il metodo di Motorcycle */

Introduzione al linguaggio Java 141

Una classe può implementare più di una interfaccia

interface Driveable { interface Rentable {void startEngine(); void startRental();void stopEngine(); void endRental();float accelerate(float acc); int book(Date start, Date end);boolean turn(Direction dir); }

}

class AvisCar implements Driveable, Rentable {void startEngine() { … }void startRental() { … }…

}

EREDITARIETA’ MULTIPLA

Introduzione al linguaggio Java 142

SUPERINTERFACCE

• Una interfaccia può estendere una o più altre interfacce, es.:

interface a extends b, c, d {….}

• Ogni classe che implementa un’interfaccia deve estendere anche tutte le sue superinterfacce

Introduzione al linguaggio Java 143

INTERFACCE vs CLASSI abstract

• Le interfacce sono simili a classi che abbiano soltanto:

– metodi abstract– campi static e final (cioè costanti)

• A differenza delle classi, le interfacce permettono di realizzare una forma di ereditarietà multipla

Introduzione al linguaggio Java 144

PACKAGES

Introduzione al linguaggio Java 25

25

Introduzione al linguaggio Java 145

PACKAGES• Più classi o interfacce interrelate possono essere

riunite in un package, dotato di nome

Esempio:

c

e

b

d

a

MyPackageclasse o interfaccia

Introduzione al linguaggio Java 146

NOMI DI CLASSI

• Il nome di una classe (o di una interfaccia) va sempre qualificato con il nome del package a cui appartiene, tranne quando viene usato all’interno dello stesso package

Esempio:

aaa.bbb.ccc.MyClass

all’interno di aaa.bbb.ccc basta questo

Introduzione al linguaggio Java 147

NOMI DI PACKAGE

• Il nome di un package può essere composto da più identificatori separati da “.”:

roberto.utilities.internet

• Per evitare che package di produttori diversi abbiano lo stesso nome, si suggerisce di far iniziare il nome del package con il dominio Internet del produttore (invertito, e con il nome di più alto livello tutto maiuscolo):

IT.unimi.dsi.roberto.utilities.internet

nome di dominio

Introduzione al linguaggio Java 148

PACKAGES STANDARD

java.lang classi base del linguaggio(Object, Thread, Throwable, System, String,Math, wrapper classes, …)

java.io classi di I/O(FileInputStream, FileOutputStream, )

java.util classi di utilità(Date, Random, …)

java.net classi di supporto alle applicazioni direte (socket, URL, …)

java.applet classe Applet, …

java.awt Abstract Windowing Toolkit

Introduzione al linguaggio Java 149

LO STATEMENT package

• Specifica che le classi che seguono apparten-gono a un certo package

• Deve apparire (una sola volta) all’inizio di una unità di compilazione

Esempio:

class a {..

class b {...

class c {..

a.java

package p; le classi a,b,c appartengonoal package p

Se lo statement è omesso, la classe appartiene alpackage anonimo

Introduzione al linguaggio Java 150

LO STATEMENT import

• Per evitare di usare sempre nomi completi di classi, si può usare lo statement import

Esempio: import java.util.Date;class MyClass { class MyClass {

java.util.Date today; Date today;… ...

} }

Note: • import java.util.* importa tutte le classi del package java.util• java.lang.* è sempre importato implicitamente

Introduzione al linguaggio Java 26

26

Introduzione al linguaggio Java 151

PACKAGE E DIRECTORY

• Molti ambienti Java mappano i nomi dei package sui pathname del file system (compilatore e classloader)

Esempio:

aaa.bbb.ccc.MyClass aaa/bbb/ccc/MyClass

package classe directories file

pathname

Introduzione al linguaggio Java 152

CLASS PATH

• Per indicare al class loader da quale directory partire per la mappatura può essere usata la variabile di ambiente CLASSPATH

Esempio (Unix):setenv CLASSPATH /classi : /usr/roberto/classi : .

java.lang.Math /java.lang.Math.class

nome completo della classe pathname assoluto

Introduzione al linguaggio Java 153

VISIBILITA’

Classi e interfacce• sono visibili all’interno del package in cui sono

dichiarate; sono visibili all’esterno del package solo se dichiarate public

public class a { …public interface b { …

Membri (campi e metodi)• sono visibili quando:

– la loro classe è visibile e– il loro modificatore li rende visibili

Introduzione al linguaggio Java 154

VISIBILITA’ DI CAMPI E METODI

Modificatore Visibilitàprivate solo nella classe in cui è definitonessuno (default) solo nelle classi del packageprotected classi nel package e sottoclassi

(stesso package o altri package)public tutte le classi

NB: I membri di una interfaccia sono sempre pubblici

più

visi

bile

Introduzione al linguaggio Java 155

class a {...

package pac

ESEMPIO

class b {private int i;private void m( ) {…}int j;void n( ) {…}public int k;public p( ){…}protected int i;protected void m( ){…}

class d extends b {...

class c {...

class e extends d {...

class d extends b {...

visibile

Introduzione al linguaggio Java 156

PROGETTARE LA VISIBILITA’

Quando progettiamo una classe dobbiamo pensare a due tipi di utenti:

• quelli che utilizzeranno la classe per realizzare delle applicazioni

• quelli che estenderanno la classe per realizzare sottoclassi

• I primi useranno i membri public; i secondi anche i membri protected

• Le interfacce public e protected vanno progettate con cura

Introduzione al linguaggio Java 27

27

Introduzione al linguaggio Java 157

package pacUSA ESTENDE

interfaccia interfaccia

DUE TIPI DI UTENTI

class a {private int i;private void m( ) {…}int j;void n( ) {…}public int k;public p( ){…}protected int i;protected void m( ){…}

Introduzione al linguaggio Java 158

PACKAGES: RIASSUNTO

I packages:• permettono di creare gruppi di classi e interfacce

fra loro in relazione• definiscono uno spazio di nomi locale per classi e

interfacce evitando conflitti con classi e inter-facce di altri packages

• permettono di avere classi, interfacce e membri (campi e metodi) non visibili all’esterno del package

• possono essere organizzati gerarchicamente

Introduzione al linguaggio Java 159

UNITA’ DI COMPILAZIONE: RIASSUNTO

MyClass.javapackage Roberto.util; /* opzionale */import java.util.* ; /* opzionale */public class MyClass {

…}class MyOtherClass { /* opzionale */

…}interface MyInterface { /* opzionale */

…}

Introduzione al linguaggio Java 160

STRUTTURA DI UN’APPLICAZIONE

Introduzione al linguaggio Java 161

STRUTTURA DI UN’APPLICAZIONE

• Affinchè un sistema a oggetti “parta”, devo avere una classe con un metodo statico e pubblico di nome main

a

b

c

d

gf

e

main

Introduzione al linguaggio Java 162

Hello.java

HELLO WORLD

class Hello {public static void main (String args []) {

System.out.println("Hello World!"); }

}

obbligatorio in questa forma

Introduzione al linguaggio Java 28

28

Introduzione al linguaggio Java 163

SPIEGAZIONI

public static void main (String args [])– void indica che main non ritorna nulla, il che è necessario per

superare il type-checking del compilatore– args[] sono gli argomenti passati a main dalla shell quando si

digita: java Hello arg1 arg2 ... argn – String dice che gli argomenti sono di classe String– public rende il metodo main visibile alle altre classi - e al

comando java (interprete)– static associa main alla classe Hello, e non alle sue istanze

System.out.println("HelloWorld!")– invoca il metodo println dell’oggetto out della classe System,

che stampa la stringa sul file stdout

Introduzione al linguaggio Java 164

UNITA’ DI COMPILAZIONE• Il sorgente di un’applicazione consiste di uno o più file

(“unità di compilazione”)• Ogni file contiene una o più dichiarazioni di classi (o di

interfacce), di cui al più una dichiarata public• Il nome del file deve essere uguale a quello della sua classe

public , con estensione .java:

public class a {...

class b {...

class c {..

file a.java

stesso nome

Introduzione al linguaggio Java 165

<bytecode>

javac a.javapublic class a {…public main (..){….

a.java

<bytecode>

a.classjava a args

class b {……uso di c... <bytecode>

b.class

il compilatore crea file di nome

classname.class

classe c, usata da b, compilata in

precedenza

COMPILAZIONE ED ESECUZIONE

La classe a deve contenere un metodo pubblico e statico di nome main

c.class

Introduzione al linguaggio Java 166

COMPILAZIONE ED ESECUZIONE

Verificare le caratteristiche del sistema di programmazione

utilizzato

Verificare le caratteristiche del sistema di programmazione

utilizzato

La programmazione orientata agli oggetti in Java

Cosa identifica la OOP?

Oggetti e classi : identità, stato, classe, creazione, metodi che osservano e che modificano, notazione punto

Information hiding : ruolo e modalità di occultamento

Ereditarietà : cosa si eredita ? ereditarietà semplice e multipla

Polimorfismo : quale? perché è così importante? classi astratte, definizione e ridefinizione di metodi

Genericità : classi generiche, downcasting, genericità vincolata

Aspetti avanzati : copia e uguaglianza, asserzioni, eccezioni, contenitori e iteratori, distruttori, persistenza

1. Cosa identifica la OOP ? L'acronimo OOP in informatica sta per Object Oriented Programming (Programmazione Orientata agli Oggetti) e vuole denotare l'insieme delle caratteristiche a fondamento del paradigma della programmazione ad oggetti. Storicamente, le prime idee fondanti di questo paradigma sono sorte con il Simula '67, un linguaggio di simulazione discreta di scuola scandinava, e sono state poi riscoperte negli USA negli anni '70-'80 con il linguaggio Smalltalk. Buona parte del gergo della OOP si deve a questi due linguaggi.

Dalla metà degli anni '80 esiste un generale accordo sulle caratteristiche che devono essere presenti in un linguaggio per poterlo classificare come OOPL, cioè per affermare che mette a disposizione il paradigma della OOP:

1. insieme di operazioni astratte, associate ad un tipo

2. stato locale

3. ereditarietà

La prima caratteristica, spesso associata all'acronimo ADT (Abstract Data Type), stabilisce che l'unico modo per agire sugli oggetti di un certo tipo è quello di invocare delle operazioni (nel gergo OOP chiamate metodi) prestabilite e note agli utenti in modo astratto, cioè indipendente dalla rappresentazione prescelta per la loro concreta implementazione (realizzazione).

La seconda caratteristica stabilisce che ogni oggetto ha un proprio stato locale che può cambiare per effetto dell'esecuzione di alcuni metodi. In pratica il valore dello stato locale ad un certo istante è stabilito dal contenuto di un insieme di celle di memoria associate all'oggetto, dette campi o attributi dell'oggetto.

L'ereditarietà stabilisce infine che il linguaggio deve prevedere un meccanismo per stabilire delle relazioni IS-A ("è-un") tra classi di oggetti. Questo meccanismo consente in definitiva il riuso e il polimorfismo, due dei principali fattori alla base del successo della OOP.

1

2. Oggetti e classi

Un oggetto (software) è un'entità dotata di:

• identità, che permette sempre di distinguere un oggetto da un altro (un "numero di serie")

• stato, quindi in grado di "ricordare" qualcosa

• comportamento, che si traduce nella possibilità di osservare (in tutto o in parte) lo stato e/o di modificare lo stato, tramite l'invocazione dei metodi sull'oggetto.

Le metafore più pertinenti per gli oggetti della programmazione sono probabilmente le apparecchiature di tipo elettrico/elettronico riportando un numero di serie (l'identità), avendo degli indicatori di vario genere che descrivono (parte) dello stato interno ed esibendo dei comportamenti, in seguito all'azionamento di alcune leve, pulsanti, ecc.

Un modo corretto di pensare ad un oggetto è rappresentato nella seguente figura:

I blocchi P1, P2, ... ed F1, F2, ... rappresentano i "meccanismi interni" dell'oggetto: in pratica sono dei sottoprogrammi (i metodi) che realizzano le operazioni previste dall'oggetto. Seguendo una metodologia di progetto ampiamente condivisa i metodi vengono spesso divisi in in due categorie:

• comandi, cioè metodi che modificano lo stato dell'oggetto. Sono procedure proprie, cioè che non restituiscono valori ma che producono degli effetti collaterali, generalmente limitati allo stato locale dell'oggetto.

• osservatori ( queries), cioè metodi che si limitano ad osservare lo stato dell'oggetto. Sono procedure di tipo funzionale che restituiscono un valore ottenuto come elaborazione (solitamente molto semplice) dello stato corrente dell'oggetto.

2

Questa separazione, anche se può comportare qualche inefficienza, favorisce in genere la leggibilità e la trasparenza referenziale del codice.

Per creare gli oggetti la tecnica più seguita è quella di definire prima una classe, cioè uno schema di creazione che definisca i possibili stati e i comportamenti, e di invocare un'operazione di istanziazione della classe, detta costruttore o creatore, che determina univocamente l'identità di un oggetto e che ne stabilisce lo stato iniziale. Una possibile sintassi di creazione potrebbe essere:

variabile nuovo [ nome_costruttore ( parametri_attuali_se_previsti ) ]

In pratica una classe sarà definita da un nome a cui viene associato un elenco di costruttori, attributi e metodi, che collettivamente chiameremo proprietà della classe. Nei linguaggi OOP tipizzati, la definizione di una classe comporta generalmente anche quella di un tipo con lo stesso nome. Si ammette che dall'elenco possano mancare i costruttori: in tal caso viene usato implicitamente un costruttore di default (senza parametri).

Per accedere al valore di un attributo o per invocare un metodo su un oggetto la maggior parte dei linguaggi fa uso della notazione punto:

espressione_oggetto.nome_attributo espressione_oggetto.nome_metodo( eventuali_parametri_attuali_se_previsti )

3

Esercizio 1

Realizzare una classe che permetta di effettuare le operazioni di somma e prodotto tra numeri reali e di restituirne il risultato. Si utilizzi una variabile che contenga il risultato dell’operazione secondo la logica dell’incapsulamento (information hiding) dando la possibilità di impostare tale risultato.

class Calcolatrice { public Calcolatrice() { accumulatore=0.0f; } public Calcolatrice(float val){

accumulatore=val; } protected float accumulatore; public void somma(float x){ accumulatore += x; } public void moltiplica(float x){ accumulatore *= x; } public float risultato() { return accumulatore; } }

Esempio di creazioni:

... //Usando il costruttore di defaultCalcolatrice c1 = new Calcolatrice(); //Usando il costruttore overloaded che inizializzaCalcolatrice c2 = new Calcolatrice(3.0);... //Esempi d'usoc1.somma(5.0); c2.somma(1.0); c1.moltiplica(C2.risultato()); System.out.println(scrivi C1.risultato()); /* scrive 20.0 */

3. Information hiding 4

Il concetto di information hiding (che potremmo tradurre con "occultamento di informazione") nella OOP è implicito in quello di ADT e consiste nell'idea che l'utente di un servizio è tenuto a conoscere solo le informazioni strettamente necessarie per usufruire del servizio. Ogni altra informazione può confondere l'utente e/o mettere a rischio l'integrità dell'oggetto stesso.

Tecnicamente si afferma che l'utente deve conoscere solo l' interfaccia della classe, cioè il suo nome e l'interfaccia di ciascuna proprietà pubblica.

Alcuni sistemi sono in grado di estrarre/documentare automaticamente l'interfaccia di classe dalla definizione completa di un classe.

In realtà esiste un altro importante vantaggio dell'information hiding: l'implementatore di una classe potrà ritenersi libero di effettuare delle migliorie senza che questo comporti delle modifiche ai programmi clienti, cioè che usino i servizi offerti da quella classe. L'information hiding è quindi determinante non solo per semplificare la vita ai programmatori, ma anche per la manutenzione e il "riuso del software".

In particolare, nella OOP, l'informazione da nascondere è la rappresentazione dello stato dell'oggetto, cioè l'insieme degli attributi. A rigore, quindi, tutti gli attributi dovrebbero essere nascosti: l'utente deve potervi accedere solo indirettamente attraverso i metodi. Tuttavia, per motivi di efficienza, alcuni linguaggi ad oggetti (tra cui C++, Java e Delphi) permettono l'accesso agli attributi (sia in lettura che in scrittura). Il problema dell'information hiding viene risolto in questi linguaggi permettendo l'accesso solo ad alcuni attributi classificati come pubblici (tipicamente saranno quelli presenti in tutte le possibili rappresentazioni). Oltre agli attributi si possono nascondere anche metodi. Tipico è il caso dei metodi ausiliari, cioè utilizzati per implementare i metodi pubblici, e più in generale, di tutti quei metodi la cui esistenza è legata alla rappresentazione scelta.

In generale, ogni linguaggio propone proprie soluzioni al problema della visibilità, cioè di come stabilire a quali classi rendere visibili le proprietà (sia attributi che metodi) di una classe. A titolo puramente indicativo possiamo citare la soluzione a tre livelli del linguaggio Java:

proprietà pubbliche: tutte le classi possono accedervi proprietà protette: solo le sottoclassi possono accedervi proprietà private: nessuna classe può accedervi

Infatti, per questioni di flessibilità ed efficienza, si sente la necessità di poter definire diversi "livelli" di visibilità. L'ideale è poter decidere per ogni proprietà, quali sono le classi che possono accedervi. L'ereditarietà, in particolare, pone un problema che occorre risolvere di volta in volta: quali proprietà ereditate di una classe devono essere nascoste alle sue sottoclassi ? alcuni linguaggi (ad es. C++ e Java) danno questa risposta: quelle pubbliche e quelle dichiarate appunto come "protette". Altri (ad es. Eiffel) sostengono la tesi che tutto quello che è visibile all'implementatore di una classe deve essere visibile anche agli implementatori delle sue sottoclassi. Inoltre Eiffel non permette la modalità "private", sostenendo il punto di vista secondo cui l'implementatore di una classe non può decidere arbitrariamente che alcuni attributi non siano utili agli implementatori delle sottoclassi.

4. Ereditarietà L'ereditarietà risulta indispensabile per processi di modellazione molto importanti nella moderna costruzione del software quali la specializzazione e la generalizzazione. Nella sua forma più semplice, l'ereditarietà (inheritance) è un meccanismo che consente ad una

5

classe di considerarsi erede di un'altra, detta classe padre o genitore (parent class), con una dichiarazione che possiamo assumere del tipo:

classe <nome> eredita da <classe padre> ...

Così facendo la classe <nome>, detta classe figlia (o classe derivata), eredita tutte le proprietà della <classe padre> specificata : tutti gli attributi e i metodi (anche quelli nascosti).

Sono state proposte varie notazioni grafiche per rappresentare una relazione di ereditarietà tra classi. Una delle più semplici è la seguente, in cui la relazione è rappresentata da un arco diretto dalla classe figlia alla classe padre. Rappresentando l'insieme delle relazioni di questo genere si ottiene il grafo di ereditarietà

Da un punto di vista pratico si può ereditare da qualsiasi classe, a patto di non introdurre cicli nel grafo di ereditarietà. Tuttavia, come suggerito dai nomi delle classi della figura, da un punto di vista metodologico è opportuno e consigliato ereditare X da Y solo quando si è certi che tra Y e X esiste una relazione Y IS-A X ("Y è un X"), o in altri termini, quando la classe figlia è una specializzazione di quella padre.

Oltre a ereditare, la classe figlia può:

• aggiungere propri attributi o metodi

• ridefinire (overriding) metodi ereditati

In questo caso il metodo ereditato (metodo precursore) e quello ridefinito hanno lo stesso nome. I linguaggi devono predisporre meccanismi linguistici opportuni per consentire all'implementatore della classe di accedere ai precursori di un metodo di qualsiasi livello. Si intende che gli utenti della classe si riferiranno a quello ridefinito.

Si osservi che per ogni classe rimane definito l'insieme dei sui discendenti (supertipi) e dei sui discendenti (sottotipi).

Molti linguaggi ad oggetti consentono solo l'ereditarietà semplice: ogni classe ha al massimo un padre. La classificazione degli oggetti è quindi strettamente gerarchica.

Se esiste un'unica radice questa ha nomi come Object o ANY.

I linguaggi ad oggetti più evoluti consentono l'ereditarietà multipla: cioè la possibilità per una classe di ereditare da più di una classe (cioè di avere più padri). Sorgono però problemi non banali di ereditarietà ripetuta: esiste cioè la possibilità di ereditare più di un metodo con lo stesso nome e occorre risolvere in qualche modo le ambiguità che si vengono a creare.

6

Esercizio 2

Realizzare una classe che permetta di effettuare oltre alle operazioni di somma e prodotto tra numeri reali anche quella di sottrazione. Il risultato dell’operazione va restituito in valore assoluto.

public class CalcolatriceLusso extends Calcolatrice{

public void sottrazione(float x){ accumulatore -= x; } public float risultato() {

if(accumulatore<0) accumulatore = -accumulatore;

return accumulatore; }

}

5. Il polimorfismo Tra i vari tipi di polimorfismo che possono essere presenti in un linguaggio, quello che si deve necessariamente ritrovare nella programmazione ad oggetti è noto come polimorfismo di inclusione universale, basato proprio sul concetto di ereditarietà. Questa forma di polimorfismo si basa sui seguenti presupposti:

7

a) la possibilità di usare variabili polimorfe, cioè che possono riferirsi ad oggetti di tipi diversi (generalmente "inclusi" in una certa gerarchia). In pratica basta permettere ad una variabile di tipo T di ricevere un oggetto di un qualsiasi sottotipo di T.

b) la possibilità di effettuare chiamate polimorfe, cioè di indicare con lo stesso nome dei metodi che appartengono a classi diverse e che sono quindi generalmente diversi ("polimorfo" = "avente più forme").

A differenza di altre forme di polimorfismo, come l'overloading (sovraccarico o sovrapposizione) degli operatori, il polimorfismo di inclusione universale prevede che la decisione su quale debba essere la routine da richiamare viene presa a tempo di esecuzione a seconda della classe effettiva (più stretta) di appartenenza dell'oggetto rispetto a cui viene fatta la chiamata. Questa tecnica è nota come collegamento dinamico (late o dynamic binding) dei nomi al codice che deve essere effettivamente eseguito. Esso si contrappone al tradizionale collegamento statico (early o static binding) deciso dal compilatore, di norma, nel caso di chiamate non polimorfe.

Spesso il polimorfismo viene introdotto con le classe astratte, vale a dire classi in cui compaiono uno o più metodi la cui definizione viene rinviata alle sottoclassi (metodi astratti). Tipico è l'esempio rappresentato nella figura qui sotto, in cui la classe ANIMALE ha un metodo astratto fai_verso() che trova una concreta realizzazione (definizione) solo nei discendenti "concreti" (ad es. CANE, GATTO, ecc. ).

Il polimorfismo trova applicazione soprattutto in schemi simili a quello esemplificato dal seguente frammento:

per ogni a : ANIMALE in S esegui a.fai_verso() fineperogni

Si immagina che la variabile a assuma di volta in volta i vari oggetti (di tipo ANIMALE) che si trovano in un insieme o in un array S. Alla variabile a verrà quindi di volta in volta associato un animale potenzialmente diverso e a priori sconosciuto. Quindi, per il compilatore, la chiamata a.fai_verso() è polimorfa e, come tale, soggetta al collegamento dinamico.

6. Genericità Un'altra delle caratteristiche desiderabili del linguaggi OOP tipizzati è la genericità, cioè la possibilità di definire delle classi con uno o più parametri di tipo "tipo". Questa possibilità è utile soprattutto quando si vogliono definire delle classi di tipo contenitore di dati: array, pile, code, alberi, ecc.

8

L'idea è quella di estendere la possibilità di dichiarare il tipo degli elementi presente per il tipo predefinito array (ad es. array of integer, array of string, ecc. ) ai contenitori definiti dall'utente (pila of integer, pila of string, ecc. ).

In assenza di questo strumento (ad es. Java ne è sprovvisto) si è costretti a definire una classe di oggetti "qualsiasi" (ANY o Object) e fare quindi un downcasting, cioè una conversione forzata al sottotipo che ci interessa di volta in volta.

Il ricorso al downcasting si rivela comunque necessario in altre occasioni, come quelle che si presentano quando dobbiamo elaborare una collezione di oggetti di varie classi utilizzando le loro operazioni specifiche (non polimorfe).

A volte esiste la necessità di restringere i possibili parametri attuali di tipo "tipo" a quelli che possiedono determinate operazioni (tipico è il caso dell'operazione di confronto : <, >, ecc.). Alcuni linguaggi (ad es. Eiffel e Sather) mettono a disposizione a tale proposito la cosiddetta genericità vincolata: solo le classi discendenti di una certa classe specificata possono essere sostituite al posto del parametro.

7. Aspetti avanzati

7.1 Copia e uguaglianza La semantica di default per le operazioni di assegnamento e di confronto per = fra oggetti prevede che vengano coinvolte solo le identità degli oggetti (in pratica, spesso, dei puntatori di memoria). Nel caso dell'assegnamento questo può creare degli spiacevoli effetti collaterali dovuti alla condivisione di strutture dinamiche che si viene a creare. Per evitarli occorre effettuare l'assegnamento con operazioni del tipo a:=copia(b) che ha l'effetto di creare in a un puntatore ad una copia dell'oggetto indicato in b. Nel confronto x = y tra oggetti, se si vuole che il confronto non venga fatto sulle identità (questo è quasi sempre il caso) ma bensì sullo stato dei due oggetti, è necessario usare operatori diversi come, ad es., uguale(x,y) . In genere i linguaggi mettono a disposizione del programmatore la possibilità di ridefinire copia e uguale classe per classe.

7.2 Asserzioni

Le asserzioni in un linguaggio di programmazione sono delle espressioni booleane valutabili a tempo di esecuzione che possono assolvere a diversi scopi:

• forma primitiva di specifica e di documentazione • prevenzione contro possibili malfunzionamenti del software; in particolare nella OOP come

precondizioni e postcondizioni dei metodi • strumento di verifica durante la fase di testing • possibili clausole di uno stile di programmazione noto come progetto per contratto

I linguaggi OOP si differenziano notevolmente rispetto al supporto e alla varietà di tipi di asserzioni che mettono a disposizione del programmatore.

7.3 Eccezioni

Per aumentare la robustezza di un'applicazione, tutti i più recenti linguaggi OOP mettono a disposizione la possibilità definire, sollevare e trattare eccezioni, cioè eventi causati da malfunzionamenti o imprevisti hardware o software che si possono sempre verificare. In particolare il programmatore di ogni metodo ha la possibilità di catturare un'eccezione, riconoscerla e prendere

9

le necessarie azioni di recupero almeno per mantenere l'oggetto in uno stato interno consistente. Il trattamento standard di default è quello di propagare l'eccezione al chiamante, fino eventualmente a raggiungere il metodo avviato per primo, facendolo abortire.

7.4 Contenitori e iteratori Una volta definito come classe un contenitore astratto di dati (ad es. una pila, una lista, una tabella, ecc.) si può presentare il problema di attraversare uno di questi contenitori, cioè di costruire cicli del tipo

portati sul primo elemento finché non sei giunto all'ultimo e non hai trovato una condizione di arresto elabora l'elemento corrente passa all'elemento successivo finefinché

La soluzione più generale, flessibile e astratta a questo problema prevede il ricorso a degli oggetti chiamati iteratori la cui classe di appartenenza viene definita in "simbiosi" a quella dei contenitori che li attraversano. In pratica essi assolvono ad un ruolo molto simile a quello rivestito dagli indici dei "for" per l'attraversamento degli array. La differenza è che viene completamente nascosta la rappresentazione dei cursori. Il cursore è l'oggetto che all'interno di un iteratore "punta" all'elemento del contenitore in corso di attraversamento. Questo permette un domani di cambiare sia la rappresentazione dei contenitori che quella degli iteratori senza cambiare il codice delle applicazioni "clienti".

7.5 Distruttori Oltre ai costruttori può essere talvolta necessario che il programmatore definisca dei metodi, chiamati spesso distruttori, che assolvono al compito di svolgere delle azioni finali prima che l'oggetto venga completamente distrutto e le sue aree di memoria rese disponibili per operazioni di allocazione di nuovi oggetti. In particolare, in C++, i distruttori hanno spesso l'onere di recuperare parte della memoria occupata dall'oggetto. Da questo onere sono liberi tutti i linguaggi che prevedono il garbage collector, cioè quel processo della macchina virtuale del linguaggio che assolve appunto al compito di individuare e recuperare le aree occupate da oggetti che si rendono inaccessibili ("garbage", appunto).

7.6 Persistenza persistenza La nella OOP è la proprietà di un oggetto di sopravvivere al processo che l'ha creato.

Un modo per implementare la persistenza è tipicamente quello di "salvarlo" su un supporto di memoria persistente, come il disco. I linguaggi OOP adottano varie tecniche per fornire questo tipo di servizio all'utenza. Il più semplice e primitivo è quello di mettere a disposizione delle primitive di salvataggio e recupero di un oggetti su un file con un certo nome. Il più sofisticato (ma anche il più semplice da usarsi) è quello di prevedere la possibilità di dichiarare come persistenti alcune classi: gli oggetti creati saranno automaticamente resi persistenti.

10

ITIS “A.Avogadro”

Compito in classe V A del 29-11-2005 Durata: 3h

Realizzare un programma Java che utilizzi la classe Automobile e due sottoclassi AutoDaCorsa ed Utilitaria. Le sottoclassi ereditano automaticamente le variabili di istanza e i metodi della superclasse. Le proprietà che devono essere gestite ed impostate sono la velocità, la tenuta di strada e la temperatura massima. Le utilitarie e le auto da corsa devono avere comportamenti diversi per la rilevare la temperatura, le utilitarie se riscontrano che la temperatura del motore ha superato la temperatura massima devono segnalare a schermo il messaggio di fermata alla prima sosta e controllare la temperatura dell’acqua del radiatore, mentre le auto da corsa i messaggio di controllo strumentazione e fermata ai box. Utilizzare una classe di Test per verificare il funzionamento. Si realizzi il diagramma delle classi, evidenziandone proprietà e metodi.

ITIS “A. Avogadro ”

Soluzione proposta

• Diagramma delle classi

• Implementazione delle classi

//Classe auto generica, file Automobile.java package auto; class Automobile { // Classe auto generica int velocita = 0; // variabili di istanza float tenutaStrada = 0f; int temperaturaMax = 100; void setVelocita(int velocita) { //metodo imposta velocità this.velocita = velocita; } int getVelocita() { //metodo velocità

System.out.println(this.velocita); return this.velocita; } void getTenutaStrada() { //metodo tenutastrada System.out.println("metodo getTenutaStrada di automobile"); } void temperaturaAlta(int temperatura) { //metodo temperatura if (temperatura > temperaturaMax) System.out.println("attenzione temperatura alta"); } }

//Classe auto da corsa, file AutoDaCorsa.java

package auto; class AutoDaCorsa extends Automobile { // Classe auto da corsa ( extends fa ereditare ) void temperaturaAlta(int temperatura) { // metodo temperatura if (temperatura > temperaturaMax) { System.out.println("Controllo strumentazione"); System.out.println("Fermata ai box"); } } void getTenutaStrada() { // metodo tenutastrada float coeff_asfalto = 0.001f; this.tenutaStrada = coeff_asfalto * this.velocita; System.out.println(this.tenutaStrada); } }

//Classe utilitaria, file Utilitaria.java package auto; class Utilitaria extends Automobile { // Classe utilitaria (extends fa ereditare ) void temperaturaAlta(int temperatura) { // metodo temperatura if (temperatura > temperaturaMax) { System.out.println("Ferma alla prima sosta"); System.out.println("Controllo temperatura acqua radiatore"); } } void getTenutaStrada(int mantoStradale) { // metodo tenutastrada

float coeff_terra = 0.034f; float coeff_asfalto = 0.03f; if (mantoStradale == 0) { this.tenutaStrada = coeff_asfalto * this.velocita; } else { this.tenutaStrada = coeff_terra * this.velocita; } System.out.println(this.tenutaStrada); } }

//Classe di test, file Test.java package auto; public class Test { // classe auto che contiene il metodo main public static void main(String[] args) { AutoDaCorsa ferrari = new AutoDaCorsa(); Utilitaria cinquecento = new Utilitaria(); ferrari.setVelocita(200); cinquecento.setVelocita(100); ferrari.getTenutaStrada(); cinquecento.getTenutaStrada(1); ferrari.getVelocita(); cinquecento.getVelocita(); ferrari.temperaturaAlta(123); cinquecento.temperaturaAlta(119); } }