Incapsulamento OOP: raggruppamento in un’unica entità di metodi e attributi

(rappresentanti lo stato dell’entità) fatto in modo che la modifica dello stato sia
possibile tramite l’uso dei metodi di interfaccia fornita dall’incapsulamento.

Occultamento informazioni: limitazione della visibilità esterna di

informazioni interne alla struttura di incapsulamento.

Occultamento implementazione: limitazione della visibilità delle politiche di

implementazione della struttura di incapsulamento.

Messaggi informativi: (orientati al passato) forniscono all’oggetto

destinatario informazioni atte a modificare il proprio stato.

Messaggi interrogativi: (presente) richiedono all’oggetto informazioni sul

proprio stato.

Messaggi imperativi: (futuro) richiedo ad un oggetto di portare a termine

qualche azione su se stesso, su altri oggetti, o sull’ambiente di sistema, in
generale modificando lo stato.

Polimorfismo: proprietà di una funzione di assumere comportamenti

differenziati: 1) meccanismo mediante il quale un singolo metodo (attributo)
può essere definito in più classi con implementazioni diverse. 2) un attributo o
una variabile può puntare ad oggetti diversi in tempi diversi.

Upcasting: possibilità di assegnare a tempo di esecuzione ad un ident di

oggetti di una cerca classe anche oggetti istanziati da sottoclassi da essa
derivate.

Genericità: meccanismo con il quale una classe può essere completata in

relazione alle classi interne da essa utilizzate a tempo di esecuzione.

Classe parametrica: classe dipendente da uno o + parametri formali. Parte

degli attributi e/o metodi della classe sono definiti in funzione dei parametri
formali della classe.

Classe legata: classe parametrica con parametri formali sostituiti da classi

effettive.

Diagrammi di Composizione: modellano la relazione che intercorre tra 2

oggetti nello scambio di un messaggio. Specificano direzione del messaggio,
il metodo del destinatario da attivare con i relativi parametri formali,
l’operazione del mittente che causa l’inoltro del messaggio.

Classi interne: definite all’interno di altre classi.

Classi locali: definite all’interno di metodi.

Classi anonime: istanze di implementazioni di classi.

 Callback: -registrazione di un oggetto obj in un oggetto di attivazione actObj
-attivazione metodi obj tramite actObj
(utile nel caso multithread e negli ascoltatori delle interfacce grafiche)

Chiusura: oggetto capace di conservare informazioni sull’ambito di visibilità

in cui è stato creato (classi interne tipiche chiusure).

GlassPane: posizionato sopra agli altri componenti di JRootPane

- intercetta gli eventi del mouse
- fa disegnare sopra a tutti i componenti
- invisibile di default

LayeredPane: fornisce strumenti per aggiungere componenti a rootPane in

layer diversi forzando una stratificazione dell’uscita grafica.

ContentPane: pannello di contenimento di componenti di JRootPane. Tutte le

richieste di inserimento componenti vanno inoltrate al ContentPane.

Componenti: JLabel, JButton, BasicArrowsButton, JToggleButton,

JRadioButton, JCheckBox, JTextField, JTextArea, JScrollBar, JComboBox,
JList, JMenu, JPopupMenu, JMenuItem, JCheckBoxMenuItem,
JRadioButtonMenuItem.

JScrollPane: permette di visualizzare componenti sottoponibili a scrollino in

un pannello dotato di barre di scorrimento e eventuali header.

RTTI: (Run-Time Type Definition) metodologia di identificazione del tipo di un

oggetto a tempo di esecuzione.
- TRADIZIONALE: le info per determinare il tipo al momento di esecuzione
derivano da info note a tempo di compilazione.
- RIFLESSIONE: informazioni desumibili a tempo di esecuzione.
Esigenza nata dal polimorfismo che a tempo di esecuzione può avere
necessità di manipolare mediante handle di tipo generico oggetti di tipi
specifici via upcast o di individuare il sottotipo di afferenza di un oggetto
gestito via handle generico.

Classe Class: quando caricata in memoria una classe è istanza della classe
Class di cui acquisisce i metodi. Metodi di class:
-static class forName(String className) (restituisce oggetto class associato
a className)
-metodi per l’individuazione delle relazioni della classe con le classi interne,
con la sovraclasse e con le interfacce implementate.
-metodi per individuazione campi pubblici e metodi pubblici inclusi quelli
ereditati.
Rifermimenti a oggetti class ottenibili con forName o con IdenCl.class.

