Java fornisce un ricco set di operatori per la manipolazione delle variabili. Tutti gli operatori Java possono essere suddivisi nei seguenti gruppi:
- operatori aritmetici;
- operatori di confronto;
- operatori bit a bit;
- operatori logici;
- operatori di assegnazione;
- altri operatori.
Operatori aritmetici
Operatori aritmetici- usato in espressioni matematiche nello stesso modo in cui sono usati in algebra. Supponiamo che la variabile intera A sia 10 e la variabile B sia 20. La tabella seguente elenca gli operatori aritmetici in Java:
Esempio
Il seguente semplice esempio mostra gli operatori aritmetici a livello di codice. Copia e incolla il seguente codice java nel file test.java, compila ed esegui questo programma:
Classe pubblica Test (public static void main (String args) (int a = 10; int b = 20; int c = 25; int d = 25; System.out.println ("a + b =" + (a + b )); System.out.println ("a - b =" + (a - b)); System.out.println ("a * b =" + (a * b)); System.out.println (" b / a = "+ (b / a)); System.out.println (" b% a = "+ (b% a)); System.out.println (" c% a = "+ (c% a )); System.out.println ("a ++ =" + (a ++)); System.out.println ("b-- =" + (a--)); // Verifica la differenza in d ++ e ++ d System .out.println ("d ++ =" + (d ++)); System.out.println ("++ d =" + (++ d));))
A + b = 30 a - b = -10 a * b = 200 b / a = 2 b% a = 0 c% a = 5 a ++ = 10 b-- = 11 d ++ = 25 ++ d = 27
Operatori di confronto
I seguenti operatori di confronto sono supportati nel linguaggio Java. Supponiamo che la variabile A sia 10 e la variabile B sia 20. La tabella seguente elenca gli operatori relazionali o di confronto in Java:
| Operatore | Descrizione | Esempio |
| == | Controlla se i valori di due operandi sono uguali o meno, in caso affermativo, la condizione diventa vera | (A == B) - non corretto |
| != | Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali, la condizione diventa vera | (A! = B) - il valore è vero |
| > | Controlla se il valore dell'operando di sinistra è maggiore del valore dell'operando di destra, in caso affermativo, la condizione diventa vera | (A> B) - non vero |
| Controlla se il valore dell'operando di sinistra è minore del valore dell'operando di destra, in caso affermativo, la condizione diventa vera | (UN | |
| >= | Controlla se il valore dell'operando di sinistra è maggiore o uguale al valore dell'operando di destra, in caso affermativo, la condizione diventa vera | (A> = B) - i valori non sono corretti |
| Controlla se il valore dell'operando di sinistra è minore o uguale al valore dell'operando di destra, in caso affermativo, la condizione diventa vera | (UN |
Esempio
Il seguente semplice esempio mostra a livello di codice gli operatori di confronto in Java. Copia e incolla il seguente codice java nel file test.java, compila ed esegui questo programma:
Classe pubblica Test (public static void main (String args) (int a = 10; int b = 20; System.out.println ("a == b =" + (a == b)); System.out.println ("a! = b =" + (a! = b)); System.out.println ("a> b =" + (a> b)); System.out.println ("a = a =" + (b> = a)); System.out.println ("b
A == b = falso a! = B = vero a> b = falso a = a = vero b
Operatori bit a bit
Java definisce diversi operatori bit a bit che possono essere applicati ai tipi interi: int, long, short, char e byte. In Java, l'operatore bit a bit lavora sui bit ed esegue l'operazione bit per bit. Supponiamo se a = 60; e b = 13; quindi in binario saranno i seguenti:
a = 0011 1100
b = 0000 1101
-----------------
a e b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~ a = 1100 0011
Supponiamo che la variabile intera A sia 60 e la variabile B sia 13. La seguente tabella elenca gli operatori bit a bit in Java:
| Operatore | Descrizione | Esempio |
| & (e bit a bit) | L'operatore AND binario copia un po' nel risultato se esiste in entrambi gli operandi. | (A e B) daranno 12 che è 0000 1100 |
| | (bit a bit o) | L'operatore binario OR copia un bit se esiste in uno qualsiasi degli operandi. | (A | B) darà 61 che è 0011 1101 |
| ^ (bit a bit booleano o) | L'operatore XOR binario copia un bit se è impostato in un operando, ma non in entrambi. | (A ^ B) darà 49 che è 0011 0001 |
| ~ (complemento bit a bit) | L'operatore di complemento binario e ha l'effetto di "capovolgere" i bit. | (~ A) darà -61, che è la forma complementare di 1100 0011 in notazione binaria |
| Operatore binario shift sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra. | UN | |
| >> (sposta a destra) | Operatore binario di spostamento a destra. Il valore degli operandi di destra viene spostato a destra del numero di bit specificato dall'operando di sinistra. | A >> 2 darà 15 che è 1111 |
| >>> (spostamento zero a destra) | Operatore di spostamento a destra zero. Il valore degli operandi di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra e i valori spostati vengono riempiti con zeri. | A >>> 2 darà 15 che è 0000 1111 |
Esempio
Il seguente semplice esempio mostra gli operatori a livello di codice a livello di codice in Java. Copia e incolla il seguente codice java nel file test.java, compila ed esegui questo programma:
Public class Test ( public static void main (String args) (int a = 60; / * 60 = 0011 1100 * / int b = 13; / * 13 = 0000 1101 * / int c = 0; c = a & b; / * 12 = 0000 1100 * / System.out.println ("a & b =" + c); c = a | b; / * 61 = 0011 1101 * / System.out.println ("a | b =" + c); c = a ^ b; / * 49 = 0011 0001 * / System.out.println ("a ^ b =" + c); c = ~ a; / * - 61 = 1100 0011 * / System. out.println ("~ a =" + c); c = a> 2; / * 215 = 1111 * / System.out.println ("a >> 2 =" + c); c = a >>> 2 ; / * 215 = 0000 1111 * / System.out.println ("a >>> 2 =" + c);))
Otterrai il seguente output:
A & b = 12 a | b = 61 a ^ b = 49 ~ a = -61 a> 15 a >>> 15
Operatori logici
Supponiamo che la variabile booleana A sia vera e la variabile B sia falsa. La tabella seguente elenca gli operatori logici in Java:
Esempio
Classe pubblica Test (public static void main (String args) (boolean a = true; boolean b = false; System.out.println ("a && b =" + (a && b)); System.out.println (" a | | b = "+ (a || b)); System.out.println ("! (a && b) = "+! (a && b));))
Questo produrrà il seguente output:
A && b = falso a || b = vero! (a && b) = vero
Operatori di assegnazione
I seguenti operatori di assegnazione sono supportati dal linguaggio Java:
| Operatore | Descrizione | Esempio |
| = | Operatore di assegnazione semplice, assegna i valori dal lato destro degli operandi al lato sinistro | C = A + B, assegnerà il valore di A + B a C |
| += | L'operatore di assegnazione "Append", assegna all'operando di sinistra i valori di quello di destra | C + = A, equivalente a C = C + A |
| -= | L'operatore di assegnazione "Sottrazione", sottrae l'operando di sinistra dall'operando di destra | C - = A, equivalente a C = C - A |
| *= | L'operatore di assegnazione "Moltiplicazione", moltiplica l'operando di destra per l'operando di sinistra | C * = A è equivalente a C = C * A |
| /= | L'operatore di assegnazione "Divisione", divide l'operando sinistro per l'operando destro | C / = A è equivalente a C = C / A |
| %= | L'operatore di assegnazione "Modulo", prende un modulo utilizzando due operandi e assegna il suo risultato all'operando di sinistra | C% = A, equivalente a C = C% A |
| Operatore di assegnazione spostamento a sinistra | C | |
| >>= | Sposta l'operatore di assegnazione a destra | C >> = 2, è come C = C >> 2 |
| &= | Operatore di assegnazione "AND" bit a bit | C & = 2, è come C = C & 2 |
| ^= | Operatore di assegnazione "OR" esclusivo bit per bit ("XOR") | C ^ = 2, è come C = C ^ 2 |
| |= | Operatore di assegnazione OR (OR) bit per bit | C | = 2, è come C = C | 2 |
Esempio
Il seguente semplice esempio mostra gli operatori logici a livello di codice in Java. Copia e incolla il seguente codice java nel file test.java, compila ed esegui questo programma:
Classe pubblica Test ( public static void main (String args) (int a = 10; int b = 20; int c = 0; c = a + b; System.out.println ("c = a + b =" + c ); c + = a; System.out.println ("c + = a =" + c); c - = a; System.out.println ("c - = a =" + c); c * = a ; System.out.println ("c * = a =" + c); a = 10; c = 15; c / = a; System.out.println ("c / = a =" + c); a = 10; c = 15; c% = a; System.out.println ("c% = a =" + c); c> = 2; System.out.println ("c >> = 2 =" + c) ; c >> = 2; System.out.println ("c >> = a =" + c); c & = a; System.out.println ("c & = 2 =" + c); c ^ = a; System.out.println ("c ^ = a =" + c); c | = a; System.out.println ("c | = a =" + c);))
Otterrai il seguente output:
C = a + b = 30 c + = a = 40 c - = a = 30 c * = a = 300 c / = a = 1 c% = a = 5 c> = 2 = 5 c >> = 2 = 1 c & = a = 0 c ^ = a = 10 c | = a = 10
Altri operatori
Ci sono molti altri operatori supportati dal linguaggio Java.
Operatore ternario o operatore condizionale (? :)
Operatore ternario- un operatore composto da tre operandi e utilizzato per valutare espressioni di tipo booleano. L'operatore ternario in Java è anche noto come operatore condizionale. Questo. Obiettivo dell'operatore ternario o operatore condizionaleè decidere quale valore assegnare alla variabile. L'operatore si scrive come:
Variabile x = (espressione)? se vero: se falso
Esempio
Di seguito è riportato un esempio:
Classe pubblica Test (public static void main (String args) (int a, b; a = 10; b = (a == 1)? 20: 30; System.out.println ("Value b:" + b); b = (a == 10)? 20:30; System.out.println ("Valore b:" + b);))
Otterrai il seguente output:
Valore B: 30 Valore b: 20
Istanza dell'operatore
Istanza dell'operatore- controlla se l'oggetto è di un certo tipo(tipo di classe o tipo di interfaccia) e viene utilizzato solo per le variabili dell'oggetto di riferimento. L'operatore instanceof si scrive come:
(Variabile oggetto di riferimento) instanceof (classe/tipo di interfaccia)
Esempi di
Se la variabile dell'oggetto referenziato sul lato sinistro dell'istruzione supera il controllo per il tipo di classe/interfaccia di lato destro, il risultato è vero. Di seguito è riportato un esempio e una descrizione dell'operatore instanceof:
Public class Test (public static void main (String args) (String name = "Oleg"; // Quanto segue restituirà true perché il tipo è String boolean result = name instanceof String; System.out.println (risultato);))
Otterrai il seguente output:
Questo operatore restituirà ancora true se l'oggetto confrontato è compatibile con il tipo per il diritto di assegnazione. Segue un altro esempio:
Class Vehicle () public class Car estende Vehicle (public static void main (String args) (Vehicle a = new Car (); boolean result = a instanceof Car; System.out.println (risultato);))
Otterrai il seguente output:
Precedenza degli operatori in Java
La precedenza dell'operatore determina il raggruppamento dei termini in un'espressione. Ciò influisce sul modo in cui viene valutata l'espressione. Alcuni operatori hanno una priorità più alta di altri; ad esempio l'operatore di moltiplicazione ha una precedenza maggiore rispetto all'operatore di addizione:
Ad esempio, x = 7 + 3 * 2. Qui a x viene assegnato il valore 13, non 20, perché l'operatore "*" ha una precedenza maggiore di "+", quindi prima viene moltiplicato "3 * 2" e poi "7 " si aggiunge ".
Nella tabella, gli operatori con la priorità più alta sono posti in alto e il livello di priorità è abbassato verso il basso della tabella. In un'espressione, gli operatori con precedenza elevata in Java verranno valutati da sinistra a destra.
| Categoria | Operatore | Associatività |
| suffisso | (). (punto) | Da sinistra a destra |
| unario | ++ - - ! ~ | Da destra a sinistra |
| moltiplicativo | * / % | Da sinistra a destra |
| Additivo | + - | Da sinistra a destra |
| Cambio | >> >>> | Da sinistra a destra |
| relazionale | > >= | Da sinistra a destra |
| Uguaglianza | == != | Da sinistra a destra |
| Bit a bit "AND" | & | Da sinistra a destra |
| Bitwise esclusivo "OR" ("XOR") | ^ | Da sinistra a destra |
| Bit a bit "OR" ("OR") | | | Da sinistra a destra |
| "AND" logico | && | Da sinistra a destra |
| "OR" logico ("OR") | || | Da sinistra a destra |
| Condizionale | ?: | Da destra a sinistra |
| Incarico | = += -= *= /= %= >>= | Da destra a sinistra |
| Virgola | , | Da sinistra a destra |
Nella prossima lezione parleremo del controllo del ciclo nella programmazione Java. Questa lezione descriverà i diversi tipi di loop, come possono essere utilizzati i loop nello sviluppo del software e per quali scopi vengono utilizzati.
Operatori in Java
I seguenti operatori aritmetici sono supportati in Java (Tabella 2.4).
Tabella 2.4. Operatori aritmetici
aggiunta
- Sottrazione
* Moltiplicazione
/ Divisione
% Calcolo del resto
++ Incremento
- Decremento
+ = Assegnazione con addizione
- = Sottrazione di assegnazione
* = Assegnazione con moltiplicazione
/ = Assegnazione con divisione
% = Assegnazione con calcolo del resto
I primi cinque operatori sono familiari a tutti da corso di scuola matematica, con due cosiddetti operatori unari, e può essere usata per indicare il segno di un dato numero. Questo è seguito da operatori chiamati incremento (++) e decremento (- -).
Uno di questi (incremento) si aggiunge al valore unità variabile, l'altro (decremento), al contrario, ne sottrae uno.
Questi operatori sono indicati senza spazio accanto al valore della variabile. Se si trovano a sinistra della variabile, questa è chiamata la forma del prefisso di un incremento o decremento, e ciò significa che prima viene aggiunta (o sottratta da essa) un'unità alla variabile, quindi viene utilizzata nell'espressione . Se l'incremento (o il decremento) è posto dopo il nome della variabile, allora questo è chiamato il formato postfisso, e questo significa che la variabile viene prima usata nell'espressione, e poi uno viene aggiunto (o sottratto da) uno.
Gli altri cinque operatori vengono utilizzati come segue:
a + = b
simile a scrivere:
a = a + b
Un esempio di utilizzo di tutti questi operatori è mostrato nel Listato 2.9.
Listato 2.9.
Esempio di utilizzo operatori aritmetici
classe Esempio (
{
int a, b, c, d, e;
a = 10
b = 11;
c = 12;
a + = b; // a = 21
un * = c; // a = 252
a = a - c; // a = 240
a - = c; // a = 228
d = 5;
e = 10;
System.out.println (++ d); visualizzerà 6
System.out.println (d++); visualizzerà 6
System.out.println (e--); visualizzerà 10
System.out.println (--e); Uscita 8
}
}
Consideriamo ora gli operatori bit a bit (bit a bit) (Tabella 2.5).
Tabella 2.5. Operatori bit a bit (bit a bit)
Descrizione dell'operatore
- Negazione unaria
& AND bit per bit
| OR bit a bit
^ OR esclusivo bit per bit
<< Сдвиг битов влево
>> Sposta i bit a destra
>>> Sposta i bit a destra, riempiendo il bit più significativo con zero
&=, | =, ^=, <<=, >> =, >>> = Assegnazione con la stessa operazione
Con l'aiuto di questi operatori lavoriamo sui numeri nella loro rappresentazione binaria. Considera, ad esempio, di scrivere il numero 15 in binario. 00001111
Il primo operatore, chiamato negazione unaria, converte 0 in 1 e 1 in 0. L'operatore "e" bit a bit diventa uno se entrambi i bit simili dei numeri confrontati hanno anche 1. Se hanno una combinazione di numeri diversa, il il totale sarà 0. Ad esempio:
C = A & B
Supponiamo che A = 15 (00001111) e B sia 10 (00001010). Il numero C in questo caso sarà uguale a 10 (00001010). "OR" bit per bit significa quanto segue: se almeno uno dei bit è 1, anche il totale è 1. "OR" esclusivo per bit restituisce 1 se solo uno dei bit dei numeri confrontati è uguale a 1. I tre successivi gli operatori spostano i bit a sinistra del numero di cifre specificato, inoltre, spostando i bit a sinistra si riempiono le posizioni vuote con zeri. Un esempio di utilizzo di questi operatori è mostrato in Tabella. 2.6 e Listato 2.10.
Tabella 2.6. Operatori di spostamento di bit
Listato 2.10.
Un esempio di utilizzo degli operatori di spostamento dei bit
classe Esempio
{
public static void main (Stringa args)
{
int a = 3, b = 4, c = 5;
int d = a * b;
System.out.println (d);
d = a | C;
System.out.println (d);
d & = a;
System.out.println (d);
}
}
Gli operatori booleani sono supportati anche in Java, come mostrato nella tabella. 2.7.
Tabella 2.7. Operatori logici
Descrizione dell'operatore
= = Uguale
! = Non uguale
< Меньше
< = Меньше или равно
> Altro
> = Maggiore o uguale
& Logico e
| booleano o
^ Logica esclusiva o
! Negazione
&& condizionale e
| | Condizionale o
& =, | =, ^ = Assegnazione con lo stesso operatore
I primi sei operatori sono chiamati operatori di confronto. Ti consentono di confrontare i numeri e restituire vero o falso. I successivi quattro operatori funzionano con dati di tipo booleano, ma sono simili nel lavoro agli operatori bit analoghi (solo tu devi sostituire il bit 0 con falso e il bit 1 con vero).
I prossimi due operatori vengono utilizzati per due condizioni contemporaneamente, ad es. vengono specificate due condizioni e l'operatore "AND condizionale" viene inserito tra di esse. Se entrambi sono veri, viene emesso true; se almeno uno di essi è falso, il totale sarà falso.
L'operatore "condizionale o" restituirà vero se almeno una delle condizioni è vera. Sono comunemente usati nelle istruzioni if (ne parleremo nel prossimo capitolo). Un esempio di utilizzo di tutti questi operatori è mostrato nel Listato 2.11.
Listato 2.11.
Esempio di utilizzo operatori logici
classe Esempio
{
public static void main (Stringa args)
{
int a = 10, b = 15, c = 20;
booleano b1 = a! = b;
booleano b2 = c> a;
booleano b3 = b1 & b2;
booleano b4 = b3 ^ b1;
if (b1 && b4 = = false) // Se b1! = b4, allora:
bЗ = vero;
else // In caso negativo, allora:
b2 = falso;
}
}
Ecco un diagramma dell'uso degli operatori logici (Tabella 2.8).
Tabella 2.8. Valori dell'operatore logico per due variabili
La maggior parte delle operazioni su tipi primitivi si fa non con metodi, ma con personaggi speciali chiamato segno di operazione.
Operazione di assegnazione
Incarico valore variabile costanti, viene chiamata un'altra variabile o espressione (variabili e/o costanti separate da segni di operazione) operazione di assegnazione ed è indicato dal cartello " = ", ad esempio: x = 3; y = x; z = x; In Java è possibile riutilizzare l'operazione di assegnazione in un'espressione, ad esempio: x1 = x2 = x3 = 0; Questa operazione viene eseguita da destra a sinistra, cioè prima alla variabile x3 viene assegnato il valore 0, poi alla variabile x2 viene assegnato il valore della variabile x3 (0) e infine alla variabile x1 viene assegnato il valore della variabile x2 (0). i segni di operazioni i cui argomenti sono numeri rientrano in due categorie: unario token (unari) per operazioni a argomento singolo e binario(binario) con due argomenti.operazioni unarie
Le seguenti operazioni unarie sono definite in Java:- unario meno "-" - cambia il segno di un numero o di un'espressione al contrario;
- unario più "+" - non esegue alcuna azione su un numero o un'espressione;
- complemento bit a bit "~" (solo per numeri interi) - inverte tutti i bit del campo numerico (cambia da 0 a 1 e da 1 a 0);
- incremento "++" (solo per numeri interi) - aumenta il valore della variabile di 1;
- decremento "-" (solo per numeri interi) - diminuisce il valore della variabile di 1.
Operazioni binarie aritmetiche
Java definisce quanto segue operazioni binarie aritmetiche:- addizione "+";
- sottrazione "-";
- moltiplicazione " * ";
- divisione "/";
- calcolando il resto della divisione degli interi "%" (restituisce il resto della divisione del primo numero per il secondo e il risultato avrà lo stesso segno del dividendo), ad esempio, il risultato dell'operazione 5% 3 sarà 2 e il risultato dell'operazione (-7) % (- 4) sarà -3. V Operazione Java può essere utilizzato per variabili reali (float o double).
Operazioni bit a bit
- Le operazioni bit a bit considerano l'originale valori numerici come campi di bit ed eseguire su di essi le seguenti azioni:
- impostando il bit su io-esima posizione del campo risultato a 1, se entrambi i bit sono in io-esima posizione degli operandi uguale a 1, o 0, altrimenti - AND bit per bit ("&");
- impostando il bit su io-esima posizione del campo risultato a 1, se almeno un bit in io-esima posizione degli operandi è uguale a 1, oa 0, altrimenti - OR bit a bit ("|");
- impostando il bit su io-esima posizione del campo risultato a 1, se i bit in io-esima posizione degli operandi non uguale tra loro, o uguale a 0, altrimenti - OR esclusivo bit a bit ("^");
- spostamento a sinistra dei bit del campo del primo operando per il numero di bit determinato dal secondo operando (il bit di segno del numero non cambia in questo caso) - spostamento bit per bit a sinistra, tenendo conto del segno "<< ";
- sposta a destra dei bit del campo del primo operando per il numero di bit determinato dal secondo operando (il bit di segno del numero non cambia in questo caso) - sposta a destra per bit, tenendo conto del " >>" segno;
- spostamento a destra dei bit del campo del primo operando per il numero di bit determinato dal secondo operando (in questo caso viene spostato anche il bit di segno del numero) - spostamento bit per bit a destra senza tenere conto del " >>>" segno.
AND . bit a bit
intero x = 112; int y = 94; int z; z = x & y; //z = 80: 00000000 00000000 00000000 01010000OR bit a bit
intero x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z = x | si; //z = 126: 00000000 00000000 00000000 01111110OR esclusivo bit a bit
intero x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z = x ^ y; //z = 46: 00000000 00000000 00000000 00101110Spostati a sinistra, tenendo conto del segno
int x = 31, z; // x: 00000000 00000000 00000000 00011111 z = x<< 2 ; //z = 124: 00000000 00000000 00000000 01111100Spostati a destra, tenendo conto del segno
int x = - 17, z; z = x >> 2; //z = -5: 11111111 11111111 11111111 11111011Sposta a destra senza riguardo al segno
int x = - 17, z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2; //z = 1073741819 // z: 00111111 11111111 11111111 11111011
Operazioni combinate
In Java, per le operazioni aritmetiche binarie, puoi usare combinato token operazione (composti): identificatore operazione = espressione Equivale alla seguente operazione: identificatore = identificatore operazione espressione Esempi:- L'espressione x + = b significa x = x + b.
- L'espressione x - = b significa x = x - b.
- L'espressione x * = b significa x = x * b.
- L'espressione x / = b significa x = x / b.
- L'espressione x% = b significa x = x% b.
- L'espressione x & = b significa x = x & b.
- L'espressione x | = b significa x = x | B.
- L'espressione x ^ = b significa x = x ^ b.
- Espressione x<<= b означает x = x << b .
- L'espressione x >> = b significa x = x >> b.
- L'espressione x >>> = b significa x = x >>> b.
Operazioni di confronto
Java definisce i seguenti operatori di confronto:- "==" (uguale), "! =" (non uguale),
- ">" (maggiore di), "> =" (maggiore o uguale),
- " < " (меньше) " <= " (меньше или равно)
Operazioni booleane
Operazioni booleane vengono eseguiti su variabili booleane e il loro risultato è anche un valore di tipo booleano... Le seguenti operazioni booleane sono definite in Java:- negazione "!" - sostituire falso con vero, o viceversa;
- Operazione AND "&" - il risultato è vero solo se entrambi gli operandi sono veri, altrimenti il risultato è falso;
- Operazione OR "|" - il risultato è vero solo se almeno uno degli operandi è vero, altrimenti il risultato è falso.
- Operazione XOR "^" - il risultato è vero solo se gli operandi non sono uguali tra loro, altrimenti il risultato è falso.
Operazione condizionale
Un'operazione condizionale è scritta nella forma espressione-1?espressione-2:espressione-3. In questo caso, viene valutata prima l'espressione-1, che dovrebbe fornire un valore booleano, quindi, se l'espressione-1 è vera, l'espressione-2 viene valutata e restituita come risultato dell'operazione, oppure (se l'espressione-1 è falsa ) e l'espressione-3 viene restituita come risultato dell'operazione. Un esempio di operazione condizionale: x = n> 1? 0: 1; Alla variabile x verrà assegnato il valore 0 se n> 1 (espressione n> 1 vale vero) o 1 se n≤1 (espressione n> 1 vale falso).Anzianità delle operazioni
Le operazioni nelle espressioni vengono tuttavia eseguite da sinistra a destra, in base alla loro priorità. Quindi operazioni di moltiplicazione nell'espressione y = x + z * 5; verrà eseguito prima dell'operazione di addizione perché la priorità dell'operazione di moltiplicazione è maggiore della priorità dell'operazione di addizione. Le priorità delle operazioni (in ordine decrescente di priorità) in Java sono mostrate nella Tabella. uno.
Le parentesi aumentano la precedenza delle operazioni che si trovano al loro interno. Quindi, se inserisci parentesi nell'espressione sopra: y = (x + z) * 5; quindi verrà eseguita prima l'operazione di addizione, quindi l'operazione di moltiplicazione. A volte le parentesi vengono usate semplicemente per rendere più leggibile l'espressione, ad esempio: (x> 1) && (x<=
5
)
;
Digitare la conversione e il casting durante l'esecuzione delle operazioni
Nelle espressioni di assegnazione e aritmetiche si possono utilizzare letterali, variabili ed espressioni di diverso tipo, ad esempio: double y; byte x; y = x + 5; Questo esempio aggiunge la variabile byte x al letterale 5 (int) e assegna il risultato alla doppia variabile y. In Java, come nel linguaggio C, le conversioni di tipo nella valutazione delle espressioni possono essere eseguite automaticamente o utilizzando un operatore di cast. Tuttavia, le regole di casting sono in qualche modo diverse da quelle del linguaggio C, e in generale sono più rigide rispetto al linguaggio C. Quando si esegue un'operazione di assegnazione, la conversione del tipo avviene automaticamente se ampliamento trasformare(conversione allargata) e i due tipi sono compatibili... Le trasformazioni in ampliamento sono trasformazioni byte® breve® int® lungo® galleggiante® Doppio... Per le conversioni di ampliamento, i tipi numerici, inclusi interi e in virgola mobile, sono compatibili tra loro. Tuttavia, i tipi numerici non sono compatibili con i tipi char e booleani. Neanche i tipi char e boolean sono compatibili tra loro. Java esegue anche la conversione automatica del tipo quando memorizza una costante letterale intera (che è di tipo int per impostazione predefinita) in variabili di tipo byte, short o long (tuttavia, se il letterale ha un valore al di fuori dell'intervallo di valori validi per questo tipo, viene visualizzato un messaggio di errore: possibile perdita di precisione). Se la conversione è una conversione restrittiva, ovvero viene eseguita byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ double, tale conversione può comportare una perdita di precisione o una distorsione del numero. Pertanto, con le conversioni restringenti, quando il programma viene compilato, viene visualizzato un messaggio di diagnostica sull'incompatibilità di tipo e i file di classe non vengono creati. Questo messaggio verrà visualizzato anche quando si tenta di convertire espressioni di tipo byte o short in una variabile di tipo char. Se è comunque necessario eseguire tali conversioni, viene utilizzata un'operazione di cast, che ha il seguente formato: ( tipo di conversione) senso, dove tipo di conversione definisce il tipo in cui il dato dovrebbe essere convertito senso, ad esempio, come risultato dell'esecuzione di operatori: byte x = 71; simbolo carattere = (carattere) x; la variabile simbolo sarà impostata su "G". Se un valore a virgola mobile è assegnato a un tipo intero, allora (se il valore a virgola mobile ha una parte frazionaria), si verifica anche una conversione di tipo esplicita troncamento(troncamento) numeri. Quindi, come risultato dell'esecuzione dell'operatore int x = (int) 77,85; la variabile x sarà impostata su 77. Se il valore assegnato è fuori intervallo conversioni di tipo , quindi il risultato della conversione sarà il resto della divisione del valore per il modulo dell'intervallo del tipo assegnato (per i numeri di tipo byte, il modulo dell'intervallo sarà 256, in breve - 65536, per int - 4294967296 , e a lungo - 18446744073709551616). Ad esempio, come risultato dell'istruzione byte x = (byte) 514; la variabile x sarà impostata su 2. Quando si convertono numeri interi o reali in dati di tipo char, la conversione in un carattere avviene se il numero originale è compreso nell'intervallo da 0 a 127, altrimenti il carattere assume il valore "?". Quando si eseguono conversioni aritmetiche e bit per bit, tutti i valori byte e short, nonché char, vengono espansi in int, (mentre il valore numerico del codice carattere viene utilizzato nei calcoli per char) quindi, se almeno un operando è di tipo long , il tipo dell'espressione intera viene esteso a long. Se uno degli operandi è di tipo float, il tipo dell'espressione completa viene espanso in float e se uno degli operandi è di tipo double, il tipo del risultato sarà double. Quindi, se le variabili sono dichiarate byte a, c; b breve; quindi nell'espressione a + b * c - 15 L + 1.5F + 1.08 - 10; prima, prima di calcolare a + b * c, i valori delle variabili verranno espansi a int, quindi, poiché la costante 15 è di tipo long, il risultato del calcolo verrà aumentato a long prima della sottrazione. Successivamente, poiché il letterale 1.5 è di tipo float, il risultato del calcolo di a + b * c - 15L verrà espanso in float prima di essere aggiunto a questo letterale. Prima di eseguire l'addizione con il numero 1.08, il risultato dei calcoli precedenti verrà espanso a double (poiché le costanti reali sono di tipo double per impostazione predefinita) e, infine, prima di eseguire l'ultima addizione, il letterale 10 (di default int) sarà ampliato al doppio. Pertanto, il risultato della valutazione dell'espressione sarà di tipo double. Le estensioni di tipo automatiche (in particolare le estensioni short e byte di int) possono causare errori in fase di compilazione non riconosciuti. Ad esempio, negli operatori: byte x = 30, y = 5; x = x + y; prima che venga eseguita l'addizione, il valore delle variabili x e y verrà espanso in int, quindi verrà visualizzato un messaggio di errore quando si tenta di assegnare il risultato di un calcolo di tipo int a una variabile di tipo byte. Per evitare ciò è necessario utilizzare una conversione di tipo esplicita nel secondo operatore: x = (byte) (x + y); È necessario racchiudere l'espressione x + y tra parentesi perché la priorità del cast racchiuso tra parentesi è maggiore della priorità dell'operazione di addizione. A proposito, se scrivi il secondo operatore come: x + = y; non ci sarà alcun messaggio di errore. Link al primoGli operatori in Java sono caratteri speciali che indicano al traduttore che si desidera eseguire un'operazione su alcuni operandi. Alcuni operatori richiedono un operando, vengono chiamati unario. Alcuni operatori sono posti prima degli operandi e sono chiamati prefisso, altri - dopo, sono chiamati suffisso operatori. La maggior parte degli operatori sono posti tra due operandi, tali operatori sono chiamati infisso operatori binari. Esiste un operatore ternario che lavora con tre operandi.
Java ha 44 operatori integrati. Possono essere suddivisi in 4 classi - operatori aritmetici, bit a bit, di confronto e rompicapo.
Operatori aritmetici
Gli operatori aritmetici vengono utilizzati per i calcoli allo stesso modo dell'algebra (vedere la tabella per un riepilogo degli operatori aritmetici di seguito). Gli operandi validi devono essere di tipo numerico. Ad esempio, non è possibile utilizzare questi operatori per lavorare con i tipi booleani, ma è possibile utilizzare questi operatori per lavorare con il tipo char, perché in Java il tipo char è un sottoinsieme del tipo int.
|
Operatore |
Risultato |
Operatore |
Risultato |
|
aggiunta |
assegnazione di addizione |
||
|
sottrazione (anche meno unario) |
assegnazione di sottrazione |
||
|
Moltiplicazione |
assegnazione moltiplicazione |
||
|
divisione con incarico |
|||
|
modulo divisione |
assegnazione modulo |
||
|
Incremento |
decremento |
Quattro operazioni aritmetiche
Di seguito, a titolo di esempio, è riportato un semplice programma che dimostra l'uso degli operatori. Nota che gli operatori lavorano sia su valori letterali interi che su variabili.
class BasicMath ( public static void int a = 1 + 1;
intb = a * 3;
main (stringa di argomenti) (
int c = b / 4;
int d = b - a;
int e = -d;
System.out.println ("a =" + a);
System.out.println ("b =" + b);
System.out.println ("c =" + c);
System.out.println ("d =" + d);
System.out.println ("e =" + e);
} }
Eseguendo questo programma, dovresti ottenere il seguente output:
C: \> java BasicMath
a = 2
b = 6
c = 1
d = 4
e = -4
Operatore modulo
L'operatore modulo, o operatore mod, è indicato dal simbolo%. Questo operatore restituisce il resto della divisione del primo operando per il secondo. A differenza di C++, la funzione mod in Java funziona non solo con numeri interi, ma anche con tipi reali. Il programma seguente illustra il funzionamento di questo operatore.
classe Modulo (
public static void main (Stringa argomenti ) {
intero x = 42;
doppia y = 42,3;
System.out.println ("x mod 10 =" + x% 10);
System.out.println ("y mod 10 =" + y% 10);
} }
Eseguendo questo programma, otterrai il seguente output:
C: \> Modulo
x modulo 10 = 2
ymod 10 = 2,3
Operatori di assegnazione aritmetica
Per ciascuno degli operatori aritmetici esiste una forma in cui un'assegnazione viene eseguita contemporaneamente a una determinata operazione. Di seguito è riportato un esempio che illustra l'utilizzo di questo tipo di operatore.
classe OpEquals (
int a = 1;
intero b = 2;
intero c = 3;
un + = 5;
b * = 4;
c + = a * b;
con% = 6;
} }
Ed ecco il risultato ottenuto durante l'esecuzione di questo programma:
C:> Java OpEquals
a = 6
b = 8
c = 3
Incremento e diminuzione
Ci sono 2 operatori in C chiamati operatori di incremento e decremento (++ e -), che sono abbreviazioni per aggiungere o sottrarre uno da un operando. Questi operatori sono unici in quanto possono essere utilizzati sia in forma prefissa che postfissa. L'esempio seguente illustra l'uso degli operatori di incremento e decremento.
classe IncDec (
public static void main (String args) (
int a = 1;
intero b = 2;
int c = ++ b;
int d = a++;
c++;
System.out.println ("a =" + a);
System.out.println ("b =" + b);
System.out.println ("c =" + c);
} }
Il risultato dell'esecuzione di questo programma sarà il seguente:
C: \ java IncDec
a = 2
b = 3
c = 4
d = 1
Operatori bit a bit interi
Per i tipi di dati numerici interi - long, int, short, char e byte, viene definito un ulteriore set di operatori, con cui è possibile verificare e modificare lo stato dei singoli bit dei valori corrispondenti. La tabella fornisce un riepilogo di questi operatori. Gli operatori aritmetici dei bit lavorano con ogni bit come un valore indipendente.
|
Operatore |
Risultato |
Operatore |
Risultato |
|
negazione unaria bit per bit (NOT) |
|||
|
AND bit a bit |
AND bit per bit (AND) con assegnazione |
||
|
OR bit per bit (OR) |
OR bit a bit (OR) con assegnazione |
||
|
OR esclusivo bit per bit (XOR) |
OR esclusivo bit per bit (XOR) con assegnazione |
||
|
sposta a destra |
spostamento a destra con assegnazione |
||
|
shift a destra riempito con zeri |
shift a destra riempito con zeri con assegnazione |
||
|
tasto maiuscolo di sinistra |
spostamento a sinistra con assegnazione |
Un esempio di un programma che manipola i bit
La tabella seguente mostra come ciascuno degli operatori aritmetici di bit influisca sulle possibili combinazioni di bit dei relativi operandi. L'esempio che segue la tabella illustra l'uso di questi operatori in un programma Java.
classe Bitlogic (
public static void main (String args) (
Stringa binario = ("OOOO", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011 "," 1100 "," 1101 ",
"1110", "1111" };
int a = 3; // 0 + 2 + 1 o binario 0011
int b = 6; // 4 + 2 + 0 o binario 0110
int c = a | B;
int d = a & b;
int e = a ^ b;
int f = (~ a & b) | (a & ~ b);
int g = ~ a & 0x0f;
System.out.println ("a =" + binario [a]);
System.out.println ("b =" + binario [b]);
System.out.println ("ab =" + binario [c]);
System.out.println ("a & b =" + binario [d]);
System.out.println ("a ^ b =" + binario [e]);
System.out.рrintln ("~ a & b | a ^ ~ b =" + binario [f]);
System.out.println ("~ a = "+ binario [g]);
} }
Di seguito è riportato l'output di questo programma:
C: \> Java BitLogic
a = 0011
b = 0110
un | b = 0111
a e b = 0010
a^b = 0101
~ a & b | a & ~ b = 0101
~ a = 1100
Sposta a sinistra e a destra
Operatore<< выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями. В предыдущей главе уже говорилось об автоматическом повышении типа всего выражения до int в том случае если в выражении присутствуют операнды типа int или целых типов меньшего размера. Если же хотя бы один из операндов в выражении имеет тип long, то и тип всего выражения повышается до long.
L'operatore >> significa spostamento a destra in Java. Sposta tutti i bit del suo operando sinistro a destra del numero di posizioni specificato dall'operando destro.Quando i bit dell'operando sinistro vengono fatti avanzare oltre la posizione della parola più a destra, vengono persi. Quando si sposta a destra, le cifre superiori (sinistra) liberate del numero spostato vengono riempite con il contenuto precedente della cifra con segno. Questo comportamento è chiamato espansione del segno.
Il seguente programma converte un valore di byte in una stringa contenente la sua rappresentazione esadecimale. Si noti che il valore traslato deve essere mascherato, cioè deve essere logicamente moltiplicato per il valore 0 x0 f, in modo da azzerare i bit riempiti per effetto dell'espansione del segno e abbassare il valore ai limiti consentiti durante l'indicizzazione di un matrice di cifre esadecimali.
classHexByte (
char hex = ("0", "1," 2 "," 3 "," 4 "," 5 "," 6 "," 7 "," 8 "," 9 "," a "," b " , "c", "d", "e", "f);
byte b = (byte) 0xf1;
System.out.println ("b = 0x" + esadecimale [(b >> 4) & 0x0f] + esadecimale);
} }
Di seguito è riportato l'output di questo programma:
C: \> java HexByte
b = 0xf1
Shift a destra senza segno
Spesso è necessario che quando si sposta a destra, il bit di segno non si espanda e le cifre lasciate vuote vengano semplicemente riempite con zeri.
classe ByteUShift (
static public void main (String args) (
char hex = ("0", "1 '," 2 "," 3 "," 4 "," 5 "," 6 "," 7 "," 8 "," 9 "," a "," b "," c "," d "," e "," f ');
byte b = (byte) 0xf1;
byte c = (byte) (b >> 4);
byte d = (byte) (b >> 4);
byte e = (byte) ((b & 0xff) >> 4);
System.out.println ("b = 0x" + esadecimale (b >> 4) & 0x0f] + esadecimale);
System.out.println ("b >> 4 = 0x" + esadecimale [(c >> 4) & 0x0f] + esadecimale);
System.out.println ("b >>> 4 = 0x" + esadecimale [(d >> 4) & 0x0f] + esadecimale);
System.out.println (“(b & 0xff) >> 4 = 0x" + esadecimale [(e >> 4) & 0x0f] + esadecimale);
} }
Per questo esempio, la variabile b potrebbe essere inizializzata con un numero negativo arbitrario, abbiamo usato un numero con rappresentazione esadecimale 0xf1. Alla variabile c viene assegnato il risultato di uno spostamento con segno b a destra di 4 bit. Come previsto, l'allargamento del bit con segno fa sì che 0xf1 diventi 0xff. Quindi il risultato di uno spostamento senza segno di b a destra di 4 bit viene inserito nella variabile d. Potresti aspettarti che d contenga 0x0f come risultato, ma in realtà otteniamo di nuovo 0xff. Questo è il risultato dell'espansione del segno eseguita quando la variabile b viene automaticamente promossa a int prima dell'operazione di spostamento a destra. Infine, nell'espressione per la variabile e, riusciamo a ottenere il risultato desiderato: il valore 0x0f. Per fare ciò, prima di spostarci a destra, dovevamo moltiplicare logicamente il valore della variabile b per la maschera 0xff, cancellando così i bit di ordine superiore riempiti durante l'aumento automatico del tipo. Si noti che non è più necessario utilizzare lo spostamento a destra senza segno, poiché conosciamo lo stato del bit di segno dopo l'operazione AND.
C: \> java ByteUShift
b = 0xf1
b >> 4 = 0xff
b >>> 4 = 0xff
b & 0xff) >> 4 = 0x0f
Operatori di assegnazione bit a bit
Come per gli operatori aritmetici, tutti gli operatori binari bit a bit hanno una forma correlata che consente di assegnare automaticamente il risultato di un'operazione all'operando di sinistra. V seguente esempio vengono create diverse variabili intere, con le quali vengono eseguite varie operazioni utilizzando gli operatori sopra indicati.
classe OpBitEquals (
public static void main (String args) (
int a = 1;
intero b = 2;
intero c = 3;
a|= 4;
b >> = 1;
Con<<= 1;
a^ = c;
System.out.println ("a =" + a);
System.out.println ("b =" + b);
System.out.println ("c =" + c);
} }
I risultati dell'esecuzione del programma sono i seguenti:
C: \> Java OpBitEquals
a = 3
b = 1
c = 6
Operatori relazionali
Per poter confrontare due valori, Java ha un insieme di operatori che descrivono la relazione e l'uguaglianza. L'elenco di tali operatori è riportato nella tabella.
|
Operatore |
Risultato |
|
più o uguale |
|
|
minore o uguale |
Valori di qualsiasi tipo, inclusi interi, numeri reali, simboli, booleani e riferimenti, possono essere confrontati utilizzando l'operatore di uguaglianza == e l'operatore di disuguaglianza! =. Si noti che in Java, proprio come in C e C++, il test di uguaglianza è indicato dalla sequenza (==). Un segno (=) è l'operatore di assegnazione.
Operatori logici booleani
Gli operatori logici booleani, riepilogati nella tabella seguente, operano solo su operandi booleani. Tutti gli operatori logici binari accettano due valori booleani come operandi e restituiscono lo stesso tipo.
|
Operatore |
Risultato |
Operatore |
Risultato |
|
AND logico (AND) |
AND (AND) con assegnazione |
||
|
OR logico (OR) |
OR (OR) con assegnazione |
||
|
OR logico esclusivo (XOR) |
OR esclusivo (XOR) con assegnazione |
||
|
l'operatore OR di valutazione rapida dell'espressione ( corto circuito O) |
|||
|
cortocircuito AND operatore |
|||
|
negazione logica unaria (NOT) |
operatore ternario if-then-else |
I risultati dell'influenza degli operatori logici su varie combinazioni dei valori degli operandi sono mostrati nella tabella.
Il programma seguente ripete quasi completamente l'esempio BitLogic che già conosci. Solo, ma questa volta stiamo lavorando con valori booleani booleani.
classe BoolLogic (
public static void main (String args) (
booleano a = vero;
booleano b = falso;
booleano c = a | B;
booleano d = a & b;
booleano e = a ^ b;
booleano f = (! a & b) | (a &! b);
booleano g =! a;
System.out.println ("a =" + a);
System.out.println ("b =" + B);
System.out.println ("a | b =" + c);
System.out.println ("a & b =" + d);
System.out.println ("a ^ b =" + e);
System.out.println ("! A & b | a &! B =" + f);
System.out.println ("! A =" + g);
} }
C: \> Java BoolLogic
a = vero
b = falso
a | b = vero
a & b = falso
a ^ b = vero
! a & b | a &! b = vero
!a = falso
Operatori di valutazione rapida espressioni logiche(operatori logici di cortocircuito)
Ci sono due interessanti aggiunte alla suite di operatori booleani. Si tratta di versioni alternative degli operatori AND e OR per valutare rapidamente le espressioni booleane. Sai che se il primo operando di un operatore OR è vero, il risultato dell'operazione è vero, indipendentemente dal valore del secondo operando. Allo stesso modo, nel caso dell'operatore AND, se il primo operando è falso, il valore del secondo operando non influisce sul risultato: sarà sempre falso. Se stai usando && e || invece delle solite forme & e |, Java non valuta l'operando di destra di un'espressione booleana se la risposta è chiara dal valore dell'operando di sinistra. È pratica comune usare && e || in quasi tutti i casi, valutando espressioni logiche booleane. Versioni di questi operatori & e | si applica solo all'aritmetica dei bit.
Operatore ternario if-then-else
La forma generale dell'istruzione if-then-use è la seguente:
espressione1? espressione2: espressione3
Come primo operando - "espressione1" - è possibile utilizzare qualsiasi espressione il cui risultato è un valore booleano. Se il risultato è vero, viene eseguito l'operatore specificato dal secondo operando, ovvero "espressione2". Se il primo operando è falso, viene eseguito il terzo operando, "espressione3". Il secondo e il terzo operando, ovvero espressione2 ed espressione3, devono restituire valori dello stesso tipo e non devono essere nulli.
Il programma seguente utilizza questo operatore per testare il divisore prima di eseguire l'operazione di divisione. In caso di divisore zero, viene restituito il valore 0.
classe ternaria (
public static void main (String args) (
int a = 42;
intero b = 2;
intc = 99;
int d = 0;
int e = (b == 0)? 0: (a/b);
int f = (d == 0)? 0: (c/d);
System.out.println ("a =" + a);
System.out.println ("b =" + b);
System.out.println ("c =" + c);
System.out.println ("d =" + d);
System.out.println ("a / b =" + e);
System.out.println ("c / d =" + f);
} }
Questo programma non solleva un'eccezione di divisione per zero e restituisce i seguenti risultati:
C: \> java Ternary
a = 42
b = 2
c = 99
d = 0
a/b = 21
s / d = 0
Priorità dell'operatore
Java ha un ordine specifico, o precedenza, delle operazioni. In algebra elementare, ci è stato insegnato che la moltiplicazione e la divisione hanno una priorità maggiore rispetto all'addizione e alla sottrazione. Nella programmazione, devi anche tenere traccia delle priorità delle operazioni. La tabella elenca in ordine decrescente le priorità di tutte le operazioni del linguaggio Java.
La prima riga della tabella elenca tre operatori insoliti di cui non abbiamo ancora parlato. Le parentesi () vengono utilizzate per impostare in modo esplicito la priorità. Come hai appreso nel capitolo precedente, le parentesi quadre vengono utilizzate per indicizzare una variabile di array. Operatore. (punto) viene utilizzato per separare gli elementi da un riferimento a un oggetto - ne parleremo nel Capitolo 7. Tutti gli altri operatori sono già stati discussi in questo capitolo.
Priorità esplicite
Poiché la massima priorità è data a parentesi tonde, puoi sempre aggiungere più coppie di parentesi a un'espressione se hai dubbi sull'ordine di valutazione o vuoi semplicemente rendere il tuo codice più leggibile.
a >> b + 3
Quale delle due espressioni, a >> (b + 3) o (a >> b) + 3, corrisponde alla prima riga? Poiché l'operatore di addizione ha una precedenza maggiore rispetto all'operatore di spostamento, la risposta corretta è a >> (b + un). Quindi se devi eseguire un'operazione (a >> b )+ 3 le parentesi sono indispensabili.
Quindi, abbiamo coperto tutti i tipi di operatori nel linguaggio Java. Ora puoi costruire qualsiasi espressione Con tipi diversi dati... Nel prossimo capitolo, faremo conoscenza con i costrutti di ramificazione, l'organizzazione dei cicli e impareremo come controllare l'esecuzione del programma.
Operatori logici di cortocircuito && e || sono destinati alle operazioni logiche AND (AND) e OR (OR) su espressioni di tipo booleano. Si noti che non esiste un operatore logico abbreviato per l'operazione XOR (OR esclusivo).
Gli operatori booleani troncati sono simili a & e |, ma sono diversi. solo alle espressioni di tipo booleano e non si applicano mai a tipi integrali... Tuttavia, && e || hanno una proprietà notevole: abbreviano la valutazione di un'espressione se il risultato può essere dedotto da una parte dell'espressione (lo spiegherò con esempi un po' più avanti). A causa di questa proprietà, && e || sono ampiamente utilizzati per gestire le espressioni nulle. Aiutano anche ad aumentare l'efficacia dell'intero programma.
La proprietà di accorciamento segue direttamente dalle differenze tra && / || e & / |: l'ultima coppia di operatori deve ricevere i valori degli operatori sinistro e destro, mentre per la prima coppia di operatori a volte è sufficiente conoscere il valore del solo operando sinistro per restituire il valore dell'intero espressione. Questo comportamento degli operatori logici troncati si basa su due regole matematiche tabella di verità logica:
- un'espressione con un operatore AND è falsa (false) se il valore di almeno uno dei suoi operandi è falso;
- un'espressione con un operatore OR è vera se il valore di almeno uno dei suoi operandi è vero.
- falso AND X = falso
- vero OPPURE X = vero
Considera un esempio di codice che visualizza un messaggio String se la stringa non è nulla ed è lunga più di 20 caratteri:
1.if ((s! = Null) && (s.length ()> 20)) (
2. System.out.println (s);
3. }
La stessa attività può essere codificata in modo diverso:
1.se (s! = Nullo) (
2.if (s.lunghezza ()> 20) (
3. System.out.println (s);
4. }
5. }
Se s fosse nullo, otterremmo una NullPointerException quando chiamiamo il metodo s.length(). Nessuno dei due esempi di codice, tuttavia, presenterà questa situazione. In particolare, nel secondo esempio, s.length() non viene chiamato quando s = null, a causa dell'uso dell'operatore abbreviato &&. Se il test (s! = Null) ha restituito false, ovvero s è una stringa inesistente, l'intera espressione è sicuramente falsa. Ciò significa che non è necessario calcolare il valore del secondo operando, ovvero l'espressione (s.length()> 20).
Tuttavia, questi operatori hanno effetti collaterali. Ad esempio, se l'operando di destra è un'espressione che esegue un'operazione, quando si utilizzano operatori troncati, questa operazione potrebbe non riuscire se l'operando di sinistra è falso.
Consideriamo un esempio:
// primo esempio 1. int val = (int) (2 * Math.random ()); 2.test booleano = (val == 0) || (++ val == 2); 3. System.out.println (“test =“ + test + “\ nval =“ + val); // secondo esempio 1. int val = (int) (2 * Math.random ()); 2.test booleano = (val == 0) | (++ val == 2); 3. System.out.println (“test =“ + test + “\ nval =“ + val);
Il primo esempio a volte stamperà questo:
prova = vero
val = 0
E a volte questo:
prova = vero
val = 2
Il secondo esempio a volte stamperà questo:
prova = vero
val = 1
E a volte questo:
prova = vero
val = 2
Ed ecco la cosa. Se val è 0, il secondo operando (++ val) non verrà mai valutato, ovvero val rimarrà uguale a zero... Se inizialmente val è uguale a uno, quindi di conseguenza questa variabile verrà incrementata e vedremo val = 2. Nel secondo esempio, quando si usa non operatori abbreviati, l'incremento viene sempre eseguito e il risultato sarà sempre 1 o 2, a seconda del valore casuale scelto nel primo passaggio. In entrambi gli esempi, il test variabile restituisce true perché val = 0 o val = 1 e viene incrementato al valore 2.
Riassumiamo le informazioni sugli operatori abbreviati && e ||:
- Si applicano agli operandi booleani;
- Calcolano solo il valore dell'operando di destra se il risultato non può essere calcolato in base al valore dell'operando di sinistra:
- falso AND X = falso
- vero OPPURE X = vero
