Ecco qui dopo un po’ di tempo con il continuo della guida sul Java. Come al solito prima di partire ti avverto che per capire al meglio quanto segue ti conviene leggere gli articoli postati qui sotto:
Bene detto questo possiamo procedere.
L’ultima volta, in questo articolo, abbiamo visto diversi concetti pratici riguardanti le variabili.
Oggi finiamo di vedere gli ultimi dettagli semplici e poi ci spostiamo in un nuovo argomento.
ATTENZIONE: non terminiamo l’argomento delle variabili, ma lo mettiamo semplicemente in pausa per vedere un nuovo argomento (facile). Dopodiché riprendiamo con le variabili.
Iniziamo.
Oggi andiamo a vedere 2 piccoli dettagli che però possono semplificare un po’ la scrittura delle variabili che sono necessarie nei programmi che andiamo a creare.
Il primo è piuttosto semplici e riguarda le variabili dello stesso tipo.
Se dobbiamo scrivere una serie di variabile di tipo (ad esempio) int, solitamente facciamo:
[java]
int v1 = 0;
int v2 = 0;
int v3 = 0;
[/java]
ecc…
Potrai ben capire che è un’operazione scomoda e soprattutto perditempo. Ma c’è un sistema per migliorare il tutto.
Ogni volta che si deve scrivere una serie di variabili dello stesso tipo si può specificare una volta sola il tipo e poi scrivere le varie variabili separate dalla virgola.
[java]
int v1 = 0, v2 = 0, v3 = 0;
[/java]
Questo procedimento è molto più veloce e più pratico e si risparmiano righe di codice.
Il secondo concetto che andremo a vedere oggi riguarda sempre la scrittura delle variabili.
Come ho sempre detto, ogni variabile necessita obbligatoriamente di essere inizializzata.
Abbiamo sempre visto questo tipo di inizializzazione:
int v1 = 0;
Dove immettiamo il valore di partenza al momento della dichiarazione della variabile (-> ogni volta che si crea una variabile, prima la si dichiara, ovvero si comunica al compilatore e poi successivamente alla JVM l’esistenza di una variabile con un certo tipo) gli si assegna anche un valore di partenza (chiamato inizializzazione).
Però c’è un’altro sistema per inizializzare una variabile.
[java]
int v1;
// ……….
v1 = 1;
[/java]
Nella prima riga di codice abbiamo soltanto dichiarato una variabile (il compilatore non darà nessun errore per la mancanza di inizializzazione, ma vi comunico che non dare un valore ad una variabile è molto pericoloso perché può causare gravi danni all’intero programma).
Poi dopo una serie di istruzioni (rappresentate con i punti di sospensione) andiamo ad inizializzarla, assegnandole un valore.
Questa tecnica si usa quando non si conosce il valore preciso necessario da assegnare alla variabile e quindi lo si assegna dopo.
Questa tecnica è altamente sconsigliata, perché innanzi tutto il rischio di dimenticarsi di assegnare un valore alla variabile è alto e poi solitamente non ha molto senso. È meglio sempre dare un valore di “default” 0.
Però ve l’ho esposta comunque per porvi alla luce tutte le varie tecniche di scrittura delle variabili.
Bene ora possiamo abbandonare momentaneamente l’argomento delle variabili per intraprendere un nuovo argomento.
Come potrai aver ben notato, in tutti i programmi che vai a creare l’utente non può avere nessun controllo. Ad esempio se faccio calcolare una moltiplicazione l’utente non può inserire i numeri da moltiplicare a programma avviato, ma dovrà essere il programmatore a cambiarli.
In poche parole questi programmi non hanno la ben che minima capacità di interazione.
Questo tipo di programma che stai andando a creare supportano solo dati in ingresso, quindi dati output. (Notiamo che l’oggetto out “System.out” è l’abbreviazione di output).
Ora ti farò vedere come gestire anche dati di tipo imput (dati in ingresso).
Se prima programmavi in C o in C++ usavi uno specifico strumento.
In C si usa lo strumento scanf e in C++ si usa lo strumento cin.
Se per caso non programmavi in C/C++ non c’è nessun problema. Tanto il metodi di Java è totalmente diverso e quindi in ogni modo partiresti da 0.
Una serie di programmatori hanno sviluppato una classe di nome Scanner. Questa classe serve per la gestione dei dati in ingresso (che possono provenire dalla tastiera, da dei file ecc…).
Questa classe è stata progettata così bene che è divenuta uno standard e ormai tutti la usano.
Ora andremo ad imparare due nuove keyword (parole chiave) di Java.
per prima cosa dobbiamo andare a scrivere al di sopra di “public class Esercizio -> Io ho dato questo nome alla classe, voi non lo so”.
Come potrai notare qui sopra ho scritto:
import java.util.Scanner;
import è la prima keyword che andiamo a vedere oggi.
import è il comando importa e si usa per importare una classe.
java è la cartella dov’è contenuta la classe
il punto serve per andare a selezionare ciò che serve all’interno della cartella java
util è una sotto cartella di java
il punto serve per andare a selezionare ciò che serve contenuto nella sotto cartella util
Scanner è la classe che andremo ad usare
Infine si immette il punto e virgola.
Ora ritorniamo nel main. Ora inseriamo nella prima riga del blocco di istruzioni del main questa riga di codice:
[java]
Scanner sc = new Scanner(System.in);
[/java]
Vediamo cosa significa:
Scanner è la classe
sc è l’oggetto. Il nome dell’oggetto possiamo sceglierlo come vogliamo, però si devono rispettare le stesse regole sintattiche delle variabili.
L’oggetto sc appartiene alla classe Scanner. È come se Scanner fosse il tuo nome e sc fosse il nome della tua auto. Quindi sc ti appartiene. È la stessa cosa.
In queste due parole, abbiamo dichiarato l’esistenza di questo oggetto.
= Ora andiamo ad assegnare un valore o un parametro all’oggetto sc con il simbolo uguale.
new : Questa è la seconda keyword che andiamo ad imparare oggi. Questa parola chiave ha uno scopo ben preciso, assegnare lo spazio all’oggetto.
La Virtual Machine di Java quando viene avviata, gli viene assegnato una parte dello spazio di memoria RAM. La JVM lo suddivide in due parti:
Lo Stak
L’Heap
Lo stak è uno spazio di memoria che serve essenzialmente per passare i vari parametri e i vari valori alle rispettive variabili, ai rispettivi oggetti ecc….
L’Heap è il secondo spazio di memoria che serve per allocare gli oggetti appena creati. Gli oggetti allocati sono oggetti a cui gli è già stato assegnato uno spazio (con la keyword new) e gli è stato assegnato anche un parametro, valore o un gruppo di funzionalità.
Con l’uso del new, l’oggetto e il suo valore vengono memorizzate nell’heap.
Naturalmente più avanti vedremo meglio nel dettaglio questi due tipi di spazi di memoria e tutte le loro funzioni.
L’oggetto che abbiamo dichiarato verrà memorizzato all’interno dell’heap.
Il new come dicevamo assegna semplicemente uno spazio per l’oggetto. Questo spazio praticamente è vuoto, non contiene nulla.
È come se comprassi un terreno e non ci costruissi nulla. Il terreno c’è, ma il contenuto no.
Ecco che andiamo a richiamare Scanner
Scanner in questo caso è il metodo costruttore. Capiamo che è un metodo dalle parentesi tonde che susseguono il metodo.
Con la chiamata del costruttore riempiamo lo spazio vuoto assegnato all’oggetto.
System.in è il parametro inserito tra le parentesi tonde. System.out si occupa della gestione dei file in uscita (output), mentre System.in si occupa dei dati in ingresso (input).
Scritto tutto ciò ci mettiamo il punto e virgola.
Bene fatto questo vediamo come gestire i dati in ingresso.
Creiamo una variabile di tipo int
int a = 0;
Al posto di inizializzarla a 0 scriviamo questo:
int a = sc.nextInt();
Vediamo cos’ho fatto.
int a ho dichiarato una variabile int con l’identificatore a
= assegno un valore alla variabile
sc è il nome dell’oggetto (io ho dato il nome sc, tu puoi dare il nome che vuoi).
. Il punto serve per accedere ai metodi della classe Scanner.
L’oggetto ha la funzione di essere una sorta di tramite. Fa da tramite per consentire di utilizzare i metodi che sono contenuti all’interno della sua classe di appartenenza.
Dopo il punto Eclipse ci consiglierà il metodo più opportuno e noi non dobbiamo far altro che farci doppio clic o premere invio per accettare il suggerimento (i suggerimenti servono per far risparmiare tempo al programmatore e per fargli evitare di dover scrivere sempre le stesse cose).
Ogni tipo di variabile ha il suo metodo specifico per la gestione dell’input.
Vediamo il tutto in questa tabella:
| Int | nextInt(); |
| float | nextFloat(); |
| double | nextDouble(); |
| long | nextLong(); |
| short | nextShort(); |
| byte | nextByte(); |
| char | nextLine(); * |
| String | nextLine(); |
* Nel caso dei char esiste lo stesso metodo delle variabili String. Il problema è che le String riescono a gestire anche intere frasi e invece i char riescono a memorizzare 1 solo carattere.
Quindi sarebbe opportuno imporre dei controlli all’utente (vedremo più avanti come fare) oppure per sicurezza optare nell’utilizzo di variabili String per evitare che il programma vada in crash.
Bene con questo ci vedremo al prossimo articolo in cui andremo avanti e riprenderemo le variabili 🙂