Controllo ed acquisizione di tipo: - casting esplicito (ClassCastException)

- interrogazioni all’istanza di class che rappresenta l’oggetto (forName)
- con la specifica istanceof (obj istanceof IdenClass) IdenClasse no Class.
Controllo statico: istanceof(…) Controllo dinamico: isIstance() (entrambi
tengono conto dell’ereditarietà)
== e equals() verificano coincidenza puntuale tra il tipo di una classe e il tipo
della classe di afferenza di un oggetto ignorando l’ereditarietà.

RTTI con RIFLESSIONE: il controllo e l’acquisizione di tipo di un oggetto può

essere effettuato a tempo di esecuzione senza disporre degli identificatori di
classe. Utilità: 1) in ambiente Rapid Access Development (approccio visuale
alla creazione di programmi basati su form le cui componenti sono costituite
da icone da sostituire in tempi successivi con istanze di classi specifiche; 2) in
ambiente Remote Method Invocation (creazione di programmi richiedenti
l’accesso a oggetti distribuiti su più sistemi); 3) supporto alla serializzazione di
oggetti (registrazione su file di classi e oggetti da recuperare e utilizzare in
tempi successivi).

Classi di riflessione: Field Object get(Object obj) restituisce il valore del

campo dest del messaggio che risiede nell’obj specificato; void set(Object obj,
Object value) Method Object invoke(Object obj, Object[] args) invoca il
metodo sull’obj specificato con valori di parametro indicati da args.
Constructor Object newIstance(Object[] args) chiama il costruttore con i
valori di parametro indicati da args.

Array: - accesso diretto agli mediante indice di posizionamento – controllo

run-time di appartenenza dell’indice al range di valori consentiti – applicabilità
a tipi base qualsiasi (Object o tipi primitivi) – allocazione statica, impossibile
modifica run-time delle dimensioni.

List, Map, Set: - possibile modifica run-time delle loro dimensioni –

implementazione differenziata in relazione alle esigenze applicative –
applicabili esclusivamente ad entità di tipo Object.

List: modellata dall’interfaccia List. Collezione ordinata di elementi a topologia

lineare. Implementazioni: ArrayList (array dinamicamente modificabile in
estensione) LinkedList (concatenazione di oggetti).

Set e SortedSet: collezione (ordinata) di elementi non ripetuti.

Implementazioni: HashSet (tabella più funzione di hash per velocizzare
accesso ed inserimento) TreeSet (albero ordinato e bilanciato per insiemi
ordinati).

Map e SortedMap: modellano strutture dati (ordinate) formate da coppie

(chiave, valore) non ripetute. Implementazioni: HashMap e TreeMap.

Contenitori: nei contenitori vengono inseriti gli handle degli oggetti. Questo fa
sì che si perda informazione sul tipo delle componenti del contenitore e
diventa quindi necessario il casting in fase di estrazione degli oggetti
componenti. Si può ottenere maggiore protezione con il controllo di tipo in
fase di immissione degli oggetti componenti nel contenitore. Il Controllo sul
corretto inserimento di oggetti nel contenitore può avvenire:
- in COMPILAZIONE: generando una classe non derivata dal contenitore di
interesse in cui vengono riscritti i metodi di inserimento e rimozione del
contenitore riferiti alla tipologia di oggetti inseribili;
- in ESECUZIONE: verificando con istanceof che l’oggetto in inserimento sia
del tipo richiesto.

Accesso a contenitori: - diretto: metodi specifici in base al contenitore

- sequenziale: mediante oggetti Iterator (per Collection, scansione
monodirezionale + eventuale rimozione) o ListIterator (per List, scansione
bidirezionale + rimozione + aggiunta)(non esiste elemento corrente, ma solo
un indice tra 2 elementi).

Stack: struttura dati gestita con metodo LIFO, push (inserimento) pop
(rimozione) top (restituzione elemento in testa). Può essere simulato da una
LinkedList sfruttando addLast(…), getLast(), removeLast().

Queue: struttura dati gestita con metodo FIFO, push (inserimento in ultima),
tail (rimozione dato, contrazione coda), head (acquisizione dato). Usa
addLast(…), getFirst(), removeFirst().

Operazioni non supportate: alcuni metodi di List, Map e Set sono da

