Menu


Trascrizione diapositive

1. Componenti fondamentali

  • Complessità: MEDIA.


2. Componenti fondamentali di un programma scritto in Java

Ecco una lista di concetti che sono alla base della conoscenza di Java:

  • Classe
  • Oggetto
  • Attributo («variabile» della classe o del metodo)
  • Metodo («azione» della classe)
  • Costruttore
  • Package


3. Definizione di classe ed oggetto

  • Una classe è un’astrazione indicante un insieme di oggetti che condividono le stesse caratteristiche (attributi) e le stesse funzionalità (metodi).
  • Un oggetto è un’istanza (ovvero, una creazione fisica) di una classe.

Le prossime diapositive hanno la finalità di spiegare in modo semplice questi due concetti che possono apparire complessi a prima vista ad utenti non esperti.



4. Esempio di classe

  • Per far capire meglio cosa è una classe passiamo subito ad un esempio pratico:

public class Punto {
               public int x;
               public int y;
}

  • In questo esempio notiamo che siamo riusciti con sole 4 righe di codice a definire un punto (a due coordinate), lo abbiamo dichiarato attraverso due attributi (variabili) dichiarati di tipo intero (int) e di tipo pubblico (public) e chiamati rispettivamente «x» ed «y».
  • Se salviamo questo listato in un file chiamato «Punto.java» e lo compiliamo tramite il comando «javac Punto.java», otteniamo al momento di mandarlo in esecuzione una terminazione immediata del programma stesso; questo perché in questa classe manca il metodo «main()», che abbiamo definito come punto di partenza di ogni applicazione.


5. Esempio di classe

  • Ci è chiaro fin da subito che con la sola definizione di classe, definiamo in effetti semplicemente un modello.
  • Un modello è una descrizione astratta di un oggetto vero e proprio, infatti in questo caso ancora non abbiamo definito le coordinate di questo punto (ad esempio: x=5 e y=6).
  • 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!


6. Esempio di oggetto

  • Occorre quindi definire i cosiddetti oggetti «Punto»; si tratta della creazione fisica realizzata a partire dal modello che si trova nella classe «Punto». Segue il listato:

[Download]

class Punto {
               public int x;
               public int y;
}

public class Programma {
  public static void main(String args[]) {
               Punto punto1; // Viene dichiarato un oggetto di tipo Punto chiamato punto1
               punto1 = new Punto(); // Viene assegnato a punto1 il suo modello che si trova nelle classe Punto
               punto1.x = 2; // Viene assegnata la coordinata x all’oggetto chiamato punto1
               punto1.y = 6; // Viene assegnata la coordinata y all’oggetto chiamato punto1
               Punto punto2; // Viene dichiarato un oggetto di tipo Punto chiamato punto2
               punto2 =new Punto(); // Viene assegnato a punto2 il suo modello che si trova nelle classe Punto
               punto2.x = 0; // Viene assegnata la coordinata x all’oggetto chiamato punto2
               punto2.y = 1; // Viene assegnata la coordinata y all’oggetto chiamato punto2
               System.out.println(punto1.x); // Viene mostrata in output la coordinata x dell’oggetto chiamato punto1
               System.out.println(punto1.y); // Viene mostrata in output la coordinata y dell’oggetto chiamato punto1
               System.out.println(punto2.x); // Viene mostrata in output la coordinata x dell’oggetto chiamato punto2
               System.out.println(punto2.y); // Viene mostrata in output la coordinata y dell’oggetto chiamato punto2
  }
}

ATTENZIONE!
Bisogna notare che il file adesso dovrà chiamarsi «Programma.java» e non più «Punto.java»


7. Osservazione importante sulla classe Punto

  • È necessario fare una considerazione importante sulla sintassi utilizzata: fino ad ora abbiamo parlato di dichiarazione di un oggetto e di assegnazione ad esso di un modello stabilito nella classe; è necessario specificare, che quando si parla assegnazione di un modello ad un oggetto, in effetti, si parla in termini tecnici di istanziare oggetti.
  • Vediamo quindi un frammento di codice che ci descrive meglio come avremmo dovuto commentare:

Punto punto1; // Dichiarazione
punto1 = new Punto(); // Istanza



8. Osservazione importante sulla classe Punto

  • Adesso che dovremmo essere in grado di capire la differenza tra classe ed oggetto non dovremo aver difficoltà a dichiarare ed istanziare un oggetto in un’unica riga di codice, in questo modo:

Punto punto1= new Punto(); // Dichiarazione ed istanza

  • Che è assolutamente equivalente a:

Punto punto1; // Dichiarazione
punto1 = new Punto(); // Istanza



9. Altra osservazione importante sulla classe Punto

  • Quando compiliamo il programma attraverso l’istruzione javac, la classe «Punto» svolge un ruolo essenziale in quanto ci permette di definire un punto (di creare veri e propri oggetti che rappresentano un punto).
  • Quando tuttavia eseguiamo il programma, la classe «Punto» è come se non esistesse, o per meglio dire in questo caso non svolge un ruolo attivo, in quanto sono gli oggetti istanziati dalla classe che influenzano il flusso di lavoro del programma.
  • Il caso preso in esame può definirsi come il caso standard di una applicazione object oriented; infatti una classe dovrebbe limitarsi a definire la struttura comune di un insieme di oggetti, e non dovrebbe mai possederevariabili e neanche metodi. Infatti, la classe «Punto» non possiede le variabili «x» ed «y».
  • La dimostrazione di questo è data dal fatto che noi non scriviamo «Punto.x» ovvero «NomeClasse.nomeVariabile» che in questo caso produrrebbe un errore in compilazione, ma scriviamo «punto1.x» ovvero «NomeOggetto.NomeVariabile».
  • 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).


10. Ultima osservazione

  • L’esempio presentato prima è matematico; infatti è facile pensare ad un punto sul piano cartesiano come formato da due coordinate «x» ed «y». Ci sono però concetti del mondo reale la cui istanza varia da persona a persona; Se confrontiamo il modello (ovvero la classe) «Auto» che definirebbe un intenditore di automobili, con quella di una persona che non possiede neanche la patente, sussisterebbero significative differenze; l’inesperto potrebbe definire un auto come un mezzo di trasporto (quindi che si può muovere), con quattro ruote ed una cilindrata; mentre l’intenditore potrebbe ad esempio introdurre caratteristiche come modello, telaio, pneumatici, etc…
  • Per convenienza ragioneremo come l’inesperto, creando una classe e dichiarando un attributo di tipo pubblico (public) e intero (int), chiamato «numeroRuote» ed inizializzato a 4. Inoltre definiamo un’altra variabile chiamata «cilindrata», ed un metodo (azione) che potemmo chiamare «muoviti()».

class Auto {
               public int numeroRuote = 4;
               public int cilindrata;
               public void muoviti() {
// implementazione del metodo…
               }
}


Quest’ultimo esempio rappresenta la miglior tecnica per introdurre il concetto di metodo che adesso andremo ad approfondire.



11. I metodi in Java

  • Abbiamo già accennato nelle diapositive precedenti che il termine metodo è sinonimo di azione, quindi affinché il programma esegua qualche azione reale deve contenere uno o più metodi.
  • E’ bene che il lettore cominci a distinguere nettamente due fasi per quanto riguarda i metodi: dichiarazione e chiamata (ovvero la definizione e l’utilizzo).


12. Dichiarazione di un metodo

  • La dichiarazione definisce un metodo. Ecco in dettaglio la sintassi da utilizzare all’interno di una classe:

dove:

[modificatori]   tipo_di_ritorno   nome_del_metodo([parametri])   {
corpo_del_metodo
}

  • modificatori: sono parole chiave di Java e permettono di modificare la visibilità e le funzionalità del metodo, esempi di modificatori sono: private, public, static; di cui ci occuperemo più avanti.
  • tipo di ritorno: il tipo di dato che il metodo dovrà restituire dopo essere stato chiamato. Questo potrebbe coincidere sia con un tipo di dato primitivo come un intero (int), sia con un tipo di dato più complesso (un oggetto). È anche possibile che il metodo non restituisca nulla (void).
  • 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 pari a zero o maggiore di zero, in tal caso le loro dichiarazioni saranno separate da virgole.
  • corpo del metodo: tutto l’insieme delle istruzioni (statement) che saranno eseguite non appena il metodo sarà invocato.

La coppia costituita dal nome del metodo e l’eventuale lista dei parametri viene detta «firma» del metodo.


