1 novembre I nomi in Java F. Bombi 1 novembre 2002

2 Le variabili Una variabile è una posizione in memoria alla quale è associato un determinato tipo che può essere o un tipo primitivo o un riferimento Una variabile ha sempre un valore compatibile con il suo tipo Il valore di una variabile può essere modificato da un’assegnazione oppure da un operatore di incremento ( ++ ) o decremento ( -- )

1 novembre I 7 tipi di variabili Variabile di classe: un campo di una classe con l’attributo static Variabile di esemplare: un campo di una classe senza l’attributo static Componenti di un array: sono variabili senza nome che vengono create quando si crea un array destinate a contenere i singoli elementi dell’array Parametro di un metodo: nome di un argomento che verrà passato al metodo Parametro di un costruttore Parametro di un gestore di eccezione Variabile locale: variabile dichiarata all’interno di un blocco

1 novembre Variabile di classe Una variabile di classe viene creata al momento in cui la classe viene caricata nella memoria della macchina virtuale e in assenza di indicazione contraria viene inizializzata a 0, false o null Di una variabile di classe esiste un solo esemplare condiviso da tutti gli oggetti della classe L’uso di variabili di classe è limitato a casi molto specifici ad esempio per costanti simboliche condivise oppure per contare quanti esemplari di una classe sono stati creati o per segnalare ad altri esemplari di una classe che si è invocato un metodo class A { static int vs; public A () {vs++;} … } … A uno = new A(); … A due = new A(); … System.out.println(A.vs);

1 novembre Variabili di esemplare Le variabili di esemplare (instance variable) rappresentano il caso più comune di campo di una classe Un nuova variabile di esemplare viene creata ogni volta che si crea un esemplare della classe che la contiene, in assenza di indicazione contraria, le variabili di esemplare sono sempre inizializzate a 0, false o null Un variabile di esemplare cessa di esistere quando l’oggetto che la contiene non è più indirizzato da un riferimento (lo spazio di memoria è a questo punto soggetto a garbage collection)

1 novembre Componenti di un array Le componenti di un array sono variabile senza nome che vengono create al momento della creazione dell’array. Sono inizializzati a 0, false o null Fare attenzione che se si crea un array di oggetti la creazione dell’array crea solo i riferimenti agli oggetti (inizializzati a null ) e non gli oggetti che dovranno essere esplicitamente creati uno per uno class coppia { int a; int b;} … coppia[] v = new coppia[4]; v[0].a = 25; // null pointer class coppia { int a; int b;} … coppia[] v = new coppia[4]; for(int i=0;i<4;i++) v[i] = new coppia(); v[0].a = 25; // OK

