Tipi di dato e

controllo del flusso

Dott. Ing. Leonardo RigutiniDipartimento Ingegneria dell’InformazioneUniversità di SienaVia Roma 56 – 53100 – SIENAUff. 0577233606rigutini@dii.unisi.itwww.dii.unisi.it/~rigutini/

Tipi di dato

Tipi di dato semplici (primitivi)

Il JAVA fornisce tutti i tipi di dato semplici. Per ognuno di essi inoltre la Sun ha sviluppato una “versione” ad oggetti: i wrapper

Per i tipi di dato primitivi il JAVA non utilizza la memorizzazione per riferimento, bensì per valore: Questo significa che tutte le operazioni di assegnamento, passaggio

di parametri ecc… creano una variabile distinta

Tipi di dato semplici

Tipo Dimensione Min Max Wrapper

boolean 1 bit - - Boolean

char 16 bit 0 216-1 Charbyte 8 bit -128 +127 Byteshort 16 bit -215 +215-1 Short

int 32 bit -231 +231-1 Integerlong 64 bit -263 +263-1 Longfloat 32 bit IEEE 754 Floatdouble 64 bit IEEE 754 Double

void - - - Void

Tipi di dato numerici

Quando utilizziamo un tipo di dato semplice numerico è importante ricordarsi del range limitato di numeri rappresentabile in hardware

Piccoli errori di arrotondamento possono portare ad un risultato scorretto anche di quantità significative a seguito di numerose operazioni aritmetiche

Il caso più eclatante fu l’errore scoperto sul processore Pentium nel 1994 pochi mesi dopo la sua uscita

Operatori

Assegnamento

L’assegnamento permette di definire il valore memorizzato in una variabile: il valore assegnato deve essere compatibile col tipo della variabile,

altrimenti si genera un errore

int a, b;float v1, v2;char c = ‘M’;

a = 4; b = a; v1 = 3.2 v2 = a;

b = v1;

b assume il valore di a (cioè 4)

ammesso: v2 assume il valore di a (4) convertito in float

variabile espressione

non ammesso

Cast

cast (forzatura) indica l’operazione di forzare la trasformazione di un tipo di dato ad un altro: La sintassi consiste nell’inserire il nome_tipo tra parentesi, prima della

variabile o della espressione che vuole essere castata int a=(int) (3,14*4); a contiene 12 invece che 12.56 !!! double A=3,14; int f=(int) A; f contiene il valore 3 !!!

Il cast può essere esplicito o implicito: cast esplicito - l’utente specifica il tipo di dato finale in cui desidera

lavorare (tra parentesi tonde) cast implicito - il compilatore automaticamente decide il tipo di dato finale

in base al tipo di dato della variabile in cui il valore va ad essere memorizzato. Le conversioni ammesse implicitamente sono:

byte short int long float double

Operatori

Operatori unari: permettono di effettuare operazioni di inversione di segno e autoincremento

positivo +, negativo – pre-incremento ++a, pre-decremento --a post-incremento a++, post-decremento a--