13. Esempio di metodo

  • Ecco di seguito un banale esempio di metodo di somma tra due numeri:

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

  • Notiamo che il metodo presenta come modificatore la parola chiave public, si tratta di uno specificatore d’accesso che rende il metodo «somma()» accessibile anche da altre classi; se fosse stato di tipo private l’invocazione (vedi prossima slide) di questo metodo poteva avvenire solo dalla classe stessa. Chiaramente «somma()» è l’unico metodo della classe «Aritmetica», se lo avessimo dichiarato di tipo private, non avremmo potuto chiamarlo (o invocarlo) dal metodo «main()» perché questo metodo si trova in un’altra classe.
  • Notiamo inoltre che il tipo di ritorno è un intero (int), ciò significa che questo metodo avrà sicuramente come ultima istruzione il comando return che restituirà un numero intero (int), questo numero sarà dato dalla somma dei due parametri interi (int) chiamati «a» e «b».


14. Chiamata (o invocazione) ad un metodo

  • Adesso scriviamo il codice della classe contenente il metodo «main()», che istanzia un oggetto dalla classe «Aritmetica» e chiama(o se meglio preferite invoca) il metodo «somma()»:

[Download]

public class Programma {
    public static void main(String args[]) {
        Aritmetica oggetto1 = new Aritmetica(); // Dichiarazione ed istanza
        int risultato = oggetto1.somma(5, 6); // Invocazione del metodo «somma()» e assegnazione del risultato alla variabile intera (int) «risultato».
        System.out.println(risultato); // Viene mostrata la variabile «risultato» in modo da verificare la reale esecuzione della somma.
    }
}

  • Notiamo subito che l’accesso al metodo «somma()» è avvenuto sempre tramite l’operatore d’appartenenza «.» come nel caso dell’accesso alle variabili.


15. Altri tipi di metodi

  • Il metodo mostrato prima è un tipo di metodo che restituisce la somma di due numeri a secondo dei due valori che gli vengono passati, ma ad esempio ci sono metodi che sommano sempre gli stessi numeri e che quindi restituiscono sempre lo stesso valore:

class Aritmetica {
               public int somma() {
                 return (5+6);
               }
}


Si invoca così…


public class Programma {
               public static void main(String args[]) {
                 Aritmetica oggetto1 = new Aritmetica();
                 int risultato = oggetto1.somma();
                 System.out.println(risultato);
               }
}

  • Oppure metodi che non restituiscono nulla:

class Aritmetica {
               public void somma() {
                 int risultato = 5+6;
                 System.out.println(risultato);
               }
}


Si invoca così…


public class Programma {
               public static void main(String args[]) {
                 Aritmetica oggetto1 = new Aritmetica();
                 oggetto1.somma();
               }
}



16. Variabili in Java

  • Una variabile è una porzione di memoria in cui viene immagazzinato un determinato dato. I tipi di dato saranno argomento della prossima lezione (anche se fin qui abbiamo già trattato approssimativamente le variabili di tipo int).
  • Adesso è bene soffermarsi sulle due fasi principali che caratterizzano una variabile: la dichiarazione e l’assegnazione. L’assegnazione di un valore ad una variabile è un’operazione che si può ripetere molte volte nel corso dell’esecuzione del programma e può anche verificarsi contemporaneamente alla dichiarazione stessa.


17. Dichiarazione di una variabile

  • La sintassi per dichiarare una variabile è la seguente:

[modificatori]   tipo_di_dato   nome_della_variabile  [ = inizializzazione]
dove:

  • modificatori: sono parole chiave di Java e permettono di modificare la visibilità e le funzionalità della variabile, esempi di modificatori sono: private, public, static; di cui ci occuperemo più avanti.
  • 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.


18. Esempi di dichiarazione di una variabile

  • Qui di seguito un esempio di dichiarazione di una variabile:

class Rettangolo {
               public int altezza;
               public int larghezza;
               public final int NUMERO_LATI = 4;
}


Notare l’uso del modificatore final, che trasforma una variabile in costante rendendo chiaramente impossibile ogni ulteriore modifica.

  • Possiamo definire più variabili dello stesso tipo con un’unica istruzione, come nel seguente esempio:

class Rettangolo {
               public int altezza, larghezza;
               public final int NUMERO_LATI = 4;
}


In questo caso possiamo notare una maggiore compattezza del codice a discapito però di una migliore leggibilità.



19. Variabili d’istanza

  • Una variabile è detta d’istanza se è dichiarata in una classe, ma al di fuori di un metodo. Questo tipo di variabile condivide il proprio ciclo di vita con l’oggetto cui appartiene.
  • L’unico tipo di variabile presente in una classe, ma al di fuori di un metodo che non può essere definita d’istanza è quella che presenta il modificatore static, in quanto una variabile dichiarata con questo tipo di modificatore sarà condivisa da tutti gli oggetti istanziati. Ribadiremo più volte con esempi pratici questo concetto, che sarà in futuro per il lettore sempre più chiaro.