considerarsi opzionali nel senso che la loro utilizzabilità dipende
dall’implementazione usata dall’applicazione. Ex: List asList(Object[] obj)
restitutuisce un array non modificabile in estensione. Ogni chiamata ad un
metodo di aggiunta o rimozione di List causerà una
UnsopportedOperationException.

Vector: fornisce metodi per la creazione di array dinamici di oggetti, per

aggiunta o rimozione di oggetti e per trasferimento di oggetti da istanze della
classe in array di natura statica. L’accesso a un Vector può avvenire per
posizione ma anche sequenzialmente grazie ai metodi dell’interfaccia
Enumeration implementati dalla classe VectorEnumerator. I componenti del
vettore vanno prima esportati con elements().

Thread: flusso di esecuzione di istruzioni (usualmente l’esecuzione di un

programma è sostenuta da un processo che realizza un thread). Multithread
utile con architetture a + CPU e quando un problema è spezzabile in
sottoproblemi paralleli. Ogni thread è caratterizzato da: - IDENTIFICATORE:
per operazioni di debugging; - THREAD GROUP: appartenenza ad un t.g.
facente parte di una struttura ad albero; - PRIORITA’ di esecuzione (1…10).
Stati di un Thread: - nuovo (new): creato ma non ancora iniziata
l’esecuzione; - eseguibile (runnable): in esecuzione o pronto per l’esecuzione;
- bloccato (blocked): esecuzione sopesa e thread in attesa; - morto (dead): ha
terminato la propria esecuzione.
Creazione di un Thread: per ereditarietà dalla classe Thread oppure
implementando l’interfaccia runnable. Fa tutto il metodo run() dell’istanza di
thread che va soprascritto. Una volta istanziato un oggetto di tipo Thread o
sottoclasse, il thread viene eseguito per chiamata del metodo start() che
invocherà run(). Creando il thread tramite l’interfaccia runnable non si può
inserire lo start() dentro al costruttore.
L’esecuzione dei thread dipende dallo scheduling della CPU: per questo non
esiste possibilità di controllo completo sull’esecuzione da parte dell’utente e
soltanto entro certi limiti è possibile coordinare le esecuzioni dei thread.
La schedulazione può essere variata: modificando la priorità (setPriority),
sospendendo il thread (sleep throws InterruptedException), attendendo la
morte del thread corrente prima che il successivo sia attivato (join throws
InterruptedException), causando una pausa al thread corrente a conclusione
di qualche operazione (yield).

Daemon: thread che opera in background per fornire servizi d’uso generale e
che non influisce sulla terminazione del programma (un programma termina
quando terminano tutti i thread non demoni dipendenti). Proprietà dei demoni:
deve essere dichiarato tale prima dell’attivazione; i thread generati da un
demone sono implicitamente demoni.

Sincronizzazione dei thread: thread che devono accedere a risorse comuni

o che devono scambiarsi informazioni è necessario che vengano sincronizzati
per evitare il contemporaneo e dannoso accesso alla risorsa e per evitare
l’inconsistenza delle informazioni scambiate.

Condivisione di risorse: ogni risorsa condivisa è protetta da un MUTEX. Per

operarci un thread deve 1) acquisire il mutex della risorsa, bloccandone
l’accesso agli altri thread 2) accedere alla risorsa 3) rilasciare il mutex.
Ogni oggetto Java ha un mutex il cui controllo è operato da metodi
synchronized (tutti i metodi della classe devono essere synchronized).
Synchronized può essere applicato: metodi dinamici (di uno stesso oggetto),
metodi statici (di una stessa classe).

Thread bloccati: un thread può portarsi nello stato bloccato per : 1) chiamata
al metodo sleep(); 2) attesa del completamento di un’operazione di I/O; 3)
accesso ad un metodo o a un blocco synchronized con mutex non disponibile;
4) chiamata al metodo wait() (ritorna runnable per intercettazione di notify() o
notifyAll().

Metodi di sincronizzazione: wait() sospende il thread in esecuzione che

perde il possesso della risorsa su cui opera e viene inserito nella coda dei
processi in attesa. I thread sospesi e in attesa del rilascio di una risorsa
possono essere risvegliati da altro thread che opera sulla stessa risorsa con i
metody notify()(risveglia un thread che è sospeso in attesa del rilascio di una
risorsa, il thread riottiene il possesso della risorsa eseguendo un metodo
sincronizzato appartenente alla risorsa) e notifyAll()(risveglia tutti i thread
sospesi, i metodi risvegliati competono per ottenere l’accesso alla risorsa in
base alla loro priorità e/o al momento della loro sospensione). Un thread
risvegliato è trasferito nella coda dei processi pronti e compete per ottenere
nuovamente il possesso della risorsa condivisa di interesse.

Regione critica: regione di codice sottoposta a vincoli di sincronizzazione.

Tutti i comandi e le chiamate ai metodi sono eseguiti previa acquisizione
dell’oggetto sincronizzato da usare quale blocco di sincronizzazione.

Comunicazione fra thread: 1) produttore / consumatore (richiede supporto

dati condiviso ed è uno schema + o – complesso in base al numero dei thread
coinvolti); 2) monitor (richiede una classe di sincronizzazione); 3) pipeline
(richiede un canale di comunicazione dedicato).

