Componenti fondamentali di un programma Java

Obiettivi 1. Saper definire i concetti di classe, oggetto, variabile, metodo e costruttore 2. Saper dichiarare una classe 3. Istanziare oggetti da una classe 4. Utilizzare i membri pubblici di un oggetto sfruttando l’operatore dot ( “ . ” ) 5. Dichiarare ed invocare un metodo 6. Saper dichiarare ed inizializzare una variabile 7. Saper definire ed utilizzare i diversi tipi di variabili (d’istanza, locali e parametri Formali) 8. Dichiarare ed invocare un metodo costruttore 9. Saper accennare alla definizione di costruttore di default 10. Saper accennare alla definizione di package

Componenti fondamentali di un programma Java 1) Classe 2) Oggetto 3) Membro: a. Attributo (variabile membro) b. Metodo (metodo membro) 4) Costruttore 5) Package

Convenzione per la programmazione Java Nello sviluppo di una applicazione Java distinguiamo due ambiti: 1. Ambito del compilatore (o compilativo, o delle classi). E’ la parte strutturale. 2. Ambito della Java Virtual Machine (o esecutivo, o degli oggetti). Qui si definisce il flusso di lavoro che deve essere seguito.

Le basi della programmazione object oriented: classi ed oggetti 1) Una classe è un’astrazione indicante un insieme di oggetti che condividono le stesse caratteristiche e le stesse funzionalità. 2) Un oggetto è un’istanza (ovvero, una creazione fisica) di una classe. Questa teoria è nata, proprio per soddisfare l'esigenza umana di interagire con il software in maniera "naturale“. Con Java è possibile creare codice per astrarre un qualsiasi concetto del mondo reale.

Esempio: classe Punto public class Punto { public int x; public int y; } Lo scopo di questa classe è definire il concetto di punto (a due dimensioni), tramite la definizione delle sue coordinate su di un piano cartesiano. Le coordinate sono state astratte mediante due attributi (variabili) dichiarati di tipo intero (int) e pubblici (public), chiamati x ed y. Questa classe potrebbe costituire una parte di un'applicazione Java, magari un'applicazione di disegno… Il file può essere salvato in Punto.java, compilato (javac Punto.java) ma non eseguito (manca il metodo main).

Con il codice scritto finora, in realtà, non abbiamo ancora definito nessun punto vero e proprio (per esempio il punto di coordinate x=5 e y=6). Quindi, come nel mondo reale, se non esistono punti concreti (ma solo la definizione di punto) non può accadere nulla che abbia a che fare con un punto e così, nel codice Java, la classe Punto non è "eseguibile" da sola! Occorre quindi definire gli "oggetti punto", ovvero le creazioni fisiche realizzate a partire dalla definizione data dalla classe. Nel contesto della programmazione ad oggetti, una classe dovrebbe quindi limitarsi a definire che struttura avranno gli oggetti che da essa saranno istanziati. "Istanziare", come abbiamo già affermato, è il termine object oriented che si usa in luogo di "creare fisicamente", ed il risultato di un’istanziazione viene detto "oggetto".

Utilizzo della classe Punto 1 public class Principale 2 { 3 public static void main(String args[]) 4 { 5 Punto punto1; 6 punto1 = new Punto(); 7 punto1.x = 2; 8 punto1.y = 6; 9 Punto punto2 = new Punto(); 10 punto2.x = 0; 11 punto2.y = 1; 12 System.out.println(punto1.x); 13 System.out.println(punto1.y); 14 System.out.println(punto2.x); 15 System.out.println(punto2.y); 16 } 17 }

Analisi del codice 5 Punto punto1; Dichiarazione di un oggetto di tipo “Punto” 6 punto1 = new Punto(); Istanziazione (creazione) della classe Punto. La parola chiave new, di fatto, istanzia la classe Punto, a cui viene assegnato il nome punto1. Dalla riga 6 in poi è possibile utilizzare l’oggetto punto1.

