Ciao a tutti e rieccoci in questo nuovo articolo, in cui continuerò la serie sul Java.
Ti invito se per caso sei un nuovo utente o se leggi per la prima volta questa guida, di riandare a leggere le guide precedenti, per poter capire al meglio quanto sarà scritto in seguito.
- Clicca qui per andare a vedere la prima sessione del corso
- Clicca qui per andare a vedere la seconda sessione del corso
Nello scorso articolo avevamo visto varie operazioni di stampa che si possono fare con il metodo print o println.
Oggi andiamo avanti a vedere il calcolo delle espressioni aritmetiche.
Per fare il calcolo di espressioni matematiche, sia aritmetiche, che di altro tipo, bisogna sapere due concetti base:
innanzi tutto le parentesi sono sempre tonde. Non si deve scrivere un’espressione con le parentesi quadre e graffe. È un errore molto grave, dato che in Java e in moltissimi altri linguaggi, questi due tipi di parentesi hanno un significato ben diverso dal calcolare delle espressioni. Lo abbiamo già visto, con la rappresentazione di un blocco di istruzioni con le parentesi graffe e dell’aggiunta di funzionalità avanzate con le parentesi quadre (ad esempio String[]).
Vediamo un esempio di espressione che possiamo calcolare stampandone il risultato:
System.out.println( ( 2 * 5 + ( 44 + 3 * ( 22 – 5) ))* 2 );
Qui ho scritto un’espressione matematica piuttosto semplice. Se andassi ad eseguire il programma, in risultato sarebbe:
210
Il risultato è corretto. Se non ci credi, puoi benissimo calcolarlo a mano e confrontare il risultato.
Ma se io volessi concatenare un’espressione ad un’altra?
Beh semplicemente faccio così:
[java]
System.out.println( ( 2 * 5 + ( 44 + 3 * ( 22 – 5 ) ) )* 2 +
"-" + 22 * 3 );
[/java]
ATTENZIONE: durante la battitura del codice, è possibile andare a capo, ad esempio come ho fatto qui in alto, appena ora. Il compilatore comprende comunque.
Direi che per questo punto siamo a posto così.
Ora però vorrei andare avanti un altro po’.
In tutti i mini programmi che abbiamo fatto fino ad ora hanno una mancanza piuttosto grave che li rende praticamente inutili.
Il risultato di queste espressioni e comunque di questi calcoli, non viene salvato in nessun modo. Quindi vuol dire che non è possibile riutilizzare il valore risultato per fare altri calcoli, non è possibile memorizzare valori per farne delle statistiche o delle altre cose del genere.
Ci serve quindi un qualcosa per memorizzarle. Ma cosa possiamo usare?
Ed ecco qui che entriamo in un altro argomento.
Esiste uno strumento in quasi tutti i linguaggi di programmazione (anzi in tutti a dir la verità) chiamati variabili.
Le variabili possiamo definirle come degli spazi di memoria RAM generati per poter memorizzare dei valori, che siano numeri interi, decimali, lettere o anche del testo.
Andiamo a vedere per prima cosa i tipi di variabili in grado di memorizzare numeri interi, senza virgola.
Ogni variabile ha un suo spazio di memorizzazione, ovvero che più di un tot di grandezza non può memorizzare. Per questo ci sono vari tipi di variabili, alcuni più piccoli e altri con uno spazio di memoria più grande, da scegliere a seconda del valore che si necessita memorizzare.
Andiamo in ordine crescente.
Per primo vediamo il byte. Il byte è il tipo di variabile intero più piccolo. Può arrivare a memorizzare un numero negativo non inferiore a -128 e un numero positivo non superiore a 127.
Notiamo che il valore positivo è un valore più piccolo di quello negativo. Questo perché in informatica si inizia a contare per i positivi da 0 e per i negativi da -1.
La variabile leggermente più grande del byte, ovvero lo short.
Lo short può memorizzare un numero negativo non superiore a -32768 e un numero positivo non superiore a 32767.
La variabile che troviamo dopo lo short è l’int. La variabile int è un tipo di variabile di grandezza intermedia tra short e long (vedremo tra poco questo tipo di variabile).
La variabile int è solitamente la più gettonata, anche perché è una via di mezzo tra una variabile che può immagazzinare valori veramente molto piccoli e una variabile che può gestire valori giganteschi, che superano i miliardi.
Questo tipo di variabile può contenere al massimo un numero negativo non superiore a -2147483648 e un numero positivo non più grande di 2147483647.
Come accennato prima, andiamo a vedere l’ultima variabile dei numeri interi, quella più grossa, che è il long.
Il numero negativo più grande che si possa memorizzare è -9223372036854775805 e il numero positivo più grande è il 9223372036854775804.
ATTENZIONE: Se provi ad inserire un numero così grande in questa variabile, il compilatore darà errore. Questo è tutta una questione di sicurezza, una sicurezza che apporta il compilatore quando si va a lavorare con valori molto grandi.
Per risolvere questo problema bisogna ricorrere a un casting, tradotto in italiano una forzatura.
Per compiere questa forzatura è necessario inserire la lettera elle “l”, maiuscola o minuscola non ha importanza, alla fine del numero. Vediamo come:
[java]
long numero_grande = 9223372036854775804l;
[/java]
Intanto che ci siamo, è possibile vedere come si scrive una variabile.
Innanzi tutto bisogna scrivere il tipo di variabile, che in questo caso è il long, ma può essere anche un int, uno short o quello che si vuole.
Poi va messo il nome della variabile, che si chiama identificatore. Questo nome servirà per poter richiamare il valore memorizzato all’interno della variabile e poi anche per permettere al compilatore e alla JVM di riconoscere questa variabile da altre.
“=”: l’uguale ha uno scopo ben preciso. L’uguale non vuol dire che una cosa è uguale a un’altra, ma ha un’altro significato. Ovvero che io assegno alla variabile che sta a sinistra il valore che sta a destra.
Se io invertissi le parti e quindi scrivessi così:
[java]
4034055040440 = numero_grande long;
// SBAGLIATO!
[/java]
È una cosa completamente sbagliata.
L’uguale funziona che assegna, da come valore qualsiasi cosa che sta a destra dell’uguale stesso a un’altra cosa, in questo caso una variabile, che sta a sinistra dell’uguale stesso.
Ritorniamo all’identificatore della variabile.
Questo ha delle regole sintattiche ben precise. Innanzi tutto non può avere spazi, non può avere simboli di punteggiatura, non può avere caratteri speciali. Può contenere soltanto numeri, lettere e l’underscore, ovvero il trattino in basso “_”.
Java è un tipo di linguaggio case sensitive, ovvero sensibile alle maiuscole. Se si scrive una variabile con un nome maiuscolo e poi l’andiamo a richiamare con il nome minuscolo, il compilatore non riconoscerà che si sta andando a richiamare una determinata variabile.
int ciao = 0;
CIAO.
Sono due variabili completamente diverse. ciao è una variabile e CIAO è un’altra variabile ancora.
Andiamo avanti. Dopo l’uguale ci sta il valore da assegnare alla variabile.
ATTENZIONE: è obbligatorio assegnare a ogni variabile che si crea almeno un valore di partenza. Ad esempio:
[java]
int ciao = 0;
[/java]
Se non si da un valore:
[java]
int ciao;
[/java]
Il compilatore darà errore. Non dare un valore di partenza a una variabile potrebbe comportare dei seri rischi al programma, se il compilatore non dovesse segnalare nulla.
Dopo aver scritto la variabile, si mette il punto e virgola per terminare l’istruzione e passare alla prossima.
Bene. Con le variabili di tipo intero abbiamo finito, ora passiamo a quelle di tipo decimale.
Ora andiamo a vedere le variabili di tipo decimale.
Come per le variabili di tipo intero, le andremo a vedere in ordine crescente.
Al primo posto troviamo le variabili di tipo float.
Questo tipo di variabile non è molto preciso, ovvero che calcola riesce a contenere un numero limitato di valori dopo la virgola.
Questo è un bene per risparmiare della memoria RAM, ma è un male se si devono effettuare dei calcoli che forniscano dei risultati precisi.
Nelle variabili float è possibile anche inserire dei valori interi, anche se a questo punto il mio consiglio è di usare variabili di tipo intero (adesso non si fa molto caso alla differenza tra le varie variabili, ma quando si andranno a creare dei programmi complicati, se si scelgono variabili di tipo sbagliato, il rischio di poter compromettere il funzionamento corretto del programma è molto alto).
[java]
float numero_intero = 34;
[/java]
Nelle variabili float in teoria non si potrebbero inserire valori come 3.14. Questo perché il Java non accetta alcuni valori di float. Per risolvere questo problema, bisogna effettuare un casting.
Bisogna inserire la lettera effe “f” subito dopo il valore numerico:
[java]
float numero_decimale = 3.14f;
[/java]
E il problema è risolto.
Ora andiamo a vedere le variabili double.
Questo tipo di variabile è molto preciso. Fornisce molti più numeri dopo la virgola rispetto al float ed è quindi più indicata per avere risultati molto più precisi.
Tutta questa precisione comporta però un grande consumo in più della memoria RAM (finché si fanno programmi così semplici, una variabile vale l’altra. Ma quando si ha a che fare con dei programmi molto complessi, allora si deve cercare di risparmiare fino all’ultimo byte possibile della RAM per ottenere programmi veloci ed efficienti).
Nella variabile double è possibile scrivere praticamente qualsiasi tipo di numero decimale senza dover apportare in alcun modo dei casting.
Se si prova invece ad inserire dei numeri interi molto grandi nella variabile double, il compilatore darà errore. Per ovviare a questo problema bisogna effettuare un casting.
Bisogna inserire la lettera “d”, subito dopo il valore numerico:
[java]
double numero_intero = 3949449494494d;
[/java]
E il problema è risolto.
Vediamo ora la differenza di precisione tra una variabile float e una double.
Per farlo scriviamo questo esempio:
float prova1 = 4.4404055030333033056607770f;
double prova2 = 4.4404055030333033056607770;
System.out.println(prova1 + “-” + prova2);
Il programma stamperà:
4.4404054-4.440405503033303
Vediamo una piccola cosa di sintassi all’interno dell’istruzione di stampa.
Per far stampare il valore di una variabile all’interno dell’istruzione di stampa è sufficiente scrivere il nome della variabile senza virgolette, come se fosse un normale numero.
Possiamo notare che float è molto meno preciso rispetto al double.
Bene. Ora abbiamo finito con le variabili decimali.
Vediamo le variabili che memorizzano caratteri o intere parole o frasi.
Partiamo dalla prima.
La variabile in grado di memorizzare dei caratteri è il char. Questo tipo di variabile è in grado di memorizzare un solo carattere alla volta, che può essere una lettera, un numero o anche un simbolo di punteggiatura. Anche lo spazio è definito come carattere.
Un carattere si scrive tra due apici (un apice è l’apostrofo):
[java]
char carattere = ‘c’;
// Proviamo a stampare questo carattere:
System.out.println(carattere);
[/java]
E il programma stamperà:
c
Bene. Ora andiamo a vedere l’ultimo tipo di variabile di oggi, che non è propriamente una variabile, ma una classe. Si chiama String.
Questa variabile è in grado di memorizzare caratteri, parole, frasi.
Il testo da memorizzare all’interno della variabile String, va inserito tra 2 virgolette:
[java]</pre>
String frase = "ciao come stai?";
// Stampiamo questa frase:
System.out.println(frase);
[/java]
Il programma stamperà:
ciao come stai?
Oggi abbiamo visto moltissimi tipi di variabili. Qualcosa potrebbe esserti sfuggito. Se così fosse, non esitare a scrivere nei commenti il tuo problema o se preferisci nella pagina di assistenza a questo indirizzo.
Con questo noi ci salutiamo e ci rivediamo al prossimo capitolo della guida sul Java o ad un altro articolo 🙂
