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: [email protected]
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.
2.
2.1.
2.2.
2.3.
2.4.
2.5.
3.
3.1.
3.2.
3.3.
3.3.1.
4.
4.1.
4.1.1.
4.2.
4.3.
4.4.
4.5.
5.
Introduzione ................................................................................................... 4
Il Riferimento didattico metodologico ......................................................... 5
Le scelte didattiche ........................................................................................................................ 5
Verso la competenza informatica................................................................................................ 7
Insegnare Informatica................................................................................................................... 8
Didattica dell’informatica............................................................................................................. 9
Scelta degli strumenti e delle metodologie................................................................................. 11
Il progetto ..................................................................................................... 12
Il contesto dell’intervento didattico ........................................................................................... 12
Scelta dei contenuti in relazione alla disciplina e alle sue caratteristiche .............................. 12
Descrizione sintetica del progetto............................................................................................... 13
Programmazione didattica ......................................................................................................... 14
Analisi del processo ..................................................................................... 16
Lo svolgimento dell’intervento didattico................................................................................... 16
Didattica e software libero.......................................................................................................... 17
Gli aspetti emotivi e relazionali .................................................................................................. 18
Riflessioni ..................................................................................................................................... 20
Progettazione della verifica ........................................................................................................ 22
Valutazione del lavoro fatto dagli studenti ............................................................................... 24
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 costruttivista 2 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 emotiva 3 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
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.
4
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 classe 5 , 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’Informatica 6 : 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
6
A. Calvani, Elementi di didattica, Roma, Carocci, 2000.
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
Continua discussione in classe
Proiezione di presentazioni
(videoproiettore)
Attività pratiche di gruppo
Mappe riassuntive
Motivazioni
La 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
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.
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.
L’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.
Avogadro 7 ” 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 “Abacus 8 ”.
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
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.
8
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
Comprendere i concetti di classe,
oggetto, ereditarietà, polimorfismo,
overriding e overloading, interfaccia
Comprendere il paradigma orientato
agli oggetti
A medio termine
Capacità di rielaborare i
contenuti trasmessi
dall’insegnante
Capacità di analisi e
valutazione delle
problematiche nel
progetto di applicazioni
Acquisire la sintassi e semantica delle Capacità di modellare con
strutture primitive del linguaggio Java le classi gli spaccati del
mondo reale
Implementare le classi e usare gli
Capacità di esposizione
oggetti in Java
Capacità di allestire installare e
Acquisizione di un
configurare l’ambiente di sviluppo
linguaggio appropriato
Realizzare i diagrammi delle classi per Stimolare interesse
un dato problema
Saper implementare e documentare la
realizzazione di applicativi Java che
usano le classi
A lungo termine
Progettazione e realizzazione
di architetture di classi per il
problema da risolvere
Acquisizione del metodo di
studio che rifletta il metodo
scientifico
Autonomia e senso di
responsabilità
Acquisizione di un linguaggio
appropriato
Capacità di confrontare le
proprie opinioni con quelle
degli altri
Capacità di collaborare con i
compagni
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à
Osservazione della classe
Lezione introduttiva
• Illustrazione obiettivi
• Analisi dei pre-requisiti
• Introduzione al linguaggio Java
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)
La programmazione orientata agli oggetti
• L’incapsulamento e interazioni tra oggetti
• Ereditarietà (Classi e Sottoclassi)
• Attività in laboratorio (Implementazione di una classe)
La programmazione orientata agli oggetti
• Ridefinizione dei metodi e polimorfismo
• L’ ereditarietà multipla (Interfacce)
• Attività in laboratorio (Realizzazione di un diagramma di
classi)
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)
Verifica in classe
Tempo previsto
2h
3h
20 min
40 min
2h
3h
40 min
2h
20 min
3h
1h
1h
1h
3h
1h
1h
1h
3h
1h
1h
1h
3h
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 education 10 .
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
scoperta 11 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 competenza 12 .
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 autentica 13 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 autentica 15 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 valutazione 16 è 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
disposizione 17 .
16
L.S. Beccegato-B.M. Varisco, Docimologia. Per una cultura della valutazione, Milano, Guerini, 2000.
Pombeni, M.L., “L’adolescente e la scuola”. In A. Palmonari (a cura di), Psicologia dell’adolescenza, Bologna, Il
Mulino, 1997, pp. 271-291
17
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 generale 18 .
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 comportamenti 19 .
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
19
G. Domenici, Manuale della valutazione scolastica, Bari, Laterza, 2001.
B.M. Varisco- L. Santelli, Docimologia. Per una cultura della valutazione, Milano, Guerini e associati, 2000.
25
Griglia di Valutazione
Conoscenze
Competenze
Capacità
Comunica in modo proprio,
efficace ed articolato; è
autonomo ed organizzato;
Affronta autonomamente anche collega conoscenze attinte da
Complete, con
compiti complessi, applicando
ambiti pluridisciplinari;
approfondimenti
le conoscenze in modo corretto analizza in modo critico, con
autonomi
e creativo
un certo rigore; documenta il
proprio lavoro; cerca
soluzioni adeguate per
situazioni nuove
Comunica in maniera chiara
ed appropriata ; ha una
propria autonomia di lavoro;
Sostanzialmente
analizza in modo
Affronta compiti anche
complete
complessivamente corretto e
complessi in modo accettabile
compie alcuni collegamenti,
arrivando a rielaborare in
modo abbastanza autonomo
Comunica in modo adeguato,
anche se semplice;
non ha piena autonomia, ma
Conosce gli elementi Esegue correttamente compiti
è un diligente ed affidabile
essenziali,
esecutore;
semplici;
fondamentali
affronta compiti più complessi
coglie gli aspetti
pur con alcune incertezze
fondamentali, ma incontra
difficoltà nei collegamenti
interdisciplinari.
Complessivamente
Comunica in modo semplice,
Esegue semplici compiti senza
accettabili;
ma non del tutto adeguato;
errori sostanziali;
ha ancora lacune, ma
coglie gli aspetti
affronta compiti più complessi
non estese e /o
fondamentali, ma le sue
con incertezza
profonde
analisi sono lacunose
Comunica in modo non
sempre coerente e proprio; ha
Applica le conoscenze minime, difficoltà a cogliere i nessi
Incerte ed
senza commettere gravi errori,
incomplete
logici e quindi ha difficoltà
ma talvolta con imprecisione
ad analizzare temi, questioni
e problemi
Comunica in modo
decisamente stentato e
Solo se guidato arriva ad
improprio;
Frammentarie e
applicare le conoscenze minime; ha difficoltà a cogliere i
gravemente lacunose
commette gravi errori anche
concetti e le relazioni
nell’eseguire semplici esercizi
essenziali che legano tra loro
i fatti anche più elementari
Nessuna
Nessuna
Nessuna
Livelli
Voto in
decimi
A
9 -10
B
8
C
7
D
6
E
5
Partecipazione:
opportunistica
Impegno: debole
Metodo: ripetitivo
F
3-4
Partecipazione: di disturbo
Impegno: nullo
Metodo: disorganizzato
G
1–2
Comportamenti
Partecipazione : costruttiva
Impegno: notevole
Metodo : elaborativo
Partecipazione: attiva
Impegno: notevole
Metodo: organizzato
Partecipazione: recettiva
Impegno: soddisfacente
Metodo: organizzato
Partecipazione: da sollecitare
Impegno : accettabile
Metodo : non sempre
organizzato
Partecipazione: dispersiva
Impegno : discontinuo
Metodo : mnemonico
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
Introduzione al linguaggio Java 1
Introduzione al linguaggio Java 2
INDICE
PARTE 1
Parte 1
Introduzione al sistema di programmazione Java
Parte 2
Programmazione a oggetti
Parte 3
Il linguaggio Java
INTRODUZIONE AL SISTEMA DI
PROGRAMMAZIONE JAVA
Introduzione al linguaggio Java 3
Introduzione al linguaggio Java 4
CHE COS’È JAVA
CARATTERISTICHE
• È 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 5
Introduzione al linguaggio Java 6
Introduzione al linguaggio Java 1
1
IL LINGUAGGIO JAVA:
CARATTERISTICHE
•
•
•
•
•
•
•
•
•
SEMPLICE E OO
Semplice e orientato agli oggetti
Interpretato
Architetturalmente neutro e portabile
Robusto
Distribuito
Sicuro
Dinamico
Ad elevate prestazioni
Concorrente (multithread)
• Sintassi simile a C e C++ (facile da imparare)
• Elimina i costrutti più "pericolosi" di C e C++
–
–
–
–
–
• Aggiunge garbage collection automatica
• Conserva la tecnologia OO di base di C++
• Rivisita C++ in alcuni aspetti (C++--==)
Introduzione al linguaggio Java 7
Introduzione al linguaggio Java 8
INTERPRETATO
BYTECODE: ESEMPIO
• Il compilatore produce un codice di tipo
intermedio per una “Java Virtual Machine” (“bytecode”) ...
• … che viene interpretato
codice
codice
sorgente
sorgente
aritmetica dei puntatori
(de)allocazione esplicita della memoria
strutture (struct)
definizione di tipi (typedef)
preprocessore (#define)
compilatore
compilatore
byte
bytecode
code
void spin ( ) {
int i;
for (i = 0; i < 100; i++) {
;
}
0
iconst_0
}
1
2
5
8
9
11
14
interprete
interprete
// push int constant 0
// store into local 1 (i=0)
// first time, don’t increment
// increment local i by 1 (i++)
// push local 1 (i)
// push int constant (100)
// compare, loop if < (I<100)
// return void when done
istore_1
goto 8
iinc 1 1
iload_1
bipush 100
if_icmplt 5
return
Introduzione al linguaggio Java 9
Introduzione al linguaggio Java 10
ARCHITETTURALMENTE NEUTRO
ESEMPIO
Sistema tradizionale
eseguibile
eseguibile
macchina
macchinaAA
compilatore
compilatore
macchina
macchinaAA
• Il byte-code è indipendente dall’architettura
hardware
codice
codice
sorgente
sorgente
compilatore
compilatore
macchina
macchinaBB
(ANDF: Architecture Neutral Distribution Format)
eseguibile
eseguibile
macchina
macchinaBB
…….
• Pertanto, un programma bytecode può essere
eseguito su qualsiasi sistema su cui giri un
ambiente run-time Java
Sistema ANDF
compilatore
compilatore
macchina
macchinaAA
codice
codice
sorgente
sorgente
compilatore
compilatore
macchina
macchinaBB
interprete
interprete
macchina
macchinaAA
byte
bytecode
code
…….
…….
Introduzione al linguaggio Java 11
interprete
interprete
macchina
macchinaBB
Introduzione al linguaggio Java 12
Introduzione al linguaggio Java 2
2
ESEMPIO
PORTABILE
• Il formato dei dati è specificato esattamente, e
non “di minima”, come nel C:
–
–
–
–
–
–
–
byte
short
int
long
float
double
char
8 bit complemento a 2
16 bit “
32 bit “
64 bit “
32 bit IEEE 754 floating
64 bit “
16 bit Unicode
• Il sistema Java (compilatore + interprete + librerie
run-time) è facilmente portabile su piattaforme
diverse
codice
codice
sorgente
sorgente
compilatore
compilatore
byte
bytecode
code
interprete
interprete
libreria
libreria
S.O.
– 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”
Introduzione al linguaggio Java 13
Introduzione al linguaggio Java 14
ROBUSTO
DISTRIBUITO
• 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:
• 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)
– 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 15
Introduzione al linguaggio Java 16
SICURO
COMPILE-LOAD-RUN
• L’ambiente di esecuzione si protegge da bytecode
potenzialmente “ostile”
Loader
Loader
delle
delleclassi
classi
Sorgente
Sorgente
Java
Java
Verifica
Verificadel
del
byte-code
byte-code
Interprete
Interprete
• 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
Rete
Compilatore
Compilatore
Ambiente
Ambiente
run-time
run-time
Byte-code
Byte-code
Java
Java
hardware
hardware
Introduzione al linguaggio Java 17
Introduzione al linguaggio Java 18
Introduzione al linguaggio Java 3
3
ELEVATE PRESTAZIONI
COMPILAZIONE ON-THE-FLY
• La verifica del bytecode permette di saltare molti
controlli a run-time: l’interprete è pertanto
efficiente
Loader
Loader
delle
delleclassi
classi
Sorgente
Sorgente
Java
Java
Verifica
Verificadel
del
byte-code
byte-code
Interprete
Interprete
• Per maggiore efficienza, possibilità compilazione
on-the-fly del bytecode in codice macchina
Rete
Generatore
Generatore
di
dicodice
codice
Compilatore
Compilatore
Ambiente
Ambiente
run-time
run-time
Byte-code
Byte-code
Java
Java
hardware
hardware
Introduzione al linguaggio Java 19
Introduzione al linguaggio Java 20
DINAMICO
CONCORRENTE
• 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
• 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
Esempio: nuove release di moduli caricabili
automaticamente dalla rete quando servono
Introduzione al linguaggio Java 21
Introduzione al linguaggio Java 22
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)
JAVA E INTERNET
Introduzione al linguaggio Java 23
Introduzione al linguaggio Java 24
Introduzione al linguaggio Java 4
4
WEB BROWSER E SERVER
Server abc.com
URL: Uniform Resource Locator
Server xyz.com
Client
<protocollo> :// <nome del server> <nome del file>
Hyperlink
Browser
program
to xyz.com
Esempio:
http://www.dsi.unimi.it/DSI/corsi/programmi/F28005/index.html
Disk
HTTP used over
this TCP connection
Disk
HTTP
Server
HTTP
Server
deve essere risolto in un
indirizzo internet (IP)
con l’aiuto di un Domain
Name Server (DNS)
Internet
Introduzione al linguaggio Java 25
Introduzione al linguaggio Java 26
HTML: ESEMPIO
APPLET JAVA
<HTML>
<HEAD>
<TITLE> Esempio </TITLE>
</HEAD>
<BODY>
<P>
Testo
<A HREF=“http://www.dsi.unimi.it”> DSI </A>
</BODY>
</HTML>
• 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
Esempio
Testo
DSI
Introduzione al linguaggio Java 27
Introduzione al linguaggio Java 28
HTML con APPLET: ESEMPIO
JAVA BROWSER
rete
<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>
testo che esce se il browser
</BODY>
non supporta gli applet
</HTML>
Introduzione al linguaggio Java 29
TCP / IP
http
client
interprete
HTML
ftp
ftp
client
client
java
loader
interprete
JAVA
I/O
library
local disk
UI library
Introduzione al linguaggio Java 30
Introduzione al linguaggio Java 5
5
UN NUOVO PARADIGMA:
NETWORK COMPUTING
PARTE 2
Approccio tradizionale
DATI
PROGRAMMI
PROGRAMMAZIONE A OGGETTI
RETE
PC
Network computing
PROGRAMMI E DATI
load
and run
RETE
NC
Introduzione al linguaggio Java 31
Introduzione al linguaggio Java 32
RIFLESSIONI SULLA
PROGRAMMAZIONE
PARADIGMI DI
PROGRAMMAZIONE
Programmare è un mestiere strano:
costruire cose immateriali
sempre piene di difetti,
che costano un sacco di soldi
e sono fatte di migliaia di frasi
scritte da gente particolare
per macchine molto stupide
che richiedono precisione assoluta
e che cambiano di continuo ...
Introduzione al linguaggio Java 33
Introduzione al linguaggio Java 34
I DUE PARADIGMI DELLA
PROGRAMMAZIONE
ESEMPIO: UNA MACCHINA PER
SPREMERE LE ARANCE
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”)
Rube Goldberg, Inventions of Professor Lucifer Butts, 1932
Introduzione al linguaggio Java 35
Introduzione al linguaggio Java 36
Introduzione al linguaggio Java 6
6
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
….
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 successiva.”
Goldstine & Von Neumann, 1947
Introduzione al linguaggio Java 37
Introduzione al linguaggio Java 38
SPAGHETTI E STRUTTURA
RIUSABILITÀ NEI LINGUAGGI
PROCEDURALI
Dalle librerie di “subroutines” alle librerie di
procedure/funzioni
Esempio: C
int fun (int i, float r)
{ int j;
….
}
“ASTRAZIONE FUNZIONALE”
Introduzione al linguaggio Java 39
Introduzione al linguaggio Java 40
IL MODELLO PROCEDURALE:
LINGUAGGI
UN BLOCCO INTELLETTUALE?
Fortran
Cobol
Basic
Pascal
C
1956-1957
1960
1963-1964
1972
1972
“… 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 41
Introduzione al linguaggio Java 42
Introduzione al linguaggio Java 7
7
IL MODELLO A OGGETTI:
ALCUNI TEMI TIPICI
IL MODELLO A OGGETTI:
LINGUAGGI
•
•
•
•
•
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
Simula
Smalltalk
Eiffel
C++
Java
Introduzione al linguaggio Java 43
Introduzione al linguaggio Java 44
OGGETTI: CHE SONO MAI?
• Versione informatica degli oggetti "reali"
• Dotati di una loro propria "individualità"
IL PARADIGMA
A OGGETTI
• 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 45
Introduzione al linguaggio Java 46
ESEMPIO: UN’AUTOMOBILE
CLASSI
• una classe ha un nome, e contiene due tipi di membri:
campi e metodi
metodo
metodo
campi
Funzioni
- Avviati
- Fermati
- Accelera
-…
Dati:
- Targa
- Colore
- Velocità
- Livello benzina
- ...
metodo
metodo
“Tipo di dati astratti” (ADT)
Introduzione al linguaggio Java 47
Introduzione al linguaggio Java 48
Introduzione al linguaggio Java 8
8
OGGETTI
CLASSI: ESEMPIO (JAVA)
• Un oggetto è una istanza (“esemplare”) di una
classe, che viene creato (“instanziato”) dinamicamente
valori
MIV5678
variabili
a
BO8956
Automobile
MIK1178
b
c
Due esemplari della stessa classe sono distinguibili soltanto per il loro
stato (il valore dei loro campi), mentre il comportamento è sempre
identico
class Automobile {
string targa;
int velocità;
color colore;
…
public void Avviati () {
…..
}
public void Fermati () {
}
}
nome classe
campi
metodi
Introduzione al linguaggio Java 49
Introduzione al linguaggio Java 50
OGGETTI: ESEMPIO (JAVA)
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”)
class Automobile {
….
}
….
Automobile a, b, c;
a = new Automobile();
b = new Automobile();
c = new Automobile();
….
a.Avviati();
….
dichiara, non crea
crea
• 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 51
Introduzione al linguaggio Java 52
ESEMPIO: AUTOMOBILE
INCAPSULAMENTO: APPROCCI
• 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
• Approccio "puro"
lo stato è privato, e lo si può modificare solo
attraverso quei metodi che sono stati dichiarati
pubblici .
Esempio: Fermati()
• Approccio di Java
anche le componenti dello stato possono essere
dichiarate pubbliche e modificate dall'esterno
Esempio: velocita=0
Introduzione al linguaggio Java 53
Introduzione al linguaggio Java 54
Introduzione al linguaggio Java 9
9
INTERAZIONI TRA OGGETTI
ESEMPIO: UN'AUTOVETTURA
• Gli oggetti possono comunicare e interagire
mediante scambio di messaggi attraverso le loro
interfacce pubbliche (stato o funzioni)
• Il sistema antiskid durante una frenata invia
periodicamente un messaggio alle ruote per
"leggere" la loro velocità di rotazione
• Per mezzo di un messaggio un oggetto può chiedere
un'informazione a un altro oggetto, causarne un
cambiamento di stato, oppure delegargli un'attività
• Il galleggiante nel serbatoio del carburante invia
messaggi all'indicatore di livello sul cruscotto per
"scrivervi" un nuovo stato
• 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à
• 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 55
Introduzione al linguaggio Java 56
OGGETTI COMPOSTI
UN SISTEMA A OGGETTI
Un oggetto può essere costituito da altri oggetti
chiamata di un metodo di b
main
d
b
automobile
a
c
e
ruota
g
carrozzeria
motore
f
Introduzione al linguaggio Java 57
Introduzione al linguaggio Java 58
SISTEMI A OGGETTI
ESEMPIO: ARTIFICIAL LIFE
• Società di entità attive, cooperanti, riusabili
• Bottom-up, non top-down
• Visione locale, non globale
• “Comportamento emergente”
Introduzione al linguaggio Java 59
Introduzione al linguaggio Java 60
Introduzione al linguaggio Java 10
10
UNA DOMANDA IMPORTANTE
I computer possono fare di più di quanto venga
loro indicato?
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:
StartTassametro
EndTassametro
Licenza
automobile
taxi
Introduzione al linguaggio Java 61
Introduzione al linguaggio Java 62
ESEMPIO
ESEMPI
• Implementazione di un'interfaccia grafica
class Taxi extends Automobile {
int licenza;
public void StartTassametro() {
…
}
public void EndTassametro () {
…
}
}
nuovo campo
– 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
nuovi metodi
• 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 63
Introduzione al linguaggio Java 64
GERARCHIA DI CLASSI
ESEMPIO
obiect
obiect
Veicolo
Veicolo
Generalizzazione
Specializzazione
VeicoloSenza
VeicoloSenza
Motore
Motore
Veicolo
Veicolo
AAMotore
Motore
Motocicletta
Motocicletta
Automobile
Automobile
instanziazione
Taxi
Taxi
Introduzione al linguaggio Java 65
Introduzione al linguaggio Java 66
Introduzione al linguaggio Java 11
11
AGGIUNGERE SOTTOCLASSI
RIDEFINIZIONE DEI METODI
obiect
obiect
Veicolo
Veicolo
VeicoloSenza
VeicoloSenza
Motore
Motore
Veicolo
VeicoloAAMotore
Motore
Noleggia
Veicolo
Veicolo
AAMotore
Motore
Motocicletta
Motocicletta
Motocicletta
Motocicletta
Automobile
Automobile
Automobile
Automobile
Aereo
Aereo
Noleggia
Altro
Altro
Taxi
Taxi
utilizza la versione locale
ereditano il metodo
Introduzione al linguaggio Java 67
Introduzione al linguaggio Java 68
POLIMORFISMO
VISIBILITÀ DEI NOMI
nome
“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
gerarchia di classi
Il msg inviato all’oggetto
risale nella gerarchia fino
a trovare una definizione
b.nome
oggetto b
oggetto a
Introduzione al linguaggio Java 69
Introduzione al linguaggio Java 70
PROGRAMMAZIONE A OGGETTI E
TASSONOMIA
ESEMPI ALTERNATIVI
Nel paradigma a oggetti, l’attenzione del
programmatore è spostata dalla creazione di
processi di computazione alla creazione di
tassonomie del sistema in esame
Spider
Osservazioni:
• Per descrivere un sistema sono possibili
tassonomie diverse, a seconda degli obbiettivi
Automobile
Automobile
Benzina
Berlina
Segmento A
Segmento B
Diesel
Segmento C
• La tassonomia è un’arte difficile
Introduzione al linguaggio Java 71
Introduzione al linguaggio Java 72
Introduzione al linguaggio Java 12
12
EREDITARIETÀ MULTIPLA
RIUSO
• Meccanismo che consente di derivare sottoclassi
da due o più classi
Classi specifiche
sviluppo interno
Mezzo
Pubblico
Automobile
Classi specializzate
dal fornitore di classi
Taxi
Classi generali
• Il problema degli omonimi
• Java non implementa ereditarietà multipla
col linguaggio
Linguaggio
Introduzione al linguaggio Java 73
Introduzione al linguaggio Java 74
INDICE
PARTE 3
•
•
•
•
•
•
•
•
•
IL LINGUAGGIO JAVA
Caratteristiche lessicali
Tipi
Strutture di controllo
Classi
Ereditarietà
Interfacce
Packages
Struttura di un’applicazione
Multithreading
Introduzione al linguaggio Java 75
Introduzione al linguaggio Java 76
ALFABETO
CARATTERISTICHE LESSICALI
• 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 77
Introduzione al linguaggio Java 78
Introduzione al linguaggio Java 13
13
FORMATO
COMMENTI
• 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
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 automaticamente a partire dal codice sorgente (es.: javadoc)
Introduzione al linguaggio Java 79
Introduzione al linguaggio Java 80
ESEMPIO
TAGS
Tag
@see
/** Questo è un esempio di commento di
documentazione per una classe “Automobile”
* @see Ruota
* @see Carrozzeria
* @author Roberto
* @version 1.0
*/
@author
@version
@param
@return
@exception
Introduzione al linguaggio Java 81
Descrizione
Nome di classe
collegata
Nome autore
Versione
Nome e descrizione
parametro
Descrizione del valore
di ritorno
Nome e descrizione
eccezione
Si applica a
Classe, metodo, campo
Classe
Classe
Metodo
Metodo
Metodo
Introduzione al linguaggio Java 82
IDENTIFICATORI
PAROLE CHIAVE
• 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 rappresentazione)
Le seguenti keywords non possono essere usate come identificatori:
abstract
double
int
super
boolean
else
interface
switch
break
extends
long
synchronized
byte
final
native
this
case
finally
new
throw
catch
float
package
throws
char
for
private
transient
class
(goto)
protected
try
(const)
if
public
void
continue
implements
return
volatile
default
import
short
while
do
instanceof
static
Note: - const e goto sono riservate, ma non usate
- anche i letterali null, true, false sono riservati
Introduzione al linguaggio Java 83
Introduzione al linguaggio Java 84
Introduzione al linguaggio Java 14
14
KEYWORDS JAVA E C
Java
C
struct union enum
signed unsigned
extern
auto register
sizeof typedef
byte boolean
final
char int short
long float double
void
if else for while do
switch case default
break continue
return goto°°
volatile
static const°°
try catch finally throw
throws
private public protected
transient synchronized
native abstract
TIPI
import class extends
instanceof implements
interface package
this super new
true° false° null°
° letterali, non keywords
°° riservate ma non usate in Java
Introduzione al linguaggio Java 85
Introduzione al linguaggio Java 86
TIPI: SINTESI
TIPI
boolean:
Primitivi
numerici
interi
floating-point
Reference
TIPI (segue)
KEYWORD
NOTE
boolean
true, false
byte
short
int
long
char
8 bit interi in compl. a 2
16 bit
32 bit
64 bit
16 bit Unicode
float
double
32 bit IEEE 754
64 bit
classi
class
interfacce
interface
• 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
array
Null
Introduzione al linguaggio Java 87
Introduzione al linguaggio Java 88
TIPI PRIMITIVI: ESEMPI
CLASSI
• Dichiarazioni:
int i, float f;
• Inizializzazioni: double d = 3.14;
• Espressioni:
i+5
j = i++ Essenzialmente, gli
stessi operatori del C
Nota:
byte e short vengono sempre promossi a int prima
di essere valutati
• Assegnamenti: i = j + 5;
dichiarazione di classe:
class Automobile {
<campi>
<metodi>
}
dichiarazione di oggetto:
Automobile a;
a
creazione di oggetto:
a
I campi vengono
inizializzati
a = new Automobile();
uso dell’oggetto:
… a.campo … … a.metodo(…) ...
Introduzione al linguaggio Java 89
nul
heap
Introduzione al linguaggio Java 90
Introduzione al linguaggio Java 15
15
CLASSI: ESEMPIO
class Safe {
public int
private boolean
private int
CLASSI “WRAPPER”
123
doorNumber = 123;
locked
= true;
combination = 456;
public boolean isLocked() {
return (locked)
}
Safe aSafe;
public void unLock (int thisCombination) {
aSafe = new Safe();
if (thisCombination == combination) unLock();
}
Safe anotherSafe;
private void unLock() {
anotherSafe = new Safe(1927)
locked = false;
...
}
aSafe.doorNumber=456;
private void setCombination(int setting) {
aSafe.unLock(1997);
combination = setting;
}
Safe() { }
/* costruttore */
Safe (int door) {
/* altro costruttore (overloading) */
doorNumber = door;
setCombination(doorNumber);
}
• 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: Character
Costanti (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 91
Introduzione al linguaggio Java 92
INTERFACCE
ESEMPIO
• 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
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 93
Introduzione al linguaggio Java 94
ARRAY
ARRAY (segue)
• 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
a
null
int[ ] a = new int[3];
heap
a
a
heap
a[0] = 0; /* uso */
• 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:
a = new int[5];
heap
Introduzione al linguaggio Java 95
Introduzione al linguaggio Java 96
Introduzione al linguaggio Java 16
16
ARRAY DI ARRAY
short [ ] [ ] a;
short a[ ] [ ];
ARRAY DI OGGETTI
/* array di array di short */
/* equivalente */
a
a[2][0]
a = new short [3][2];
class Automobile {
public int targa;
public int velocità;
….
}
….
Automobile[ ] a=new Automobile[3];
a
heap
heap
a
a = new short [3][ ];
null null
a[2].targa
null
heap
Introduzione al linguaggio Java 97
Introduzione al linguaggio Java 98
STRUTTURE DI CONTROLLO:
SINTESI
Sequenza
Selezione
STRUTTURE DI CONTROLLO
if
switch
Iterazione
for
while
do-while
Salto
Gestione eccezioni
break
uscita da un blocco
continue
return
continua un loop
da un metodo
Non c’è goto!
try-catchfinally-throw
Introduzione al linguaggio Java 99
Introduzione al linguaggio Java 100
SINTASSI
USCITE
boolean,
non integer!
if ( condition )
statement;
[else
statement; ]
switch ( intexpr ) {
case intexpr : statement;
[case intexpr : statement;
...
default : statement; ]
}
• break [label];
• continue [label];
• return expr;
• label: statement
while ( condition )
statement;
for ( init; condition; increment )
statement;
do
statement;
while ( condition );
Introduzione al linguaggio Java 101
Introduzione al linguaggio Java 102
Introduzione al linguaggio Java 17
17
ESEMPIO
GESTIONE ECCEZIONI
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 */
}
}
• È 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 103
Introduzione al linguaggio Java 104
STRUTTURA try-catch-finally
LA SEGNALAZIONE DELLE
ECCEZIONI
qui dentro viene
segnalata la eccezione,
con throw e
try
blocco-0
catch (exception_type1 id)
blocco-1
catch (exception_type2 id)
block-2
…
finally
blocco-n
Le eccezioni possono venire segnalate:
blocco-0
exception_type1
• dal sistema run-time, es.:
exception_type2
blocco-1
ArithmeticException
IndexOutOfBoundsException
SecurityException
NullPointerException
...
blocco-2
• dal programma:
blocco-n
throw e;
Introduzione al linguaggio Java 105
Introduzione al linguaggio Java 106
CHE COSA SONO LE ECCEZIONI
LA DICHIARAZIONE throws
• Le eccezioni sono oggetti, di una sottoclasse
della classe Throwable:
Object
Throwable
Exception
Error
type method(args)
throws MyException
{
….
throw new MyException(…)
….
}
•Permette al compilatore di controllare
quali eccezioni vengono segnalate
• fornisce documentazione all’utente
del metodo
unchecked
exceptions
Runtime
Exception
unchecked
exceptions
checked exceptions,
definite dall’utente
Introduzione al linguaggio Java 107
Introduzione al linguaggio Java 108
Introduzione al linguaggio Java 18
18
DICHIARAZIONE DI CLASSI
[Doc comment] [Modifiers] class ClassName
[ extends SuperClassName]
[ implements InterfaceName [, InterfaceName] ...]
{ClassBody}
CLASSI
Doc comment
Modifiers
extends
implements
ClassBody
commento di documentazione
abstract, final, public, ...
la classe è sottoclasse di un'altra
la classe realizza una o più interfacce
i campi e i metodi della classe
Introduzione al linguaggio Java 109
Introduzione al linguaggio Java 110
ESEMPIO
DICHIARAZIONE DI CAMPI
Dichiarazione di una classe MyClass
public class MyClass {
int i;
public void Add_to_i (int j) {
i = i+j;
}
public MyClass () {
i = 10;
}
}
[DocComment] [Modifiers] Type
VariableDeclarator [,VariableDeclarator]… ;
/* campo */
/* metodo */
/* metodo costruttore: ha lo
stesso nome della classe */
Creazione e uso di una istanza di MyClass
MyClass mc;
mc = new MyClass();
mc.i++;
mc.Add_to_i(10);
/* dichiarazione, non creazione */
/* creazione: l'attributo i vale 10 */
/* ora i vale 11 */
/* e ora i vale 21 */
Esempio:
static int i = 5, j = 7, a[];
Doc comment
Modifiers
commento di documentazione
static, public, protected,private,
final, ...
tipo (primitivo o reference)
identificatore (anche di array), con
eventuale inizializzazione
Type
VariableDeclarator
Introduzione al linguaggio Java 111
Introduzione al linguaggio Java 112
DICHIARAZIONE DI METODI
ESEMPIO
[Doc comment] [Modifiers] ReturnType MethodName (ParameterList)
[throws ClassType [,ClassType] … ] {
MethodBody
int base;
}
Doc comment
Modifiers
commento di documentazione
static, public,protected,private, abstract,
final,native, ...
ReturnType
può essere un tipo primitivo o reference, o
void (nessun valore di ritorno). Deve essere sempre specificato (ma non per i costruttori)
ParameterList
campo della classe
public int power (int n) {
int i, p;
p=1;
for (i=1; i<=n; ++i)
p=p*base;
return p;
}
variabili locali
valore della funzione
un metodo ha sempre un numero fisso di
argomenti (ma è possibile l’ overloading)
Introduzione al linguaggio Java 113
Introduzione al linguaggio Java 114
Introduzione al linguaggio Java 19
19
IL MODIFICATORE static
ESEMPIO
class Safe {
static int LastSerialNumber;
Il costruttore Safe fa sì che
public int SerialNumber;
ogni istanza di Safe abbia un
int SetCombination;
SerialNumber unico
….
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 ….
• 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 istanza
MyClass.a =MyClass.a + 1;
Introduzione al linguaggio Java 115
Introduzione al linguaggio Java 116
VARIABILI LOCALI
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
• 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)
Esempio:
• Non si può accedere a una variabile a cui non si sia
prima assegnato un valore (e viene segnalato in
compilazione !)
Esempio:
class MyClass {
int x, y, z;
void MyMethod (int x) {
int y;
y=x+1;
z=this.x;
…
int i;
if ( cond ) { i = 55; … }
i++; /* compile-time error */
/* membri */
/* parametro */
/* variabile locale */
/* y è la variabile locale,
x è il parametro */
/* this.x è il membro x */
}
NB: Poichè this denota un oggetto, non si può usare con membri dichiarati static
Introduzione al linguaggio Java 117
Introduzione al linguaggio Java 118
PASSAGGIO DI PARAMETRI
A UN METODO
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:
• Tutti i tipi primitivi sono passati per valore
• Anche i riferimenti a oggetti di tipo reference sono
passati per valore
Es:
i
int i;
SomeObject obj = new SomeObject();
obj
MyMethod( i, obj );
….
o
j
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 */
}
class MyClass {
…
MyClass() { }
}
heap
• Possono essere overloaded; non ha senso che siano
static
Introduzione al linguaggio Java 119
Introduzione al linguaggio Java 120
Introduzione al linguaggio Java 20
20
ESEMPIO: OVERLOADING
Dichiarazione di una classe MyNewClass
public class MyNewClass {
int i;
public MyNewClass () {
i = 10;
}
public MyNewClass (int j) {
i = j;
}
Overloading: metodi omonimi devono essere
distinguibili per la quantità e/o per il tipo degli
argomenti
.....
• 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;
s = new String ("abc");
s = "def";
}
Creazione di una istanza di MyNewClass
MyNewClass mc0, mc1;
mc0 = new MyNewClass();
mc0.i++;
mc1= new MyNewClass(20);
mc1.i++;
DISTRUZIONE DI OGGETTI
/* dichiarazione, non creazione */
/* creazione: s punta a "abc" */
/* "abc" non è più puntata da s */
/* dichiarazione, non creazione */
/* creazione: l'attributo i vale 10 */
/* ora i vale 11 */
/* creazione: l'attributo i vale 20 */
/* ora i vale 21 */
Introduzione al linguaggio Java 121
Introduzione al linguaggio Java 122
FINALIZZATORI DI OGGETTI
IL MODIFICATORE native
• 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.:
• 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 ;
protected void finalize () throws Throwable {
...
super.finalize(); /* meglio metterlo sempre */
}
non deve essere
specificato il body
• Il metodo finalize esiste sempre: se non è stato
definito, viene ereditato da Object;
Introduzione al linguaggio Java 123
Introduzione al linguaggio Java 124
SOTTOCLASSI
EREDITARIETA’
• 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 125
Introduzione al linguaggio Java 126
Introduzione al linguaggio Java 21
21
“COME”
ESTENDERE UNA CLASSE
ESEMPIO
class Animale {
Gatto Fufi = new Gatto();
float Peso;
Animale creatura = Fufi;
…
void Mangia () { … }
…
lecito, perchè “gatto”
}
è una sottoclasse
class Mammifero extends Animale {
di “animale”
int BattitoCardiaco;
// eredita Peso
…
void Respira() { … }
// eredita mangia
…
}
class Gatto extends Mammifero {
// eredita BattitoCardiaco, Peso, Mangia, Respira
void FaLeFusa() { … }
}
• 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 127
Introduzione al linguaggio Java 128
SHADOWING E OVERRIDING
POLIMORFISMO
• shadowing
un campo di una sottoclasse può “nascondere” un campo omonimo di una sua
superclasse
• overriding
un metodo di una sottoclasse può “sovrascrivere” un metodo di ugual “segnatura”
e ugual ReturnType di una sua superclasse
Esempio:
class SuperClass {
nasconde
int i;
sovrascrive
void m(int k) {…}
…
}
class Subclass extends Superclass {
long i:
void m(int n) {…}
…
}
Gatto Fufi = new Gatto();
Animale creatura =Fufi;
creatura.Mangia();
Introduzione al linguaggio Java 129
Introduzione al linguaggio Java 130
LA KEYWORD super
CASTING
• per denotare un membro nascosto (campo shadowed
o metodo overridden non static), si può usare la
keyword super
Esempio:
class Animale {
…
void Mangia () { … }
…
}
class Mammifero extends Animale {
…
}
class Gatto extends Mammifero {
…
void Mangia() { … }
...
}
class SuperClass {
int i;
…
}
class Subclass extends SuperClass {
long i:
…
i = super.i +1;
…
}
viene eseguito il metodo
Mangia della classe Gatto!
(binding dinamico: il metodo
da chiamare viene selezionato
a run-time)
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: se
non lo fosse, il controllo a
run-time segnalrebbe una
eccezione */
Introduzione al linguaggio Java 131
Introduzione al linguaggio Java 132
Introduzione al linguaggio Java 22
22
COSTRUTTORI NELLE
SOTTOCLASSI
IL MODIFICATORE abstract
Nel costruttore di una sottoclasse, è corretto,
come prima cosa, chiamare il costruttore della
superclasse
• 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 abstract
in una sottoclasse, e istanziare la sottoclasse
Esempio:
class SubClass extends SuperClass {
SubClass() {
super();
<altre operazioni>
}
}
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 133
Introduzione al linguaggio Java 134
IL MODIFICATORE final
METODI final: ESEMPIO
final ha tre significati diversi:
• campo final
• metodo final
• classe final
non può essere modificato: è un
campo costante (deve essere
inizializzato)
Esempio: final int i = 5;
non può essere sovrascritto
non può avere sottoclassi (quindi i
suoi metodi sono implicitamente
final)
class Password {
private int passwd;
final boolean validatePassword(String s) {
…..
se non fosse final ,
}
potrebbe essere sovrascritto !
...
}
Introduzione al linguaggio Java 135
Introduzione al linguaggio Java 136
INTERFACCE
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 137
Introduzione al linguaggio Java 138
Introduzione al linguaggio Java 23
23
IMPLEMENTAZIONE DI UNA
INTERFACCIA
Una interfaccia può essere implementata da una
(o più) classi:
POLIMORFISMO
Esempio:
Driveable vehicle;
interface Driveable {
boolean startEngine();
...
}
interface Automobile implements Driveable {
boolean startEngine() { ... } // una particolare implementazione
….
}
interface Motorcycle implements Driveable {
boolean startEngine() { ... } // un’altra implementazione
….
}
/* 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 139
Introduzione al linguaggio Java 140
EREDITARIETA’ MULTIPLA
SUPERINTERFACCE
Una classe può implementare più di una interfaccia
interface Driveable {
void startEngine();
void stopEngine();
float accelerate(float acc);
boolean turn(Direction dir);
}
• Una interfaccia può estendere una o più altre
interfacce, es.:
interface Rentable {
void startRental();
void endRental();
int book(Date start, Date end);
}
interface a extends b, c, d {
….
}
class AvisCar implements Driveable, Rentable {
void startEngine() { … }
void startRental() { … }
…
}
• Ogni classe che implementa un’interfaccia deve
estendere anche tutte le sue superinterfacce
Introduzione al linguaggio Java 141
Introduzione al linguaggio Java 142
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 143
PACKAGES
Introduzione al linguaggio Java 144
Introduzione al linguaggio Java 24
24
PACKAGES
NOMI DI CLASSI
• Più classi o interfacce interrelate possono essere
riunite in un package, dotato di nome
Esempio:
classe o
interfaccia
MyPackage
• 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:
c
b
a
aaa.bbb.ccc.MyClass
d
e
all’interno di aaa.bbb.ccc basta questo
Introduzione al linguaggio Java 145
Introduzione al linguaggio Java 146
NOMI DI PACKAGE
PACKAGES STANDARD
• Il nome di un package può essere composto da
più identificatori separati da “.”:
roberto.utilities.internet
java.lang
classi base del linguaggio
(Object, Thread, Throwable, System, String,
Math, wrapper classes, …)
java.io
classi di I/O
(FileInputStream, FileOutputStream, )
• 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
java.util
classi di utilità
(Date, Random, …)
java.applet
classi di supporto alle applicazioni di
rete (socket, URL, …)
classe Applet, …
java.awt
Abstract Windowing Toolkit
java.net
nome di dominio
Introduzione al linguaggio Java 147
Introduzione al linguaggio Java 148
LO STATEMENT package
LO STATEMENT import
• Specifica che le classi che seguono appartengono a un certo package
• Deve apparire (una sola volta) all’inizio di una
unità di compilazione
Esempio:
a.java
package p;
class a {..
class b {...
class c {..
le classi a,b,c appartengono
al package p
Se lo statement è omesso,
la classe appartiene al
package anonimo
• Per evitare di usare sempre nomi completi di
classi, si può usare lo statement import
Esempio:
class MyClass {
java.util.Date today;
…
}
import java.util.Date;
class MyClass {
Date today;
...
}
Note:
• import java.util.* importa tutte le classi del package java.util
• java.lang.* è sempre importato implicitamente
Introduzione al linguaggio Java 149
Introduzione al linguaggio Java 150
Introduzione al linguaggio Java 25
25
PACKAGE E DIRECTORY
CLASS PATH
• Per indicare al class loader da quale directory
partire per la mappatura può essere usata la
variabile di ambiente CLASSPATH
• Molti ambienti Java mappano i nomi dei package
sui pathname del file system (compilatore e class
loader)
Esempio (Unix):
setenv CLASSPATH /classi : /usr/roberto/classi : .
Esempio:
aaa.bbb.ccc.MyClass
package
aaa/bbb/ccc/MyClass
classe
directories
java.lang.Math
file
nome completo della classe
pathname
/java.lang.Math.class
pathname assoluto
Introduzione al linguaggio Java 152
VISIBILITA’
VISIBILITA’ DI CAMPI E METODI
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:
più visibile
Introduzione al linguaggio Java 151
Modificatore
private
nessuno (default)
protected
public
Visibilità
solo nella classe in cui è definito
solo nelle classi del package
classi nel package e sottoclassi
(stesso package o altri package)
tutte le classi
NB: I membri di una interfaccia sono sempre pubblici
– la loro classe è visibile e
– il loro modificatore li rende visibili
Introduzione al linguaggio Java 153
Introduzione al linguaggio Java 154
ESEMPIO
PROGETTARE LA VISIBILITA’
package pac
class a {...
class b {
private int i;
private void m( ) {…}
int j;
visibile
void n( ) {…}
public int k;
public p( ){…}
protected int i;
protected void m( ){…}
class
classddextends
extendsbb{...
{...
class e extends d {...
class c {...
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 155
Introduzione al linguaggio Java 156
Introduzione al linguaggio Java 26
26
DUE TIPI DI UTENTI
PACKAGES: RIASSUNTO
class a {
private int i;
private void m( ) {…}
int j;
void n( ) {…}
public int k;
public p( ){…}
protected int i;
protected void m( ){…}
ESTENDE
USA
package pac
interfaccia
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 interfacce di altri packages
• permettono di avere classi, interfacce e membri
(campi e metodi) non visibili all’esterno del
package
• possono essere organizzati gerarchicamente
interfaccia
Introduzione al linguaggio Java 157
Introduzione al linguaggio Java 158
UNITA’ DI COMPILAZIONE:
RIASSUNTO
MyClass.java
package Roberto.util;
import java.util.* ;
public class MyClass {
…
}
class MyOtherClass {
…
}
interface MyInterface {
…
}
/* opzionale */
/* opzionale */
STRUTTURA DI UN’APPLICAZIONE
/* opzionale */
/* opzionale */
Introduzione al linguaggio Java 159
Introduzione al linguaggio Java 160
STRUTTURA DI
UN’APPLICAZIONE
HELLO WORLD
Hello.java
• Affinchè un sistema a oggetti “parta”, devo avere
una classe con un metodo statico e pubblico di
nome main
main
d
b
class Hello {
public static void main (String args []) {
System.out.println("Hello World!");
}
}
a
c
e
g
f
obbligatorio in questa forma
Introduzione al linguaggio Java 161
Introduzione al linguaggio Java 162
Introduzione al linguaggio Java 27
27
SPIEGAZIONI
UNITA’ DI COMPILAZIONE
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
• 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:
file a.java
stesso nome
public class a {...
class b {...
System.out.println("HelloWorld!")
– invoca il metodo println dell’oggetto out della classe System,
che stampa la stringa sul file stdout
class c {..
Introduzione al linguaggio Java 163
Introduzione al linguaggio Java 164
COMPILAZIONE ED ESECUZIONE
COMPILAZIONE ED ESECUZIONE
a.java
a.class
public class a {…
public main (..)
{….
java a args
javac a.java
<bytecode>
b.class
class b {…
…uso di c...
<bytecode>
La classe a deve
contenere un metodo
pubblico e statico di
nome main
Verificare
Verificare le
le caratteristiche
caratteristiche
del
del sistema
sistema di
di programmazione
programmazione
utilizzato
utilizzato
c.class
<bytecode>
il compilatore crea
file di nome
classname.class
classe c, usata da
b, compilata in
precedenza
Introduzione al linguaggio Java 165
Introduzione al linguaggio Java 166
Introduzione al linguaggio Java 28
28
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 default
Calcolatrice c1 = new Calcolatrice();
//Usando il costruttore overloaded che inizializza
Calcolatrice c2 = new Calcolatrice(3.0);
...
//Esempi d'uso
c1.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
La persistenza 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);
}
}