1 novembre I parametri Un parametro attribuisce un nome all’interno di un metodo all’argomento con il quale il metodo viene invocato Un parametro viene creato al momento dell’invocazione del metodo e cessa di esistere quando si conclude il blocco che costituisce il corpo del metodo Un parametro viene inizializzato con il valore dell’argomento usato al momento della chiamata del metodo Java di conseguenza utilizza sempre e solo il passaggio dei parametri per valore class a { void m(int i) { int locale; locale = i*i; } … a x = new a(); int k = 25; x.m(k); x.m(3); parametro argomento i = k = 25

1 novembre // Il passaggio dei parametri in Java public class Param { public static void main (String[] arg) { int i = 1; int j = 2; System.out.println("Prima: i= " + i + " j= " + j); scambia(i, j); System.out.println("Dopo1: i= " + i + " j= " + j); Integer ii = new Integer(i); Integer jj = new Integer(j); scambia(ii, jj); System.out.println("Dopo2: i= " + ii + " j= " + jj); MioInt iii = new MioInt(); iii.valore = i; MioInt jjj = new MioInt(); jjj.valore = j; scambia(iii, jjj); System.out.println("Dopo3: i= " + iii + " j= " + jjj); } static void scambia (int x, int y) { int tmp = x; x = y; y = tmp; } static void scambia (Integer x, Integer y) { Integer tmp = x; x = y; y = tmp; } static void scambia (MioInt x, MioInt y) { int tmp = x.valore; x.valore = y.valore; y.valore = tmp; } class MioInt { int valore; public String toString() { return Integer.toString(valore); } }

1 novembre int i = 1; int j = 2; 1 i 2 j scambia(i, j); static void scambia (int x, int y) { int tmp = x; x = y; y = tmp; } ? x ? y inizializza ? tmp al ritorno del metodo scambia le variabili i e j sono immutate

1 novembre Integer ii = new Integer(1); Integer jj = new Integer(2); ii jj scambia(ii,jj); inizializza x y al ritorno del metodo scambia i riferimenti ii e jj sono immutati 1 2 static void scambia (Integer x, Integer y) { Integer tmp = x; x = y; y = tmp; } tmp

1 novembre Valore ? jjj Valore ? iii MioInt iii = new MioInt(); iii.valore = 1; MioInt jjj = new MioInt(); jjj.valore = 2; scambia(iii, jjj); al ritorno del metodo scambia i riferimenti iii e jjj non sono cambiati sono però stati scambiati i campi inizializza x y 1 2 tmp static void scambia (MioInt x, MioInt y) { int tmp = x.valore; x.valore = y.valore; y.valore = tmp; } 1 2 1

1 novembre Come ritornare un valore Il meccanismo del passaggio dei parametri ad un metodo essendo per valore è unidirezionale, il parametro viene inizializzato con l’argomento al momento della chiamata, se il parametro viene modificato l’argomento rimane immutato Un metodo può restituire una sola variabile con la clausola return, il tipo di valore restituito deve essere indicato nella dichiarazione del metodo

1 novembre Uso di variabili globali All’interno di una classe due metodi possono scambiarsi dati utilizzando un campo della classe come variabile condivisa o globale Questa forma di comunicazione non può essere usata fra metodi di classi diverse in quanto gli esemplari di classi diverse non accedono agli stessi campi Ricordarsi infine che un metodo quando è invocato conosce i campi dell’esemplare della classe individuata dal riferimento usato per invocare il metodo

1 novembre argomento actual parameter parametro reale parametro formal parameter parametro formale all’attivazione o chiamata del metodo il valore dell’argomento viene utilizzato per inizializzare il corrispondente parametro return valore; Alla terminazione del metodo il controllo iene passato al punto di chiamata. I valore dei parametri vengono persi (ma non vengono persi eventuali effetti collaterali). Il metodo può restituire un singolo valore

1 novembre I nomi in Java

1 novembre Pacchetti (package) Una applicazione Java si compone di uno o più pacchetti sottopacchetti Un pacchetto è un insieme di file (unità compilabili), un pacchetto può essere organizzato gerarchicamente in sottopacchetti pacchetto senza nome In assenza di indicazioni contrarie i file contenuti nel directory di lavoro costituiscono un pacchetto senza nome liste Se si esclude l’esempio delle liste (la cui realizzazione è organizzata in un sottopacchetto) tutti gli esempi visti a lezione sono realizzati come pacchetti senza nome

1 novembre I nomi in Java nomi Tutte le entità usate in un programma Java sono individuate da nomi composti da stringhe, dette identificatori, di caratteri alfanumerici con il primo carattere alfabetico dichiarato Ogni nome deve essere dichiarato prima di essere usato, la dichiarazione specifica l’entità cui il nome si riferisce e chi può accedere al nome qualificandolo scope Ogni nome semplice è riconosciuto in una porzione del programma detta il suo scope contesto Il significato di un nome è stabilito dal contesto nel quale viene usato

1 novembre Le entità individuate da un nome possono essere – Una classe – Un’interfaccia – Un membro di una classe (campo o metodo) – Un parametro di un metodo, di un costruttore o di un gestore di eccezione – Una variabile locale semplice Un nome semplice è costituito da un solo identificatore qualificato Un nome qualificato è costituito da più identificatori separati da un public class Coppia implements Comparable { public Comparable chiave; …} public interface Stack { void push (Object x); …} public class Coppia implements Comparable { public Comparable chiave; … public String toString () { return chiave.toString() + ":" + attributo.toString(); } public String toString () { return chiave.toString() + ":" + attributo.toString(); }} public class Coppia implements Comparable { … public Coppia (Comparable c, Object a) { chiave = c; attributo = a; } public Coppia (Comparable c, Object a) { chiave = c; attributo = a; } public int compareTo (Object x) { return chiave.compareTo(((Coppia)x).chiave); } public int compareTo (Object x) { return chiave.compareTo(((Coppia)x).chiave); }} public static void main (String[] arg) throws IOException public static void main (String[] arg) throws IOException { BufferedReader in = new BufferedReader(new FileReader(arg[0])); { BufferedReader in = new BufferedReader(new FileReader(arg[0])); int n = 0; int n = 0; int somma = 0; int somma = 0; … while ((str = in.readLine()) != null) while ((str = in.readLine()) != null) { token = new StringTokenizer(str, ":"); { token = new StringTokenizer(str, ":"); int matricola = Integer.parseInt(token.nextToken()); int matricola = Integer.parseInt(token.nextToken()); String nome = token.nextToken(); String nome = token.nextToken(); dati[n++] = new Studente(nome, matricola); dati[n++] = new Studente(nome, matricola); }

1 novembre Lo scope Lo scope di una dichiarazione è la regione di un programma nell’ambito della quale ci si può riferire ad una entità con il nome semplice Lo scope del nome di una classe è l’intero pacchetto nel quale la classe compare Lo scope di un membro di una classe è l’intera classe nella quale è dichiarato Lo scope di un parametro di un metodo o di un costruttore è l’intero corpo del metodo o del costruttore Lo scope di una variabile locale dichiarata in un blocco si estende fino alla fine del blocco for Lo scope di una variabile locale dichiarata nell’inizializzazione di un ciclo for si estende al solo corpo del ciclo public class Coppia implements Comparable { public Object attributo; public Coppia (Comparable c, Object a) { chiave = c; attributo = a; } public Coppia (Comparable c, Object a) { chiave = c; attributo = a; } public int compareTo (Object x) { return chiave.compareTo(((Coppia)x).chiave); } public int compareTo (Object x) { return chiave.compareTo(((Coppia)x).chiave); } public String toString () { return chiave.toString() + ":" + attributo.toString(); } public String toString () { return chiave.toString() + ":" + attributo.toString(); } public Comparable chiave; public Comparable chiave;} int[] r = c.contiene(); int[] r = c.contiene(); for (int i = 0; i < r.length; i++) for (int i = 0; i < r.length; i++) System.out.print(r[i] + ", "); System.out.print(r[i] + ", "); System.out.println(); System.out.println(); c.togli(1); c.togli(1); r = c.contiene(); r = c.contiene(); for (int i = 0; i < r.length; i++) for (int i = 0; i < r.length; i++) System.out.print(r[i] + ", "); System.out.print(r[i] + ", "); System.out.println(); System.out.println(); for (int i = 0; i < 32; i++) for (int i = 0; i < 32; i++) if (c.appartiene(i)) if (c.appartiene(i)) System.out.print("1"); System.out.print("1"); else else System.out.print("0"); System.out.print("0");

1 novembre Il controllo dell’accesso nomi qualificati L’uso di nomi qualificati consente di controllare l’accesso ai membri di una classe indipendentemente dallo scope, si danno 4 casi: – default – default: accesso a livello di package – public – public : accesso da qualsiasi punto – private – private : accesso possibile solo dall’interno della classe nella quale il nome è dichiarato – protected – protected : accesso a livello di package e nelle sottoclassi che estendono la classe In genere i campi di una classe sono private (o protected) in quanto si vuole che solo i metodi della classe possano modificare il valore dei campi mentre i metodi sono public perché devono poter essere utilizzati dall’esterno della classe

1 novembre Oscurare una dichiarazione La dichiarazione di un nome all’interno di un blocco contenuto in un altro blocco può oscurare la dichiarazione più esterna In genere è bene evitare di dichiarare la stessa variabile in blocchi diversi con significati diversi per evitare confusione (il compilatore non si confonde ma il lettore può rimanere confuso)

1 novembre public class StackAr implements Stack { private Object[] v; private int sp; private int sp; private static final int MAX = 10; private static final int MAX = 10; public StackAr () public StackAr () { sp = 0; { sp = 0; Object[] v = new Object[MAX]; Object[] v = new Object[MAX]; } public StackAr (int max) public StackAr (int max) { sp = 0; { sp = 0; v = new Object[max]; v = new Object[max]; } public void push (Object x) { v[sp++] = x; } public void push (Object x) { v[sp++] = x; } public Object pop () throws Underflow public Object pop () throws Underflow { if (sp == 0) { if (sp == 0) throw new Underflow("Pop di stack vuoto"); throw new Underflow("Pop di stack vuoto"); else else return v[--sp]; return v[--sp]; } public Object testa () throws Underflow public Object testa () throws Underflow { if (sp == 0) { if (sp == 0) throw new Underflow("Testa di stack vuoto"); throw new Underflow("Testa di stack vuoto"); else else return v[sp-1]; return v[sp-1]; } public boolean vuoto () { return sp == 0; } public boolean vuoto () { return sp == 0; }}