20. Variabili locali

  • Una variabile è detta locale se è dichiarata all’interno di un metodo. Essa smetterà di esistere quando terminerà il metodo. Di seguito un esempio di variabile locale chiamata «z»:

public int somma(int x, int y) {
               int z = x + y;
               return z;
}



21. Parametri formali

  • Le variabili dichiarate all’interno delle parentesi tonde in un metodo, sono dette: parametri.
  • Ad esempio nella seguente dichiarazione del metodo «somma()» vengono specificati due parametri interi «x» ed «y»:

public int somma(int x, int y) {
               return (x + y);
}

  • I parametri di un metodo sono inizializzati al momento della chiamata del metodo. Ad esempio in questo modo:

int risultato = oggetto1.somma(5, 6);

  • Il ciclo di vita di un parametro è uguale a quello di una variabile locale.


22. I metodi costruttori

  • Ci sono caratteristiche tipiche di un metodo particolare chiamato costruttore, sono:
  • Ha lo stesso nome della classe.
  • Non ha tipo di ritorno.
  • E’ chiamato automaticamente ogni volta che viene istanziato un oggetto.
  • E’ presente in ogni classe anche se non dichiarato.


23. Caratteristiche tecniche del costruttore

  • Il costruttore come detto in precedenza è caratterizzato dal fatto che possiede lo stesso nome della classe, ecco un esempio pratico:

class Saluto {
               public Saluto() { // Metodo costruttore
                 System.out.println("Ciao");
               }
}

  • Notare che sarà eseguito il blocco codice del costruttore ogni volta che sarà istanziato un oggetto dal metodo «main()».

Saluto amico1= new Saluto(); // Dichiarazione ed istanza

  • Quindi l’istanza non deve essere interpretata come «NomeDellaClasse()» ma come chiamata al «MetodoCostruttore()».


24. Utilità del costruttore

  • Solitamente il costruttore è utilizzato per inizializzare le variabili d’istanza:

class Punto {
               public Punto(int a, int b) { // Metodo costruttore
                 x = a;
                 y = b;
               }
               public int x;
               public int y;
}

  • A questo punto il costruttore dovrà essere chiamato obbligatoriamente nel seguente modo:

Punto punto1= new Punto(5, 6); // Dichiarazione ed istanza

  • Se lo istanziamo senza parametri otterremo un errore in compilazione in quanto il costruttore di default non esiste più.


25. Costruttore di default

  • Ogni oggetto che noi istanziamo grazie alla parola chiave new effettuerà sempre una chiamata automatica ad un metodo costruttore, il lettore potrà obiettare che in molti esempi fin qui forniti le classi non hanno fatto uso di costruttori. È giusto specificare che in ogni classe sprovvista di costruttore ne viene aggiunto uno automaticamente dal compilatore anche se noi non lo dichiariamo. Questo tipo di costruttore si chiama appunto costruttore di default, ecco un esempio:

class Punto {
               public int x;
               public int y;
}

  • Al momento della compilazione con javac, il compilatore aggiunge alla classe di cui sopra il costruttore di default:

class Punto {
               public Punto() {
                 // non c’è scritto niente
               }

               public int x;
               public int y;
}

  • Quindi quando noi procediamo ad istanziare l’oggetto la chiamata al costruttore di default avviene in un modo del tutto trasparente:

Punto punto1= new Punto() // Dichiarazione ed istanza



26. Osservazione importante sul costruttore di default

  • Bisogna porre l’accento sul fatto che il costruttore di default viene inserito in una classe dal compilatore se e solo se il programmatore non ne ha fornito uno esplicitamente. Nel momento in cui il programmatore fornisce un costruttore ad una classe, sia esso con o senza parametri, il compilatore non inserirà quello di default.

Un costruttore fornito senza nessun parametro ma inserito dal programmatore (anche senza corpo del metodo) NON si chiama costruttore di default


27. Accenno al Package

  • Un package in Java permette di raggruppare in un’unica cartella più classi logicamente correlate. Per eleggere una cartella a package, una classe Java deve dichiarare al suo interno l’appartenenza a quel determinato package, ed inoltre deve risiedere fisicamente all’interno di essa. Giacché il concetto di package non è essenziale per l’apprendimento di Java, lo tratteremo nel dettaglio nelle prossime unità.