Produttore/Consumatore: uno o + thread produttori trasferiscono dati ad

uno o + thread consumatori di quei dati sfruttando una risorsa condivisa
dotata di metodi sincronizzati.

Monitor: uno o + thread produttori trasferiscono dati ad uno o + thread

consumatori sfruttando una risorsa condivisa (monitor) dotata di metodi
sincronizzati avente la funzione di acquisire e smistare i singoli dati trasferiti. Il
monitor non fornisce un mero supporto di allocazione ma svolge funzione
attiva acquisendo dai produttori singoli blocchi di dati solo quando disponibile
e smistando tali dati quando posseduti.

Pipeline: variante dello schema produttore/consumatore. Utilizza le classi

PipedWriter e PipedReader che realizzano l’I/O tra thread mediante pipe
(canale di comunicazione). Il thread consumatore (contenente PipedReader)
è bloccato quando la pipeline è sotto controllo del produttore (contenente
PipedWriter) oppure è vuota.

Applet: piccoli programmi integrati in pagine web. Tutti i JApplet includono

alla radice un JRootPane a cui delegano le loro operazioni. Hanno restrizioni
di sicurezza: 1) impossibilità di accesso al file system del client; 2)
impossibilità di apertura di connessioni di rete; 3) impossibilità di stampare; 4)
impossibilità di creare processi figli; 5) uso limitato di Awt e Swing. Vantaggi:
1) non richiedono installazione; 2) indipendenti dalla piattaforma.
Per l’esecuzione di un’applet si richiede un file html visualizzato in un browser
dotato di interprete java o in un appletviewer. File .class (un accesso http per
ogni file) File .jar (una sola connessione per tutti). Gli applet sono processi
che possono essere allocati e inizializzati, attivati, sospesi e deallocati dal
browser. Non hanno main ma metodi invocati direttamente dal browser(init()
(inizializzazione e layout dei componenti) start()(invocato per l’esecuzione di
un applet su pagina web) stop()(interrompe l’esecuzione quando l’applet
scompare dalla pagina web) destroy()(forza la chiusura dell’applet e rilascia
le risorse utilizzate)paint() e paintComponent()).

Porta: dispositivo fisico di un calcolatore, individuato da un identificatore

numerico, a cui un programma fa capo per la comunicazione con un’altra
macchina.

Protocollo: insieme di regole procedurali a cui devono attenersi due

macchine per scambiarsi informazioni. Ogni servizio ha un proprio protocollo.

URL di una risorsa: protocollo :// indServer [:idenPorta] / idenRisorsa

Si può indicare anche soltanto l’idenRisorsa. In questo caso gli altri parametri
sono ereditati dall’ultimo URL specificato in modo completo.

validate(): se in un’applet ho l’esigenza di inserire a posteriori nuovi

componenti non inseriti nell’init() per visualizzarli devo chiamare validate().
Animazioni: per inserire un’animazione in un’applet comporta l’utilizzo di GIF
o JPEG da usare come fotogrammi e l’impiego di un pannello di tracciatura da
gestire quale thread di controllo della sequenza di fotogrammi e come
temporizzatore.

File: collezioni di dati allocati su memoria di massa (esistono

indipendentemente dalle applicazioni che li utilizzano).

Proprietà permanente: ORGANIZZAZIONE: criterio di definizione degli

indirizzi di registrazione delle singole componenti del file sulle memorie di
massa (sequential, relative, indexed).
Proprietà transitoria: ACCESSO: specifica il modo in cui le componenti del
file possono essere elaborate durante una singola sessione di lavoro
(sequential, direct, keyed).

Apertura del file: si definisce un puntatore implicito al file da associare