L’operatore "dot" ( “ . “ ) serve per accedere alle variabili x e y. 7 punto1.x = 2; 8 punto1.y = 6; Alle righe 7 e 8 utilizziamo l’oggetto punto1 per assegnare alle sue coordinate x e y rispettivamente i valori interi 2 e 6. Sfruttando la definizione che ci ha fornito la classe Punto, abbiamo creato un oggetto di tipo Punto, che è individuato dal nome punto1. L’operatore "dot" ( “ . “ ) serve per accedere alle variabili x e y.

Abbiamo poi impostato le sue coordinate a 0 e 1. 9 Punto punto2 = new Punto(); Qui abbiamo dichiarato ed istanziato con un’unica riga di codice un altro oggetto dalla classe Punto, chiamandolo punto2. 10 punto2.x = 0; 11 punto2.y = 1; Abbiamo poi impostato le sue coordinate a 0 e 1. 12 System.out.println(punto1.x); 13 System.out.println(punto1.y); 14 System.out.println(punto2.x); 15 System.out.println(punto2.y); Abbiamo infine stampato le coordinate di entrambi i punti.

Facciamo il …punto La classe è servita per definire come saranno fatti gli oggetti. L’oggetto rappresenta una realizzazione fisica della classe. In questo esempio, abbiamo istanziato due oggetti diversi da una stessa classe. Entrambi questi oggetti sono punti, ma evidentemente sono punti diversi (si trovano in diverse posizioni sul riferimento cartesiano). Questo ragionamento, in fondo, è già familiare a chiunque, giacché derivante dal mondo reale che ci circonda. L’essere umano, per superare la complessità della realtà, raggruppa gli oggetti in classi. Per esempio, nella nostra mente esiste il modello definito dalla classe Persona. Ma nella realtà esistono miliardi di oggetti di tipo Persona, ognuno dei quali ha caratteristiche uniche.

