Tipi di dati primitivi

A differenza di linguaggi come Smalltalk, Java non è un linguaggio OO puro: infatti comprende dei dati che non sono oggetti.

In Java ci sono otto tipi di dati predefiniti (primitivi):
 

byte interi tra -128 e 127 (8 bit)
short interi tra -32768 e 32767 (16 bit)
int interi tra -2147483648 e 2147483647 (32 bit)
long interi con 64 bit 
float numeri in virgola mobile (32 bit)
double numeri in virgola mobile (64 bit)
char caratteri (standard UNICODE, 16 bit)
boolean  true e false



Dichiarazione di variabili

I nomi di variabili sono identificatori.

Una dichiarazione di variabile può avere una delle seguenti forme:

  • <tipo> <nome>;
  • <tipo> <nome1>,<nome2>,...;
  • <tipo> <nome> = <espressione>;
Esempi:
 
 
 
int  base;
int  k, l, m;
boolean  a = 2 > 1;
boolean  b = false;
char  c = 's';



Costanti


Si può associare a un identificatore un valore che non può essere cambiato nel programma:
 
static final  <tipo> <nome> = <valore>;


Esempi:
 
 
static final double PI = 3.141592;
static final int SPEED_LIMIT = 60;
static final char SEPARATOR = ':';




Costanti numeriche (1)

Le costanti numeriche (literals) si scrivono nella forma usuale:
  • Interi: 3, 74, 563899289, 0x41 (65 in esadecimale), 0xFF (255), ...
  • Numeri in virgola mobile: 3.14, 45, 35.78e2, ...
Attenzione ai tipi!
  • Le costanti intere sono di tipo int
  • Le costanti in virgola mobile sono di tipo double, no float

  • Suggerimento: usare solo int e double



Costanti numeriche (2)

short x = 256; OK
short x = 3565567; Errore: troppo grande
long x = 44444442556; integer number too large: 44444442556
long x = 44444442556l; OK: una "l" (L minuscola) alla fine indica che la costante è long
float y =  3.1; possible loss of precision
found   : double
required: float
float y =  3.1f; OK: "f" indica che la costante è float
float y =  (float) 3.1; OK: l'operatore di cast converte la costante in float



Operatori aritmetici (1)

 -
 negazione
++
incremento
--
decremento
*
moltiplicazione
/
divisione
%
modulo
+
addizione
-
sottrazione

Tutti gli operatori, se applicati a interi, restituiscono un valore int o long, mai byte o short.




Operatori aritmetici (2)


Incremento. Supponiamo che n valga 5:
   n++   // vale 5, però dopo n vale 6
   ++n   // vale 6, e dopo n vale 6

Divisione 
   double n; 
   n = 7.0 / 4.0; // n = 1.75 
   n = 7 / 4.0; // n = 1.75 
   n = 7.0 / 4; // n = 1.75 
   n = 7 / 4;  // n = 1 !!(División entera)

Modulo
   n % d //  equivale  a     n - (n/d)*d

Overflow e underflow

  • Non dipende dalla macchina
  • Alcune conversioni sono automatiche (come da int a long), altre no
  • L'Overflow viene gestito a livello del linguaggio con il meccanismo delle eccezioni



Assegnamento

Sintassi (eredità di C e C++):
<variabile> = <espressione>;
I tipi devono essere compatibili.
 
 
int y;
double x;
y = 3 + 4 * 2;
x = y;  // ok
y = x;  // NO: errore di compilazione

Java è un linguaggio con un controllo stretto dei tipi (strongly typed, fortemente tipato).





Altri operatori di assegnamento

  • Eredità di C e C++
  • Un comando di assegnamento è anche un'espressione: restituisce il valore assegnato
int x = 5;
double y = 3.15;

x += 7;         // x = x + 7
y *= 2.5;       // y = y * 2.5
x -= 7;         // x = x - 7
y /= 4;         // y = y / 4;

x = y *= 3;     // x = (y = y * 3)  associa alla destra

Per incrementare int x:
   x = x + 1
   x += 1
   x++
   ++x
Sono tutti equivalenti?




Altri operatori

 Operatore
Significato
Esempi
>>
shift aritmetico
a livello di bit - destra
int x = 45;
int y = x >> 2; //y = 11
x = -45;
y = x >> 2;  // y = -12
<<
shift - sinistra
>>>
shift logico - destra
x = 45;
y = x >>> 2; //y = 11
x = -45;
y = x >>> 2;  // y = 1073741812
~
negazione logica a livello di bit
~74  //  74 = 0100 1010
     // -75 = 1011 0101
&
AND a livello di bit
|
OR a livello di bit
^
XOR a livello di bit