Si ringrazia Claudio De Sio per la concessione del materiale pubblicato in questo articolo.

Operatori e flusso di controllo

Obiettivi:

Il Lettore al termine di questo capitolo dovrà essere in grado di

1. Conoscere e saper utilizzare i vari operatori (unità 4.1).
2. Conoscere e saper utilizzare i costrutti di programmazione semplici (unità 4.2, 4.3).
3. Conoscere e saper utilizzare i costrutti di programmazione avanzati (unità 4.2, 4.4).

- Operatore d’assegnazione:     =

                somma                       +

                sottrazione             -

                moltiplicazione       *

                divisione                    /

                somma e assegnazione                              +=

                sottrazione e assegnazione            -=

                moltiplicazione e assegnazione         *=

                divisione e assegnazione             /=

                modulo e assegnazione                                 %=

                incremento di un’unità                         ++ (pre e post)

                decremento di un’unità             -- (pre e post)

    i=i+1;

ottenendo comunque lo stesso risultato. Infatti, in tutti i casi, otterremo che il valore della variabile i, è stato incrementato di un’unità, ed assegnato nuovamente alla variabile stessa. Quindi anche questi operatori svolgono due compiti (incremento ed assegnazione). Parleremo di operatore di pre-incremento nel caso in cui anteponiamo l’operatore d’incremento ++ alla variabile. Parleremo invece, di operatore di post-incremento nel caso in cui posponiamo l’operatore di incremento alla variabile. La differenza tra questi due operatori "composti", consiste essenzialmente nelle priorità che essi hanno rispetto all’operatore di assegnazione. L’operatore di pre-incremento, ha maggiore priorità dell’operatore di assegnazione =. L’operatore di post-incremento, ha minor priorità rispetto all’operatore di assegnazione =.

pre-incremento

    y = ++x; si ha x=6 e y=6

post-incremento

    y = x++; si ha x=6 e y=5

                NOT                                                                           ~

                AND                                                                         &

                OR                                                                                |

                XOR                                                                             ^

                shift a sinistra                                        <<

                shift a destra                                                                 >>

                shift a destra senza segno                                                     >>>

                AND e assegnazione                                                         &=

                OR e assegnazione                                                           |=

                XOR e assegnazione                                                         ^=

                shift a sinistra e assegnazione                                          <<=

                shift a destra e assegnazione                                            >>=

Tutti questi operatori binari, sono molto efficienti giacché agiscono direttamente sui bit, ma in Java si utilizzano raramente. L’operatore NOT ~ è un cosiddetto operatore unario, dato che si applica ad un solo operando.

Gli operatori AND &, OR |, e XOR ^, si applicano a coppie di operandi, e svolgono le relative operazioni logiche di conversioni di bit riassunte nelle seguente tabella:

Gli operatori di shift, provocano lo scorrimento verso una direzione, dei bit della rappresentazione binaria di un certo numero. Il numero dei bit da scorrere è rappresentato dall’operando a destra dell’operazione. I bit che dopo lo scorrimento si trovano al di fuori della rappresentazione binaria del numero, vengono eliminati. I bit che invece "rimangono vuoti" vengono riempiti con i valori 0 oppure 1 a seconda del caso. In particolare, lo scorrimento a sinistra provoca un riempimento con i valori 0, per i bit lasciati vuoti sulla destra della rappresentazione binaria del numero. Anche lo scorrimento a destra senza segno riempie i bit lasciati vuoti con degli 0. Lo scorrimento a destra con segno invece, provoca il riempimento di 0 oppure di 1, a seconda che l’ultima cifra a sinistra prima dello scorrimento (bit del segno) sia 0 oppure 1, ovvero che la cifra prima dello scorrimento sia positiva o negativa. Consideriamo i seguenti esempi:

    byte a=35; byte b=-8;

rappresentazioni binarie

Possiamo notare che l’operazione di scorrimento a sinistra equivale, a dividere l’operando di sinistra, per 2 elevato l’operando situato alla destra dell’operazione. Similmente, l’operazione di scorrimento a destra equivale a moltiplicare l’operando di sinistra per 2 elevato l’operando situato sulla destra dell’operazione. Il risultato viene arrotondato per difetto nelle operazioni con resto.

Il risultato di queste operazioni è sempre un valore boolean, ovvero true o false.

        uguale a                                     ==                                tutti i tipi

        diverso da                                     !=                                 tutti i tipi

        maggiore                                        >                                  solo i tipi numerici

        minore                                       <                                  solo i tipi numerici

        maggiore o uguale                         >=                                solo i tipi numerici

        minore o uguale                         <=                               solo i tipi numerici

 Notiamo che se confrontiamo due reference con l’operatore ==, il risultato risulterà true se e solo se i due reference puntano allo stesso oggetto, false altrimenti. Un classico errore che l’aspirante programmatore commette spesso, è quello di scrivere = in luogo di ==.

I seguenti sono operatori che utilizzano solo operandi di tipo booleano, ed il risultato è di tipo boolean:

        NOT logico                                 !

        AND logico                             &

        OR logico                                |

        XOR logico                             ^

        short circuit AND                    &&

        short circuit OR                       ||

        AND e assegnazione                &=

        OR e assegnazione                   |=

        XOR e assegnazione                     ^=

E’ consuetudine utilizzare le versioni short circuit di AND ed OR. Ad esempio, la seguente riga di codice, mostra come avvantaggiarsi della valutazione logica di corto circuito per essere certi che il risultato di una operazione di divisione sia valido prima di valutarlo:

    boolean flag = (a!=0 && b/a>10)

Affinché l’espressione tra parentesi sia vera, bisogna che entrambi gli operandi siano veri. Se il primo tra loro è in partenza falso, non ha senso andare a controllare la situazione dell’altro operando. In questo caso addirittura sarebbe dannoso essendoci il rischio di una divisione per zero. Quest'operatore short – circuit, a differenza della sua versione tradizionale, fa evitare il secondo controllo in caso di fallimento del primo. Equivalentemente l'operatore short - circuit ||, nel caso la prima espressione da testare risultasse verificata, convalida l'intera espressione, senza nessun'altra (superflua) verifica.

farà in modo che la stringa nomeCompleto, avrà come valore "Mr. James Gosling".