Operatori dentro linguaggio 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 vengono posti prima degli operandi e vengono chiamati prefisso, altri - dopo, vengono chiamati suffisso operatori. La maggior parte degli operatori sono posti tra due operandi, tali operatori vengono chiamati infisso operatori binari. Esiste un operatore ternario che opera su tre operandi.
Java ha 44 operatori integrati. Possono essere divisi in 4 classi - operatori aritmetici, bit per bit, di confronto e rompicapo.
Operatori aritmetici
Gli operatori aritmetici vengono utilizzati per i calcoli allo stesso modo dell'algebra (vedere la tabella seguente per un riepilogo degli operatori aritmetici). Gli operandi validi devono essere di tipo numerico. Ad esempio, utilizzare questi operatori con cui lavorare tipi booleaniè impossibile, ma per lavorare con il tipo char è possibile, perché in tipo Java char è un sottoinsieme del tipo int.
|
Operatore |
Risultato |
Operatore |
Risultato |
|
Aggiunta |
aggiunta con incarico |
||
|
sottrazione (anche meno unario) |
sottrazione con assegnazione |
||
|
Moltiplicazione |
moltiplicazione con incarico |
||
|
divisione con incarico |
|||
|
modulo |
modulo con incarico |
||
|
Incremento |
decremento |
Quattro operazioni aritmetiche
Quello che segue è un semplice programma che mostra l'uso degli operatori come esempio. Si noti che gli operatori funzionano sia su valori letterali interi che su variabili.
class BasicMath( public static void int a = 1 + 1;
int = a*3;
main(Argomenti di stringa) (
int c = b / 4;
int d \u003d 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);
} }
Quando esegui 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 dopo aver diviso il primo operando per il secondo. A differenza di C++, la funzione mod di Java funziona non solo con numeri interi, ma anche con tipi reali. Il programma seguente illustra il funzionamento di questo operatore.
classModulus(
vuoto statico pubblico principale (Stringargs ) {
int x = 42;
doppia y = 42,3;
System.out.println("x mod 10 = " + x % 10);
System.out.println("y mod 10 = " + y % 10);
} }
Quando esegui questo programma, otterrai il seguente risultato:
C:\>Modulo
x mod 10 = 2
y mod 10 = 2.3
Operatori di assegnazione aritmetica
Per ciascuno di operatori aritmetici esiste una forma in cui un incarico viene eseguito contemporaneamente a una determinata operazione. Quello che segue è un esempio che illustra l'uso di questo tipo di operatore.
classe OpEquals(
int a = 1;
int b = 2;
int 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 decremento
Ci sono 2 operatori in C, chiamati operatori di incremento e decremento (++ e --), che sono un'abbreviazione per aggiungere o sottrarre uno da un operando. Questi operatori sono unici in quanto possono essere utilizzati in forma di prefisso o suffisso. L'esempio seguente illustra l'utilizzo degli operatori di incremento e decremento.
classe IncDec(
public static void main(String args) (
int a = 1;
int 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à:
C:\java IncDec
a = 2
b = 3
c=4
d=1
Operatori di bit interi
Per i tipi di dati numerici interi - long, int, short, char e byte, è definito insieme aggiuntivo operatori, con i quali è 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 funzionano con ciascun bit come se fosse un valore indipendente.
|
Operatore |
Risultato |
Operatore |
Risultato |
|
negazione unaria bit per bit (NON) |
|||
|
bit a bit AND (E) |
bit per bit AND (AND) con assegnazione |
||
|
bit per bit OR (OR) |
bit per bit OR (OR) con assegnazione |
||
|
bit per bit OR esclusivo (XOR) |
bit per bit OR esclusivo (XOR) con assegnazione |
||
|
spostamento a destra |
turno di destra con incarico |
||
|
sposta a destra con zero padding |
spostamento a destra con riempimento zero con assegnazione |
||
|
sposta a sinistra |
sposta a sinistra con incarico |
Un esempio di programma che manipola i bit
La tabella seguente mostra come ciascuno degli operatori aritmetici bit per bit influisce sulle possibili combinazioni di bit dei suoi 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) (
Binario stringa = ( "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 = un | b;
int d = a&b;
int e = a^b;
int f = (~a & b) | (a & ~b);
int g = ~a & 0x0f;
System.out.println(" a = " + binary[a]);
System.out.println(" b = " + binario[b]);
System.out.println(" ab = " + binary[c]);
System.out.println(" a&b = " + binary[d]);
System.out.println(" a^b = " + binario[e]);
System.out.println("~a&b|a^~b = " + binario[f]);
System.out.println("~a = " + binario[g]);
} }
Di seguito il risultato ottenuto eseguendo questo programma:
C:\>Java BitLogic
a = 0011
b=0110
un | b=0111
a&b=0010
a^b=0101
~a&b | a&~b=0101
~a = 1100
Sposta a destra e a sinistra
Operatore<< выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями. В предыдущей главе уже говорилось об автоматическом повышении типа всего выражения до int в том случае если в выражении присутствуют операнды digita int o tipi interi più piccoli. Se almeno uno degli operandi nell'espressione è di tipo long, il tipo dell'intera espressione viene promosso a 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 spinti oltre la posizione della parola più a destra, vengono persi. Quando si passa a destra, i bit senior (sinistra) rilasciati del numero spostato vengono riempiti con il contenuto precedente del bit del segno. Questo comportamento è chiamato espansione del bit di segno.
Il programma seguente converte un valore di byte in una stringa contenente la sua rappresentazione esadecimale. Si noti che il valore spostato deve essere mascherato, cioè moltiplicato logicamente per il valore 0 x0 f, in modo da azzerare i bit riempiti a seguito dell'espansione del segno e abbassare il valore fino ai limiti consentiti durante l'indicizzazione di un array 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" + hex[(b >> 4) & 0x0f] + hex);
} }
Di seguito è riportato l'output di questo programma:
C:\>java HexByte
b = 0xf1
Cambio a destra non firmato
Spesso è necessario che quando si passa a destra, non si verifichi l'espansione del bit del segno e che i bit sinistri vuoti vengano semplicemente riempiti 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" + hex(b >> 4) & 0x0f] + hex);
System.out.println(" b >> 4 =0x" + hex[(c >> 4) & 0x0f] + hex);
System.out.println("b >>> 4 = 0x" + hex[(d >> 4) & 0x0f] + hex);
System.out.println(“(b & 0xff) >> 4 = 0x" + hex[(e >> 4) & 0x0f] + hex);
} }
Per questo esempio, la variabile b potrebbe essere inizializzata con un numero negativo arbitrario, abbiamo usato un numero con una rappresentazione esadecimale di 0xf1. Alla variabile c viene assegnato il risultato di uno spostamento con segno b a destra di 4 bit. Come previsto, l'espansione del bit di segno fa sì che 0xf1 diventi 0xff. Quindi il risultato di uno spostamento b senza segno a destra di 4 bit viene inserito nella variabile d. Ci si aspetterebbe che d contenga 0x0f, ma in realtà otteniamo di nuovo 0xff. Questo è il risultato dell'espansione del bit di segno eseguita quando b è stato automaticamente promosso 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ò, abbiamo dovuto moltiplicare logicamente il valore della variabile b per la maschera 0xff prima di spostarci a destra, cancellando così i bit di ordine superiore riempiti durante la promozione automatica del tipo. Si noti che non è più necessario utilizzare uno spostamento a destra senza segno, poiché conosciamo lo stato del bit del segno dopo l'operazione AND.
C:\>java ByteUShift
b = 0xf1
b >> 4 = 0xff
b >>> 4 = 0x segg
b & 0xff) >> 4 = 0x0f
Operatori di assegnazione bit per bit
Proprio come nel caso degli operatori aritmetici, tutti gli operatori binari bit per bit hanno una relativa maschera che consente di assegnare automaticamente il risultato dell'operazione all'operando di sinistra. L'esempio seguente crea diverse variabili intere ed esegue varie operazioni su di esse utilizzando gli operatori precedenti.
classe BitEquals(
public static void main(String args) (
int a = 1;
int b = 2;
int c = 3;
a |= 4;
b >>= 1;
Insieme a<<= 1;
un ^= 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 dispone di 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, caratteri, booleani e riferimenti, possono essere confrontati utilizzando l'operatore di uguaglianza == e l'operatore disuguaglianza!=. Si noti che in Java, così come in C e C++, il controllo dell'uguaglianza è indicato dalla sequenza (==). Un singolo segno (=) è un operatore di assegnazione.
Operatori logici booleani
Gli operatori logici booleani, riepilogati nella tabella seguente, operano solo su operandi di tipo booleano. Tutti gli operatori logici binari prendono due valori booleani come operandi e restituiscono un risultato dello stesso tipo.
|
Operatore |
Risultato |
Operatore |
Risultato |
|
logico AND (AND) |
AND (AND) con incarico |
||
|
OR logico (OR) |
OR (OR) con assegnazione |
||
|
OR logico esclusivo (XOR) |
OR esclusivo (XOR) con assegnazione |
||
|
Operatore OR per una rapida valutazione delle espressioni ( corto circuito O) |
|||
|
Operatore AND per la valutazione rapida delle espressioni (AND di cortocircuito) |
|||
|
negazione unaria logica (NON) |
operatore ternario se-allora-altro |
I risultati dell'azione degli operatori logici su varie combinazioni di 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 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=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 stima rapida espressioni booleane(operatori logici di corto circuito)
Ci sono due interessanti aggiunte all'insieme degli operatori logici. 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, indipendentemente dal valore del secondo operando, il risultato dell'operazione è vero. 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 destro di un'espressione booleana se la risposta è chiara dal valore dell'operando sinistro. La pratica comune consiste nell'usare && e || in quasi tutti i casi, valutazione di espressioni logiche booleane. Versioni di questi operatori & e | si applica solo all'aritmetica bit per bit.
Operatore ternario if-then-else
La forma generale dell'istruzione if-then-use è:
espressione1? espressione2: espressione3
Come primo operando - "espressione1" - è possibile utilizzare qualsiasi espressione il cui risultato è un valore booleano. Se il risultato è vero, viene eseguita l'istruzione data dal secondo operando, cioè "espressione2". Se il primo operando è falso, viene eseguito il terzo operando - "espressione3". Il secondo e il terzo operando, ovvero expression2 ed expression3, devono restituire valori dello stesso tipo e non devono essere di tipo void.
Il programma seguente utilizza questo operatore per controllare il divisore prima di eseguire l'operazione di divisione. Nel caso di un divisore zero, viene restituito il valore 0.
classe Ternario(
public static void main(String args) (
int a = 42;
int b = 2;
int c = 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 genera un'eccezione di divisione per zero e produce i seguenti risultati:
C:\>java ternario
a = 42
b = 2
c = 99
d=0
a/b=21
c/d= 0
Precedenza dell'operatore
Java ha un ordine specifico, o una precedenza, delle operazioni. Nell'algebra elementare, ci è stato insegnato che la moltiplicazione e la divisione hanno una precedenza maggiore rispetto all'addizione e alla sottrazione. Nella programmazione, devi anche tenere traccia delle priorità delle operazioni. La tabella elenca, in ordine decrescente, la precedenza di tutte le operazioni del linguaggio Java.
La prima riga della tabella contiene tre operatori insoliti che non abbiamo ancora discusso. Le parentesi () vengono utilizzate per impostare esplicitamente la precedenza. Come hai appreso nel capitolo precedente, le parentesi quadre vengono utilizzate per indicizzare una variabile di matrice. 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 priorità più alta è parentesi tonde, puoi sempre aggiungere più coppie di parentesi a un'espressione se hai dubbi sull'ordine di valutazione o vuoi semplicemente rendere più leggibile il tuo codice.
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 è necessario eseguire un'operazione (a>>b )+ 3 le parentesi sono indispensabili.
Quindi, abbiamo considerato tutti i tipi di operatori del linguaggio Java. Ora puoi costruire qualsiasi espressione Insieme a vari tipi dati. Nel prossimo capitolo impareremo i costrutti ramificati, i cicli e come controllare l'esecuzione del programma.
Gli operatori logici funzionano solo con operandi di tipo booleano. Tutti gli operatori logici con due operandi combinano due valori logici per formare il valore logico risultante. Non confondere con .
Tabella degli operatori logici in Java
Operatori logici & , | , ^ operare su valori di tipo booleano allo stesso modo per quanto riguarda bit di valori interi. Operatore booleano ! inverte (inverte) uno stato booleano: !vero == falso e !falso == vero.
Tavolo. Risultati dell'esecuzione di operatori logici
| UN | B | A | B | A&B | A^B | !UN |
|---|---|---|---|---|---|
| falso | falso | falso | falso | falso | VERO |
| VERO | falso | VERO | falso | VERO | falso |
| falso | VERO | VERO | falso | VERO | VERO |
| VERO | VERO | VERO | VERO | falso | falso |
Collegamento Operatori booleani
Oltre agli operatori standard E (&) e OPPURE (|) ci sono scorciatoie && e || .
Se guardi la tabella, puoi vedere che il risultato dell'esecuzione dell'operatore Oè uguale a VERO VERO, indipendentemente dal valore dell'operando B. Allo stesso modo, il risultato dell'esecuzione dell'operatore Eè uguale a falso quando il valore dell'operando A è falso, indipendentemente dal valore dell'operando B. Risulta che non è necessario calcolare il valore del secondo operando se il risultato può essere già determinato dal primo operando. Ciò diventa conveniente nei casi in cui il valore dell'operando di destra dipende dal valore di sinistra.
Ritenere prossimo esempio. Supponiamo di aver introdotto una regola: nutrire o meno il gatto, a seconda del numero di topi catturati a settimana. Inoltre, il numero di topi dipende dal peso del gatto. Più grande è il gatto, più topi deve catturare.
Il gatto, che ha letto le condizioni del problema, è stato da me offeso. Ha detto che ero indietro con i tempi e nel cortile del 21° secolo - i topi possono essere catturati con trappole per topi. Ho dovuto spiegargli che questo è solo un problema e non un esempio della sua vita personale.
topo; // numero di topi int peso; // peso del gatto in grammi topo = 5; peso = 4500; se (mouse != 0 & peso / mouse< 1000) { mInfoTextView.setText("Можно кормить кота"); }
Se esegui il programma, l'esempio funzionerà senza problemi: cinque topi a settimana sono sufficienti per offrire al gatto una deliziosa colazione. Se cattura quattro topi, i problemi inizieranno con l'alimentazione del gatto, ma non con il programma: funzionerà, semplicemente non visualizzerà un messaggio sul permesso di nutrire il parassita.
Ora prendiamo un caso estremo. Il gatto è diventato pigro e non ha catturato un solo topo. Valore variabile topo sarà uguale a 0 e nell'espressione è presente un operatore di divisione. Ma non puoi dividere per 0 e il nostro programma si chiuderà con un errore. Sembrerebbe che abbiamo fornito l'opzione con 0, ma Java valuta entrambe le espressioni mouse!= 0 e peso/topo< 1000 , nonostante il fatto che già nella prima espressione ritorni falso.
Riscriviamo la condizione come segue (aggiungiamo un solo carattere):
Se (mouse != 0 && peso / mouse< 1000) { mInfoTextView.setText("Можно кормить кота"); }
Ora il programma viene eseguito senza arresti anomali. Una volta che Java ha visto che la prima espressione è tornata falso, l'espressione della seconda divisione viene semplicemente ignorata.
Operatori abbreviati E e O comunemente usato in situazioni in cui sono richiesti operatori logica booleana e i relativi parenti di un carattere vengono utilizzati per le operazioni bit per bit.
Operatore ternario
Il linguaggio Java ha anche un ternario speciale operatore condizionale, che può sostituire alcuni tipi operatori se-allora-altroè un operatore ?:
L'operatore ternario utilizza tre operandi. L'espressione si scrive nella forma seguente:
Condizione booleana? espressione1: espressione2
Se una booleanaCondizioneè uguale a VERO, quindi viene calcolato espressione1 e il suo risultato diventa il risultato dell'esecuzione dell'intera istruzione. Se booleanaCondizioneè uguale a falso, quindi viene calcolato espressione2 e il suo valore diventa il risultato dell'operatore. Entrambi gli operandi espressione1 e espressione2 deve restituire un valore dello stesso tipo (o compatibile).
Consideriamo un esempio in cui la variabile ass assegnare un valore assoluto a una variabile val.
int absval, val; val = 5; absval = val< 0 ? -val: val; // выводим число mInfoTextView.setText("" + absval); val = -5; absval = val < 0 ? -val: val; mInfoTextView.setText("" + absval);
variabile ass verrà assegnato il valore della variabile val se il valore è maggiore o uguale a zero (la seconda parte dell'espressione). Se il valore della variabile val è negativo, quindi la variabile ass il valore della variabile viene assegnato, preso con un segno meno, di conseguenza, meno volte meno darà un più, cioè un valore positivo. Riscriviamo il codice usando se altro:
Se (val< 0) absval = -val; else absval = val;
Puoi vedere un altro esempio con un operatore ternario.
La maggior parte delle operazioni su tipi primitivi non si fa con i metodi, ma con personaggi speciali chiamato segno di operazione.
operazione di assegnazione
Incarico valore variabile costante, viene chiamata un'altra variabile o espressione (variabili e/o costanti separate da segni di operatore). operazione di assegnazione ed è contrassegnato con " = ", ad esempio: x = 3 ; y = x; z = x; In Java, è possibile utilizzare l'operatore di assegnazione più volte in un'espressione, ad esempio: x1 = x2 = x3 = 0 ; Questa operazione viene eseguita da da destra a sinistra, ovvero alla prima variabile x3 viene assegnato il valore 0 , quindi a x2 viene assegnato il valore di x3 (0) e infine a x1 viene assegnato il valore di x2 (0) I segni delle operazioni i cui argomenti sono numeri rientrano in due categorie : unario Segni di operazione (unari) con un argomento e binario(binario) con due argomenti.Operazioni unarie
Java definisce le seguenti operazioni unarie:- unario meno "-" - cambia il segno di un numero o di un'espressione nell'opposto;
- unary plus " + " - non esegue alcuna operazione su un numero o un'espressione;
- complemento bit per 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;
- decrement " -- " (solo per numeri interi) - decrementa il valore della variabile di 1.
Operazioni binarie aritmetiche
Java definisce quanto segue operazioni binarie aritmetiche:- aggiunta "+";
- sottrazione "-";
- moltiplicazione " * ";
- divisione "/";
- calcolo del resto della divisione di 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à uguale a -3 . A Operazione Java può essere utilizzato anche per variabili reali (digitare float o double).
Operazioni bit a bit
- Le operazioni bit per bit considerano l'originale valori numerici come campi di bit ed eseguire le seguenti azioni su di essi:
- impostando il ritmo su io-la posizione del campo del risultato è 1 se entrambi i bit sono inseriti io-esima posizione degli operandi è uguale a 1 , oppure a 0 altrimenti AND bit per bit (" & ");
- impostando il ritmo su io-la posizione del campo del risultato è 1 se è presente almeno un bit io-esima posizione degli operandi è 1 , altrimenti 0 - OR bit per bit (" | ");
- impostando il ritmo su io-esima posizione del campo del risultato è 1 se i bit entrano io-le posizioni degli operandi non sono uguali tra loro, o altrimenti a 0 - OR bit per bit (" ^ ");
- spostamento a sinistra dei bit di campo del primo operando del numero di bit determinato dal secondo operando (in questo caso il bit di segno del numero non cambia) - spostamento a sinistra bit per bit, tenendo conto del segno "<< ";
- spostamento a destra dei bit del campo del primo operando del numero di bit determinato dal secondo operando (in questo caso il bit di segno del numero non cambia) – spostamento a destra bit per bit, tenendo conto del segno " >> ";
- sposta a destra dei bit di campo del primo operando il numero di bit determinati dal secondo operando (in questo caso viene spostato anche il bit di segno del numero) - sposta a destra bit per bit senza tener conto di ">> >" segno.
bit a bit E
int x = 112 ; int y = 94 ; intz; z=x & y; // z=80: 00000000 00000000 00000000 01010000OR bit a bit
int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 intz; z=x | si; // z = 126: 00000000 00000000 00000000 01111110XOR bit a bit
int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 intz; z=x^y; // z = 46: 00000000 00000000 00000000 00101110Spostamento a sinistra con segno
int x = 31 , z; // x: 00000000 00000000 00000000 00011111 z=x<< 2 ; // z = 124: 00000000 00000000 00000000 01111100Cambio a destra con segno
int x = - 17 , z; z = x >> 2 ; // z = -5: 11111111 11111111 11111111 11111011Spostati a destra senza 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 Segni di operazione (composti): identificatore di operazione = espressione Equivale alla seguente operazione: identificatore = espressione di identificatore di operazione 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 a),
- " < " (меньше) " <= " (меньше или равно)
operazioni booleane
operazioni booleane vengono eseguiti su variabili booleane e anche il loro risultato è un valore di tipo booleano. Java definisce le seguenti operazioni booleane:- negazione "!" – sostituendo false con true o viceversa;
- operatore 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.
- Operatore XOR "^" - il risultato è vero solo se gli operandi non sono uguali tra loro, altrimenti il risultato è false .
Operazione condizionale
L'operatore condizionale è scritto nella forma expression-1?expression-2:expression-3 . Questo prima valuta expression-1 , che dovrebbe restituire un valore booleano, quindi, se expression-1 è true , valuta e restituisce expression-2 come risultato dell'operazione oppure (se expression-1 restituisce false), valuta 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 (l'espressione n>1 restituisce true) o 1 se n≤1 (l'espressione n>1 restituisce false).Precedenza dell'operazione
Le operazioni nelle espressioni vengono eseguite da sinistra a destra, tuttavia, in base alla loro precedenza. Quindi le operazioni di moltiplicazione nell'espressione y = x + z* 5 ; verrà eseguito prima dell'operazione di addizione perché l'operazione di moltiplicazione ha una priorità maggiore rispetto all'operazione di addizione. Le priorità delle operazioni (in ordine decrescente di priorità) in Java sono riportate nella tabella. uno.
Le parentesi aumentano la precedenza delle operazioni che sono 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 utilizzate semplicemente per rendere più leggibile un'espressione, ad esempio: (x > 1 ) && (x<=
5
)
;
Conversione del tipo e casting durante l'esecuzione delle operazioni
Le operazioni di assegnazione e le espressioni aritmetiche possono utilizzare valori letterali, variabili ed espressioni di tipo diverso, ad esempio: double y; byte; y = x + 5 ; Questo esempio aggiunge la variabile byte x e il letterale 5 (tipo int) e assegna il risultato alla variabile doppia y. In Java, come nel linguaggio C, le conversioni di tipo nella valutazione delle espressioni possono essere eseguite automaticamente o con l'ausilio di un operatore di type casting. Tuttavia, le regole per il casting sono leggermente diverse da quelle in C e in generale sono più restrittive rispetto a C. Quando si esegue un'operazione di assegnazione, la conversione del tipo avviene automaticamente se trasformazione allargata(ampliamento della conversione) e due tipi sono compatibili. Le trasformazioni allargate sono le trasformazioni byte® breve® int® lungo® galleggiante® Doppio. Per ampliare le conversioni, i tipi numerici, inclusi interi e virgola mobile, sono compatibili tra loro. Tuttavia, i tipi numerici non sono compatibili con i tipi char e booleani. Anche i tipi char e boolean non sono compatibili tra loro. Il linguaggio Java esegue anche la conversione automatica del tipo durante la memorizzazione di una costante intera letterale (che ha il tipo int per impostazione predefinita) in variabili di tipo byte , short o long (tuttavia, se il valore letterale ha un valore al di fuori dell'intervallo di valori validi per quel tipo, viene lanciato un messaggio di errore: possibile perdita di precisione). Se la conversione è restringente (narrowing conversion), cioè la conversione è byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ double , allora tale conversione può portare alla perdita di precisione del numero o alla sua distorsione. Pertanto, il restringimento delle conversioni genera una diagnostica di incompatibilità di tipo quando il programma viene compilato e i file di classe non vengono generati. Tale messaggio verrà emesso anche quando si tenta di convertire espressioni di tipo byte o short in una variabile di tipo char . Se è ancora necessario eseguire tali conversioni, utilizzare l'operazione di cast, che ha il seguente formato: ( tipo di conversione) significato, dove tipo di conversione definisce il tipo in cui deve essere convertito il dato significato, ad esempio, come risultato dell'esecuzione di istruzioni: byte x = 71 ; simbolo char = (char ) x; la variabile simbolo sarà impostata su " G ". Se un valore in virgola mobile è assegnato a un tipo intero, allora (se il valore in virgola mobile ha una parte frazionaria) si verifica anche la conversione esplicita del tipo troncamento(troncamento) numeri. Quindi, come risultato dell'esecuzione dell'operatore int x = (int ) 77.85 ; la variabile x otterrà il valore 77 . Se il valore assegnato è al di fuori dell'intervallo tipo-conversione , 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 per lungo tempo - 18446744073709551616). Ad esempio, come risultato dell'esecuzione dell'istruzione byte x = (byte ) 514 ; la variabile x otterrà il valore 2 . Quando si convertono numeri interi o numeri a virgola mobile in char , la conversione in un carattere avviene se il numero originale è compreso tra 0 e 127, altrimenti il carattere è impostato su " ?". Quando si eseguono conversioni aritmetiche e bit per bit, tutti i valori byte e short, oltre a 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 di risultato è double. Quindi, se le variabili byte a, c; b breve; quindi nell'espressione a + b * c - 15 L + 1.5F + 1.08 - 10; prima, prima di valutare a + b*c , i valori delle variabili verranno espansi a int , quindi, poiché la costante 15 è di tipo long , il risultato del calcolo verrà espanso a long prima di sottrarre. Dopodiché, poiché il letterale 1.5 è di tipo float , il risultato della valutazione di a + b*c - 15L verrà espanso in float prima di essere aggiunto a questo valore letterale. Prima di eseguire l'addizione con il numero 1.08, il risultato dei calcoli precedenti verrà ampliato al doppio (poiché le costanti reali sono doppie per impostazione predefinita) e infine, prima che venga eseguita l'ultima addizione, il letterale 10 (int per impostazione predefinita) sarà ampliato per raddoppiare. Pertanto, il risultato della valutazione dell'espressione sarà di tipo double . Le espansioni automatiche dei tipi (soprattutto le espansioni di short e byte to int) possono causare errori in fase di compilazione poco riconoscibili. Ad esempio, nelle istruzioni: byte x = 30 , y = 5 ; x = x + y; il valore di xey verrà espanso a int prima che venga eseguita l'aggiunta, quindi verrà generato un errore quando si tenta di assegnare il risultato di un calcolo int a una variabile di byte. Per evitare ciò, è necessario utilizzare la conversione esplicita del tipo nel secondo operatore: x = (byte ) (x + y) ; L'espressione x + y deve essere racchiusa tra parentesi perché la precedenza dell'operazione di cast tra parentesi è maggiore della precedenza dell'operatore di addizione. A proposito, se scriviamo il secondo operatore come: x += y; quindi non ci sarà alcun messaggio di errore. Collegati al primo1. Operazioni aritmetiche di base
La tabella seguente elenca le operazioni aritmetiche di base utilizzate nel linguaggio Java:
Considera alcune regole per lavorare con le operazioni aritmetiche:
- Le espressioni vengono valutate da sinistra a destra a meno che non vengano aggiunte parentesi o alcuni operatori abbiano una precedenza maggiore.
- Gli operatori *, / e % hanno la precedenza su + e -.
Esempio 1. Operazioni aritmetiche su valori interi
Ad esempio, in questo codice, le variabili un e b avrà diversi significati:
Classe pubblica BasicIntMath ( public static void main(String args) ( int a = 4 + 5 - 2 * 3; int b = 4 + (5 - 2) * 3; System.out.println("a = " + a) ; System.out.println("b = " + b); ) )
Risultato dell'esecuzione:
A = 3 b = 13
- L'operazione di sottrazione unaria cambia il segno del suo singolo operando.
- L'operatore di addizione unario restituisce semplicemente il valore del suo operando. In linea di principio, non è necessario, ma possibile.
Esempio 2. Operazioni unarie di addizione e sottrazione
public class UnarySignOperation ( public static void main(String args) ( double a = -6; double b = +6; System.out.println(a); System.out.println(b); ) )- Quando un'operazione di divisione viene eseguita su un tipo di dati intero, il suo risultato non conterrà una componente frazionaria.
Esempio 3. Divisione di interi
public class IntDivision ( public static void main(String args) ( int a = 16 / 5; System.out.println(a); ) )Il risultato dell'esecuzione di questo programma:
- Gli operandi aritmetici devono essere di tipo numerico. Le operazioni aritmetiche non possono essere eseguite sui tipi di dati booleani, ma sono consentite sui tipi di dati car, perché in Java questo tipo è essenzialmente un tipo di tipo int.
Esempio 4. Operazioni aritmetiche su variabili di tipo car
public class BasicCharMath1 ( public static void main(String args) ( char c = "n"; System.out.println(c); System.out.println(c + 1); System.out.println(c / 5) ; ) )Risultato dell'esecuzione:
N 111 22
Esempio 5. Operazioni aritmetiche su variabili di tipo car
public class BasicCharMath2 ( public static void main(String args) ( char c1 = "1"; char c2 = "\u0031"; char c3 = 49; System.out.println(c1 + c2 + c3); ) )Risultato dell'esecuzione:
L'operatore modulo è indicato dal simbolo %. Questo operatore restituisce il resto dopo aver diviso il primo numero per il secondo. Quando si divide un intero, anche il risultato è un intero.
Esempio 6. Divisione modulo
public class DivisionByModule ( public static void main(String args) ( int a = 6 % 5; double b = 6.2 % 5.0; System.out.println(a); System.out.println(b); ) )Risultato dell'esecuzione:
1 1.2000000000000002
2. Operazioni aritmetiche composte con assegnazione
Java ha operatori speciali che combinano l'aritmetica con l'assegnazione. Considera la seguente espressione:
A = a + 4;
In Java, questa operazione può essere scritta come segue:
UN += 4;
Le operazioni di assegnazione composta consentono non solo di ridurre la quantità di codice, ma consentono anche di eseguire conversioni automatiche che le normali operazioni non fanno.