all’identificatore con il quale il file è conosciuto nell’ambiente globale di
sistema e viene effettuato un controllo di compatibilità tra le specifiche
richieste per il file dall’applicazione e le caratteristiche stabilite all’atto della
sua creazione e residenti in directory.
Quando un file viene aperto il puntatore al file deve essere legato ad un buffer
che rappresenta l’unica finestra di accesso al file per eseguire operazioni di
lettura e scrittura.

Stream: generico flusso di dati. Input stream: sequenza di byte leggibile

mediante opportuni metodi. Output stream.

File sequenziali: i file sequenziali (formattati e non) sono modellabili a partire

dalle classi astratte InputStream e OutputStream.

InputStream: definiscono flussi in ingresso da cui è possibile leggere singoli

byte o gruppi di byte. Metodi: abstract int read() e int read(byte b[]), void
close() (chiude lo stream in lettura) long skip(long n) (salta in lettura n byte
restituendo la posizione successiva).
OutputStream: flussi in uscita. abstract void write(int b), void write(byte
b[]), void close().

FileInputStream, FileOutputStream: definiscono file sequenziali di lettura e

scrittura.

File formattati: flussi di byte rappresentativi di dati descritti in forma binaria

quando allocati in memoria, in notazioni standardizzate quando residenti su
supporti diversi.

FilterInputStream e FilterOutputStream: sovraclassi di tutte le classi che

modellano stream di ingresso e uscita con metodi di filtraggio per la
formattazione dei dati. I metodi di queste classi riscrivono gli omonimi metodi
di Input&OutputStream necessari ad inoltrare le richieste di servizio ricevute
ai metodi dei sottostanti stream.
DataInputStream e DataOutputStream: definiscono file sequenziali
formattati di lettura e di scrittura. Implementano le interfacce DataInput e
DataOutput. I metodi permettono di leggere e scrivere dati primitivi
(readBoolean(), readInt(), readChar(), readLine()…writeBoolean(),
writeChars()…). Utilizzo: new DataInputStream(new FileInputStream(f));

RandomAccessFile: definiscono file ad accesso casuale formattati in cui si

può leggere e scrivere in determinate posizioni. Implementa DataInput e
DataOutput. Metodi: void seek(long n), long getFilePointer().

File di oggetti: per registrare oggetti su file bisogna prima serializzarli

(trasformare le informazioni contenute in formato stringa). 1) gli oggetti da
registrare su file vanno definiti serializzabili; 2) gli stream modellati da
FileInputStream e da FileOutputStream vanno convertiti in stream di classi
ObjectInputStream e ObjectOutputStream.

Serializable: interfaccia vuota che va implementata da tutte le classi i cui

oggetti andranno registrati su file. A ciascun oggetto viene associato un
numero di serie(lo stesso oggetto una sola volta).

ObjectInputStream: contiene metodi per lettura dati primitivi e metodi

necessari per deserializzare oggetti precedentemente serializzati
(IOException, StreamCorruptedException). ObjectInputStream(InputStream
in): modella lo stream da cui leggere gli oggetti da deserializzare; Object
readObject() restituisce il successivo oggetto acquisito dal file.

No Serializable: se la classe, i cui oggetti sono da salvare, non implementa

serializable (ma gli oggetti sono dichiarati transient) bisogna riscrivere il
metodo void defaultReadObject() all’interno del metodo private void
readObject(ObjectInputStream in).

File di immagini: sono controllati da oggetti di tipo ImageReader e

ImageWriter. Sono implicitamente istanziati dalle classi che realizzano i
provider per il riconoscimento ed il trattamento di diversi formati di immagine.
Anche i file di immagine lavorano con flussi di dati.

ImageInputStreamImpl e ImageOutputStreamImpl: classi filtro astratte per

i metodi implementati dalle sottoclassi.

ImageInputStream e ImageOutputStreamImpl: permettono di effettuare

operazioni di lettura e scrittura direttamente su oggetti delle classi File e
AccessRandomFile. (FileImageInputStream(File f)).

ImageIO: file immagine associati ad oggetti FileImageInputStream e

FileImageOutputStream. Gestibili con metodi: static BufferedImage
read(ImageInputStream inStr), static boolean write(BufferedImage img, String
formatName, ImageOutputStream ouStr). Questi metodi rintracciano gli
ImageReader e ImageWriter specifici per le tipologie di file ed effettuano
operazioni elementari di codifica e decodifica di immagini (IOException).