class Prova { public static void main(String[] args) { int A = 10; System.out.println(A); // Stampa 10 System.out.println(A++); // Stampa 10 System.out.println(++A); // Stampa 12 }}

Operatori

Operatori aritmetici: moltiplicazione *, divisione / modulo % addizione +, sottrazione –

Operatori relazionali: permettono di costruire espressioni logiche uguale == , diverso != maggiore > , maggiore e uguale >= minore < , minore e uguale <=

(c != 23) è true se c è diverso da 23(b == ‘s’) è true se b è il carattere ‘s’

Operatori

Operatori booleani

Permettono di costruire espressioni logiche: And && Or || Not !

Non vengono mai valutate tutte i termini della condizione, ma solo fino a quando il risultato è univocamente determinato:

v1 && v2 && v3 && v4 v4 non viene valutata

( !((c == 23) || (c ==24)) ) c non è uguale a 23 nè a 24( (b == ‘s’) || (b ==‘S’) ) è true se b è il carattere ‘s’ o ‘S’( !((a >= 0) && (a < 0.5)) ) è false se a è compreso tra 0 (compreso) e

0.5 (escluso)

T T F T

Operatori

Operatori bit-a-bit And & Or | Xor ^ Not ~

class ProvaXor { public static void main(String[] args) { boolean A = 0x80; // (1000 0000)2

boolean B = 0xAB; // (1010 1011)2

System.out.println(A ^ B); // Stampa 0x2B (0010 1011)2

}}

Operatori

Operatori di shiftPermettono di traslare a destra o a sinistra sequenze di bit:

shift a destra >> shift a sinistra <<

1001001011101101 >> 2 00100100101110111001001011101101 << 3 0010010111011000

Varianti di operatori

Per quasi tutti gli operatori è possibile sostituire una espressione del tipo

variabile = variabile <operatore> valore

con una forma abbreviata:

variabile <_varoperatore>= valore

double A = 0.0D;

// Invece di scrivere A = A + 2D// abbiamo scritto A += 2.0DSystem.out.println(A += 2.0D); // Stampa 2.0

System.out.println(A /= 2.0D); // Stampa 1.0

Confronto di oggetti

Quando utilizziamo l’operatore == per confrontare due oggetti, in realtà confrontiamo l’indirizzo memorizzato nelle due variabili: Tale confronto quindi ritorna true nel caso che entrambe le variabili

si riferiscano allo stesso oggetto

Quindi in questo caso l’uguaglianza non si riferisce al contenuto della variabile ma controlla se le due variabili indicano lo stesso oggetto

Normalmente ogni oggetto mette a disposizione un metodo per controllare l’uguaglianza tra due oggetti: String.equals() ecc…

Confronto di oggetti

Solamente per i tipi di dato primitivi il confronto si comporta effettivamente come un operatore matematico di uguaglianza: Es. due variabili intere diverse che contengono lo stesso valore

sono considerate uguali

Un riferimento ad oggetto può avere valore null

Tale valore può essere utilizzato per verificare su un oggetto è stato inizializzato tramite confronto:

Rectangle R;

if (R==null) … // l’oggetto R non è stato inizializzato

Array

Array Un array è un handle ad un vettore (o una matrice) di elementi che

possono essere di tipo primitivo oppure oggetti:

Se vogliamo allocare memoria:

int[] A1;int A2[];

int[] B = {1, 2, 3, 4, 5, 6};

in entrambi i casi viene generato un handle adun vettore

in questo caso viene ancheallocata la zona di memorianecessaria a contenere glielementi indicati

int[] A1;int A2[];int[] B = {1, 2, 3, 4, 5, 6};

A1 = new int[6];A2 = A1;

A1.length indica quantielementi sono stati allocati

Array di oggetti È anche possibile creare un array di oggetti, cioè un vettore di

handle tutti inizializzati a null

E anche possibile inizializzare direttamente un vettore di oggetti:

ma è poco utile

Segmento[] Spezzata;Spezzata = new Segmento[6];

for ( int i = 0; i < Spezzata.length; i++) { Spezzata[i] = new Segmento();}

NULL

NULL

NULL

NULL

NULL

NULL

3:

4:

5:

2:

1:

0:

Segmento[] Spezzata = { new Segmento();new Segmento();new Segmento();

};

Array multidimensionali Il JAVA non pone limiti al numero di dimensioni degli array

int[][] A = { {1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10} };

int[][] B = new int[5][2];

￪￪

￪109876

54321

A[0][3]

A[i].length

A.length

int[][][] A = new [2][2][3];

for (int x = 0; x < A.length; x++) for (int y = 0; y < A[x].length; y++) for (int z = 0; z < A[x][y].length; z++) A[x][y][z] = 1;

Controllo del flusso

if … else …

cond

blocco 1 blocco 2

false

true

if (boolean-cond) { blocco 1}else { blocco 2}

if (vendite > media) { bonus = 0.1; guadagno = quota * bonus;}else { guadagno = 0;}

Operatore ?

Il costrutto if … else … può essere condensato in una istruzione singola utilizzando l’operatore ?

condizione ? valore1 : valore2

y = x>=0 ? x : -x ;

if (x >=0) y=x;else y=-x;

y = if (x>=0) x; else -x;

errore

if … else if … else …

cond1

blocco 1

blocco 3

false

true

cond2

blocco 2

true

false

if (cond1) { blocco 1}else { if (cond2) { blocco 2; } else { blocco3; }}

if (cond1) { blocco 1}else if (cond2) { blocco 2;}else { blocco3;}

switch … case …

char C = ‘n’;switch (C) { case ‘n’: System.out.println(“Sconto”); break; case ‘s’: System.out.println(“Sconto no”); break; default: System.out.println(“Boh!”);}

switch (variabile) { case Valore1: blocco1 break; case Valore2: { blocco2;

break; } default: blocco default;}

while ()

cond

blocco

false

true

while (boolean-cond) { blocco}

while (true) { System.out.println(“Infinito”);}

Ciclo infinito:

do … while()

La condizione viene valutata dopo aver eseguito il blocco almeno una volta

do { blocco} while (boolean-cond)

cond

blocco

false

true

Cicli determinati: for

Ciclo di 5 iterazioni:

Ciclo infinito:

cond

blocco

false

true

inizializzazione

incremento

for (inizializzazione; boolean-cond; incremento) { blocco}

for (int i = 0; i < 5; i++) { System.out.println(i);}

for (;;) { System.out.println(“Infinito”);}

for multivariabile

È possibile specificare nel ciclo for condizioni per più variabili.

L’esecuzione dei due cicli avviene eseguendo prima il più interno e poi avanzando quello superiore:

for (int i = 0, j = 5; i < 5; i++, j--) { System.out.println(i); System.out.println(j);}

break e continue

Queste istruzioni modificano l’esecuzione del ciclo: break interrompe l’attuale istruzione di iterazione while, do while, for ...

ed esce definitivamente dalla iterazione continue interrompe la corrente iterazione e ritorna all’inizio del ciclo,

iniziandone un’altra

for (int i = 0, j = 10; i < 15; i++, j--) { System.out.println(i); if (i % 2 == 0) continue; if (j < 0) break; System.out.println(j);}