Ulteriori osservazioni La classe Punto ha la caratteristica di rappresentare “un dato”.  è una parte strutturale dell’applicazione (svolge un ruolo essenziale nell’ambito compilativo. Nell’ambito esecutivo, la classe Punto non ha un ruolo attivo. Infatti sono gli oggetti istanziati da essa che influenzano il flusso di lavoro del programma. In un’applicazione object oriented, una classe dovrebbe limitarsi a definire la struttura comune di un insieme di oggetti, e non dovrebbe mai “possedere” né variabili né metodi. Infatti, la classe Punto non possiede le variabili x e y, bensì, dichiarando le due variabili, definisce gli oggetti che da essa saranno istanziati, come possessori di quelle variabili. Mai all’interno del codice dell’ambito esecutivo è presente un’istruzione come: Punto.x ovvero: NomeClasse.nomeVariabile bensì: punto1.x ovvero nomeOggetto.nomeVariabile

L’operatore ". " è sinonimo di “appartenenza” L’operatore "." è sinonimo di “appartenenza”. Sono quindi gli oggetti a possedere le variabili dichiarate nella classe (che tra l’altro verranno dette "variabili d’istanza", ovvero dell'oggetto). Infatti, i due oggetti istanziati avevano valori diversi per x e y, il che significa che l’oggetto punto1 ha la sua variabile x e la sua variabile y, mentre l’oggetto punto2 ha la sua variabile x e la sua variabile y. Le variabili di punto1 sono assolutamente indipendenti dalle variabili di punto2. Giacché le classi non hanno membri (variabili e metodi), non eseguono codice e non hanno un ruolo nell’ambito esecutivo, e per quanto visto sono gli oggetti protagonisti assoluti di quest’ambito.

L’eccezione che conferma la regola La classe “Principale” è una classe che esegue codice contenuto all’interno dell’unico metodo main(), che per quanto detto è assunto per default quale punto di partenza di un’applicazione Java. In qualche modo, infatti, i creatori di Java dovevano stabilire un modo per far partire l'esecuzione di un programma. In Java i programmi chiamanti non esistono, ma esistono i metodi, ed in particolare i metodi statici (dichiarati con un modificatore static). Per ora limitiamoci a sapere che un membro dichiarato statico appartiene alla classe e che tutti gli oggetti istanziati da essa condivideranno i membri statici.

Esempio: classe Auto public class Auto { public int numeroRuote = 4; public int cilindrata; // quanto vale? public void muoviti() // implementazione del metodo... }

1 public class Principale2 2 { 3 public static void main(String args[]) 4 { 5 Auto fiat500; 6 fiat500 = new Auto(); 7 fiat500.cilindrata = 500; 8 fiat500.muoviti(); 9 Auto ferrariTestarossa = new Auto(); 10 ferrariTestarossa.cilindrata = 3000; 11 ferrariTestarossa.muoviti(); 12 } 13 }

I metodi in Java “Metodo" è sinonimo di "azione". Affinché un programma esegua qualche istruzione, deve contenere metodi. Per esempio è il metodo main(), che per default, è il punto di partenza di ogni applicazione Java. Una classe senza metodo main(), come la classe Punto, non può essere mandata in esecuzione, ma solo istanziata all’interno di un metodo di un’altra classe (nell’esempio precedente, nel metodo main() della classe Principale). Il concetto di metodo è quindi anch’esso alla base della programmazione ad oggetti. Senza metodi, gli oggetti non potrebbero comunicare tra loro. Distinguere nettamente due fasi: dichiarazione e chiamata (ovvero la definizione e l’utilizzo).

Dichiarazione di un metodo Definisce un metodo: [modificatori] tipo_di_ritorno nome_del_metodo ([parametri]) {corpo_del_metodo} • modificatori: parole chiave di Java che possono essere usate per modificare in qualche modo le funzionalità e le caratteristiche di un metodo. Esempi di modificatori sono public e static. • tipo di ritorno: il tipo di dato che un metodo potrà restituire dopo essere stato chiamato. Questo potrebbe coincidere sia con un tipo di dato primitivo come un int, sia con un tipo complesso (un oggetto) come una stringa (classe String). È possibile specificare che un metodo non restituisca nulla (void).

• nome del metodo: identificatore del metodo • nome del metodo: identificatore del metodo. • Parametri: dichiarazioni di variabili che potranno essere passate al metodo, e di conseguenza essere sfruttate nel corpo del metodo, al momento della chiamata. Il numero di parametri può essere zero, ma anche maggiore di uno. Se si dichiarano più parametri, le loro dichiarazioni saranno separate da “,” • corpo del metodo: insieme di istruzioni (statement) che verranno eseguite quando il metodo sarà invocato. La coppia costituita dal nome del metodo e l’eventuale lista dei parametri viene detta “firma” (in inglese “signature”) del metodo.

Esempio: classe Aritmetica public class Aritmetica { public int somma(int a, int b) return (a + b); }

Analisi del codice Il modificatore public è uno specificatore d’accesso che rende il metodo somma() accessibile da altre classi: i metodi di altre classi potranno, dopo aver istanziato un oggetto della classe Aritmetica, invocare il metodo somma(). Il tipo di ritorno è un int, ovvero, un intero. Ciò significa che questo metodo avrà come ultima istruzione un comando (return) che restituirà un numero intero. Inoltre la dichiarazione di questo metodo evidenzia come lista di parametri due interi (chiamati a e b). La dichiarazione di un metodo definisce quali azioni deve compiere il metodo stesso, quando sarà chiamato

Chiamata (o invocazione) di un metodo Esempio di eseguibile della classe Aritmetica: 1 public class Uno 2 { 3 public static void main(String args[]) 4 { 5 Aritmetica oggetto1 = new Aritmetica(); 6 int risultato = oggetto1.somma(5, 6); 7 } 8 }

Analisi del codice int risultato = oggetto1.somma(5, 6); L’accesso al metodo somma() è avvenuto tramite l’operatore "dot" come nel caso dell’accesso alle variabili. Tutti i membri (attributi e metodi) pubblici definiti all’interno di una classe saranno accessibili tramite un’istanza della classe stessa che sfrutta l’operatore dot. La sintassi da utilizzare è la seguente: nomeOggetto.nomeMetodo(); e nomeOggetto.nomeAttributo;

L’accesso al metodo di un oggetto provoca l’esecuzione del relativo blocco di codice. In quest’esempio, quindi, abbiamo definito una variabile intera risultato che ha immagazzinato il risultato della somma. Se non avessimo fatto ciò, non avrebbe avuto senso definire un metodo che restituisse un valore, dal momento che non l’avremmo utilizzato in qualche modo! Avremmo anche potuto aggiungere la riga seguente: System.out.println(risultato);

Esistono anche: metodi che non hanno parametri in input ma, per esempio, un metodo che somma sempre gli stessi numeri e quindi restituisce sempre lo stesso valore. metodi che non hanno tipo di ritorno e dichiarano come tipo di ritorno void(vuoto) come il metodo main(). Infatti il metodo main() è il punto di partenza del runtime di un’applicazione Java, quindi non deve restituire un risultato, non venendo chiamato esplicitamente da un altro metodo. In questo caso il risultato del metodo non deve essere “catturato” metodi che non hanno né parametri in input, né in output (tipo di ritorno void), come per esempio un semplice metodo che visualizza a video sempre lo stesso messaggio.

Varags: Variable arguments Dalla versione 5 di Java è possibile creare metodi che dichiarano un numero non definito di parametri di un certo tipo: public class AritmeticaVariabile { public void somma(int… interi) { //... } Può essere invocato in diversi modi: AritmeticaVariabile ogg = new AritmeticaVariabile(); ogg.somma(); ogg.somma(1,2); ogg.somma(1,4,40,27,48,27,36,23,45,67,9,54,66,43); ogg.somma(1);

Le variabili in Java Una variabile è una porzione di memoria in cui è immagazzinato un certo tipo di dato. Possiamo distinguere due fasi: dichiarazione ed assegnazione. L’assegnazione di un valore ad una variabile è un’operazione che si può ripetere molte volte nell’ambito esecutivo, anche contemporaneamente alla dichiarazione stessa.

Dichiarazione di una variabile Sintassi: [modificatori] tipo_di_dato nome_della_variabile [ =inizializzazione]; modificatori: parole chiavi di Java che possono essere usate per modificare in qualche modo le funzionalità e le caratteristiche della variabile. tipo di dato: il tipo di dato della variabile. nome della variabile: identificatore della variabile. inizializzazione: valore di default con cui è possibile valorizzare una variabile.

Esempio: classe Quadrato public class Quadrato { public int altezza; public int larghezza; public final int NUMERO_LATI = 4; } Abbiamo definito: Due variabili intere (altezza e larghezza) Una costante (NUMERO_LATI): Il modificatore final infatti rende una variabile costante nel suo valore.

Osservazioni E’ anche possibile definire due variabili dello stesso tipo con un’unica istruzione: public int altezza,larghezza; La dichiarazione di una variabile è molto importante. La posizione della dichiarazione definisce lo “scope”, ovvero la visibilità, ed il ciclo di vita della variabile stessa. In pratica potremmo definire tre diverse tipologie di variabili, basandoci sul posizionamento della dichiarazione (vedi slide seguenti).

Variabili di istanza Variabile dichiarata in una classe ma al di fuori di un metodo. Le variabili definite nella classe Quadrato sono tutte di istanza. Esse condividono il proprio ciclo di vita con l’oggetto (istanza) cui appartengono. Quando un oggetto della classe Quadrato è istanziato, viene allocato spazio per tutte le sue variabili d’istanza che vengono inizializzate ai relativi valori nulli. Nel nostro caso, le variabili altezza e larghezza saranno inizializzate a zero. Ovviamente NUMERO_LATI è una costante esplicitamente inizializzata a 4, ed il suo valore non potrà cambiare. Una variabile d’istanza smetterà di esistere quando smetterà di esistere l’oggetto a cui appartiene.

Variabili locali Detta anche variabile di stack, o automatica, o temporanea). E’ dichiarata all’interno di un metodo. Essa smetterà di esistere quando terminerà il metodo. Una variabile di questo tipo, a differenza di una variabile di istanza, non sarà inizializzata ad un valore nullo al momento dell’istanza dell’oggetto a cui appartiene. È buona prassi inizializzare comunque una variabile locale ad un valore di default, nel momento in cui la si dichiara. Infatti il compilatore potrebbe restituire un messaggio di errore laddove ci sia possibilità che la variabile non venga inizializzata al runtime

Parametri formali Detti anche argomenti del metodo. Variabili dichiarate all’interno delle parentesi tonde che si trovano alla destra dell’identificatore nella dichiarazione di un metodo. I parametri di un metodo saranno inizializzati al momento della chiamata del metodo. Condividendo il ciclo di vita con il metodo in cui sono dichiarate, non ha senso anteporre alle variabili locali un modificatore d’accesso come public.

I metodi costruttori 1. Ha lo stesso nome della classe (case sensitive) 2. Non ha tipo di ritorno (non significa che il tipo di ritorno è void, ma che non dichiara alcun tipo di ritorno) 3. È chiamato automaticamente (e solamente) ogni volta che è istanziato un oggetto, relativamente a quell’oggetto. 4. È presente in ogni classe.

Esempio: costruttore esplicito public class Punto { public Punto() //metodo costruttore System.out.println("costruito un Punto"); } int x; int y; Verrà eseguito il blocco di codice del costruttore, ogni volta che sarà istanziato un oggetto

Per istanziare un oggetto scriviamo: Punto punto1; // dichiarazione punto1 = new Punto(); //istanza “new” è la parola chiave per istanziare formalmente l’oggetto, Basterebbe quindi scrivere: new Punto(); però, l’oggetto appena creato non avrebbe un “nome” (si dirà “reference”) e quindi non sarebbe utilizzabile. Punto() Non va interpretata come “nomeDellaClasse con parentesi tonde”, bensì come “chiamata al metodo costruttore”.

Costruttore con parametri public class Punto { public Punto(int a, int b) x = a; y = b; } public int x; public int y;

Con questa classe non sarà più possibile istanziare gli oggetti con la solita sintassi: Punto punto1 = new Punto(); otterremmo un errore di compilazione, dal momento che staremmo cercando di chiamare un costruttore che non esiste (quello senza parametri)! La sintassi da utilizzare però, potrebbe essere la seguente. Punto punto1 = new Punto(5,6); Questa ci permetterebbe anche d’inizializzare l’oggetto direttamente senza essere costretti ad utilizzare l’operatore dot. Infatti, la precedente riga di codice è equivalente alle seguenti: punto1.x = 5; punto1.y = 6;

Costruttore di default Se infatti proviamo a compilare una classe sprovvista di costruttore, il compilatore ne fornisce uno implicitamente. Il costruttore inserito non contiene comandi che provocano qualche conseguenza visibile al programmatore. Esso è detto "costruttore di default" e non ha parametri. Ciò giustifica il fatto che fino ad ora non abbiamo mai istanziato oggetti passando parametri al costruttore. Nel momento in cui il programmatore fornisce ad una classe un costruttore, sia esso con o senza parametri, il compilatore non inserirà quello di default.

Package (cenni) Un package in Java permette di raggruppare in un'unica entità complessa classi Java logicamente correlate. Fisicamente il package non è altro che una cartella del nostro sistema operativo, ma non tutte le cartelle sono package. Per eleggere una cartella a package, una classe Java deve dichiarare nel suo codice la sua appartenenza a quel determinato package, ed inoltre ovviamente, deve risiedere fisicamente all’interno di essa.