*********************************************************************************
Appunti di JAVA
License: GPL
Author: Marco Segato <segatom(at)yahoo(dot)it> aka Mach <tumin17(at)yahoo(dot)it>
Website: http://www.marcosegato.tk/
irc: irc.azzurra.org ---> #lonelzero
*********************************************************************************
*********************************************************************************
Capitolo 1. Appunti di JAVA - "Tipi di dati e variabili"
*********************************************************************************
------------------------
1.1 \ TIPI PREDEFINITI
------------------------
In JAVA esistono dei tipi predefiniti di dati, ma teoricamente, essendo un
linguaggio ad oggetti, sarebbe possibile crearsene infiniti semplicemente
definendone di nuovi. Di seguito una lista dei tipi predefiniti con tipo,
dimensioni e intervallo di validita':
- VALORI NUMERICI INTERI:
| byte | 8 bit | da -128 a +127
| short | 16 bit | da -32768 a +32767
| int | 32 bit | da -2147483648 a +2147483647
| long | 64 bit | da -9223372036854775808 a +9223372036854775807
- VALORI NUMERICI A VIRGOLA MOBILE:
| float | 32 bit | 7 cifre dopo la virgola
| double | 64 bit | 16 cifre dopo la virgola
- CARATTERI:
| char | 16 bit | da -32768 a +32767
Per la rappresentazione dei caratteri, JAVA fa riferimento alla codifica
Unicode per mantenere le proprie caratteristiche di portabilita' sui vari
sistemi operativi; nella dichiarazione, il carattere deve essere racchiuso
tra una coppia di apici singoli:
char c = 'a';
Esistono dei caratteri che non sono visibili nella formattazione di un testo,
ma sono necessari quando si tratta di andare a gestire delle stringhe quando
si fa della programmazione:
' diventa \'
" diventa \"
\ diventa \\
"Ritorno a capo" diventa \r
"Nuova riga" diventa \n
"Avanzamento modulo" diventa \f
"Tabulazione" diventa \t
"Backspace" diventa \b
- VALORI BOOLEANI:
Quando e' necessario assegnare a degli oggetti o a delle variabili una
condizione di verita', si ricorre all'uso dei booleani, che possono assumere
solamente due valori: vero o falso; in JAVA si usano cosi':
boolean a = true;
boolean b = false;
-------------------
1.2 \ LE STRINGHE
-------------------
Quando andiamo a gestire della stringhe in JAVA, ci imbattiamo concretamente
nella caratteristica principale di questo linguaggio: gli oggetti; le stringhe
sono appunto degli oggetti di una classe a cui possiamo applicare dei metodi per
modificarne lo stato. Nella dichiarazione, definiamo una stringa come una
sequenza di caratteri racchiusa tra una coppia di apici doppi:
String nome = "Mach";
E' importante ricordare che le spaziature all'interno delle stringhe assumono
un valore letterale, e che per indicare la posizione dei caratteri che
compongono una stringa si parte da 0; quindi:
+===========+===+===+===+===+===+===+===+===+===+===+===+
| STRINGA | M | a | c | h | | r | u | l | e | z | ! |
+===========+===+===+===+===+===+===+===+===+===+===+===+
| POSIZIONE | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10|
+===========+===+===+===+===+===+===+===+===+===+===+===+
Tutto cio' e' assai importante perche', quando successivamente si vedranno i
metodi da applicare alle stringhe, otterremo che la stringa "Mach rulez!" sara'
lunga 11 caratteri, e la sua sottostringa (2,7) sara' "ch rule".
--------------------
1.3 \ LE VARIABILI
--------------------
Quando manipoliamo dei dati, abbiamo bisogno di uno strumento che ci permetta
di memorizzarli per poi gestirli o modificarli; questo strumento e' la
variabile, che in JAVA si inizializza secondo questo schema generale:
<tipo> <nome_variabile> < = inizializzazione>;
Ad esempio:
int tumin = 17; // assegnamo il valore 17 alla variabile tumin
Dichiarazione e inizializzazione possono avvenire anche in tempi diversi, a
patto pero' che la prima preceda sempre la seconda:
int tumin; // dichiarazione
... [blocco di istruzioni] ...
tumin = 17; // inizializzazione
E' possibile infine dichiarare e/o inizializzare contemporaneamente piu'
variabili dello stesso tipo:
int a, b, c;
int a, b, c = 8;
int a = 32, b, c = 34;
-------------------
1.4 \ LE COSTANTI
-------------------
Nel corso di un programma potremmo avere bisogno di una costante, di una
variabile cioe' che mantenga durante tutta l'esecuzione lo stesso valore; in
JAVA la si inizializza anteponendo la parola "final" alla dichiarazione della
variabile:
final int NOME_COSTANTE = 23;
Solitamente, per distinguerle facilmente, e' buona norma scrivere le costanti
tutte in maiuscolo.
---------------------------------------
1.5 \ CONVERSIONI IMPLICITE E CASTING
---------------------------------------
Nel corso del programma potremmo avere la necessita' di convertire un dato di
un certo tipo in un altro; in determinati casi tutto cio' puo' avvenire in modo
del tutto automatico: se osserviamo la tabella del capitolo 1.1 dei tipi
numerici interi, ci accorgiamo che il tipo "int" e' compreso nell'intervallo del
tipo "long", quindi se noi andremo a convertire un "int" in "long" non avremo
alcun problema. Ad esempio:
int num1 = 77;
long num2 = num1; // ora anche la variabile num2 vale 77
Otteniamo un errore invece quando tentiamo di convertire implicitamente un
"int" in "byte":
int num3 = 345;
byte num4 = num3; // ERRORE! il numero 345 non appartiene al tipo byte
Come fare allora in questi casi? Ricorriamo al cosiddetto "casting" o
conversione esplicita che, a discapito di una possibile perdita di precisione,
ci permette di convertire un tipo in un altro:
(nuovo_tipo)valore;
Ad esempio:
double num5 = 7.87;
int num6 = (int)num5; // num6 vale 7, cioe' la parte intera di 7.87
Proprio quest'ultimo caso ci da uno spunto: come faccio allora ad arrotondare
un numero decimale? Devo utilizzare il metodo "round" della classe "Math", il
cui risultato e' un numero intero di tipo long:
double num7 = 7.87;
long num8 = Math.round(num7); // num8 vale 8
int num9 = (int)Math.round(num7); // num9 vale 8 ma l'ho trasformato in int