Operatori logici. Operazioni aritmetiche

Gli operatori logici funzionano solo con operandi come booleano... Tutti gli operatori booleani con due operandi combinano due valori booleani per formare il valore booleano risultante. Non confondere con.

Tabella degli operatori booleani in Java

Operatori logici & , | , ^ applicare ai valori di tipo booleano esattamente lo stesso che per quanto riguarda bit di valori interi. Operatore logico ! inverte (inverte) lo stato booleano: !vero == falso e !falso == vero.

Tavolo. Risultati dell'operatore logico

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

Operatori booleani abbreviati

Oltre agli operatori standard E (&) e OPPURE (|) ci sono operatori stenografici && 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. Analogamente, il risultato dell'esecuzione dell'operatore Eè uguale a falso quando il valore dell'operando A è falso, indipendentemente dal valore dell'operando B. Si scopre che non è necessario calcolare il valore del secondo operando, se il risultato può essere già determinato dal primo operando. Ciò diventa utile nei casi in cui il valore dell'operando di destra dipende dal valore di quello di sinistra.

Considera il seguente esempio. Diciamo che abbiamo introdotto una regola: nutrire o non nutrire 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ù deve catturare i topi.

Il gatto, che ha letto le condizioni del problema, si è offeso da me. Ha detto che ero al passo con i tempi, e nel cortile del 21 ° secolo - i topi possono essere catturati con l'aiuto di trappole per topi. Ho dovuto spiegargli che questo è solo un compito e non un esempio della mia vita personale.

mouse interno; // numero di topi int peso; // il peso del gatto in grammi topo = 5; peso = 4500; if (mouse! = 0 & peso / mouse< 1000) { mInfoTextView.setText("Можно кормить кота"); }

Se esegui il programma, l'esempio funzionerà senza problemi: cinque topi a settimana sono sufficienti per coccolare il tuo gatto con una deliziosa colazione. Se cattura quattro topi, inizieranno i problemi 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 limite. 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. E non puoi dividere per 0 e il nostro programma si chiuderà con un errore. Sembrerebbe che abbiamo fornito un'opzione con 0, ma Java valuta entrambe le espressioni topo! = 0 e peso/topo< 1000 , nonostante il fatto che già nella prima espressione ritorni falso.

Riscriviamo la condizione come segue (aggiungiamo solo un simbolo):

If (mouse! = 0 && peso / mouse< 1000) { mInfoTextView.setText("Можно кормить кота"); }

Il programma ora funziona senza crash. Una volta che Java ha visto che la prima espressione stava tornando falso, quindi l'espressione della seconda divisione viene semplicemente ignorata.

Varianti abbreviate dell'operatore E e O solitamente utilizzato in situazioni in cui sono richiesti operatori booleani e i loro cugini a un carattere vengono utilizzati per operazioni bit per bit.

Operatore ternario

Il linguaggio Java ha anche uno speciale operatore condizionale ternario che può sostituire alcuni tipi di operatori. se-allora-altrimentiè l'operatore ?:

L'operatore ternario utilizza tre operandi. L'espressione si scrive nella forma seguente:

Condizione logica? espressione1: espressione2

Se condizione logica equivale vero, quindi si calcola espressione1 e il suo risultato diventa il risultato dell'esecuzione dell'intera istruzione. Se condizione logica equivale falso, quindi si calcola espressione2, e il suo valore diventa il risultato del lavoro dell'operatore. Entrambi gli operandi espressione1 e espressione2 deve restituire un valore dello stesso tipo (o compatibile).

Consideriamo un esempio in cui la variabile absval viene assegnato il valore assoluto della variabile valore.

Int absval, val; val = 5; absval = val< 0 ? -val: val; // выводим число mInfoTextView.setText("" + absval); val = -5; absval = val < 0 ? -val: val; mInfoTextView.setText("" + absval);

Variabile absval verrà assegnato il valore della variabile valore se il valore è maggiore o uguale a zero (seconda parte dell'espressione). Se il valore della variabile val è negativo, quindi la variabile absval viene assegnato il valore della variabile, preso con un segno meno, di conseguenza, meno per meno darà un più, cioè un valore positivo. Riscriviamo il codice usando se altro:

Se (val< 0) absval = -val; else absval = val;

Puoi guardare un altro esempio con l'operatore ternario.

La maggior parte delle operazioni sui tipi primitivi viene eseguita non utilizzando metodi, ma utilizzando caratteri speciali chiamati segno di operazione.

Operazione di assegnazione

Assegnando ad una variabile il valore di una costante, di un'altra variabile, o di un'espressione (variabili e/o costanti separate da segni di operazione) si chiama 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.

Esempi di operazioni unarie "+" e "-": int i = 3, j, k; j = - io; //j = -3 k = + io; // k = 3 Un esempio di operazione di complemento bit a bit: int a = 15; int b; b = ~ a; // b = -16 I numeri a e b sono int, cioè sono rappresentati internamente come interi con segno binario con una lunghezza di 32 bit, quindi la rappresentazione binaria dei numeri a e b sarà simile a questa: a = 00000000 00000000 00000000 00001111 b = 11111111 11111111 11111111 11110000 Come puoi vedere da questa rappresentazione, tutti zero bit nel numero a sono stati cambiati quelli in b, e quelli in a sono cambiati a zero bit. La rappresentazione decimale di b è –16. I segni delle operazioni di incremento e decremento possono essere posti prima o dopo la variabile. Queste opzioni sono denominate di conseguenza prefisso e suffisso registrando queste operazioni. Il segno dell'operatore nella notazione del prefisso restituisce il valore del suo operando dopo valutare un'espressione Per la notazione postfissa, il segno di operazione primo restituisce il valore del suo operando e solo dopo calcola l'incremento o il decremento, ad esempio: int x = 1, y, z; y = ++ x; z = x++; Alla variabile y verrà assegnato il valore 2, perché prima il valore di x verrà incrementato di 1, quindi il risultato verrà assegnato alla variabile y. Alla variabile z verrà assegnato il valore 1, perché prima verrà assegnato un valore alla variabile z, quindi il valore di x verrà incrementato di 1. In entrambi i casi, il nuovo valore di x sarà 2. Da notare che in Java, a differenza del C, le operazioni di decremento e incremento possono essere applicate anche a variabili reali (di tipo float e double). Segni di operazione binaria si suddividono in operazioni con risultato numerico e operazioni di confronto il cui risultato è un valore booleano.

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. In Java, l'operazione può essere utilizzata anche per variabili reali (come float o double).

Esempi di operazioni aritmetiche binarie: int x = 7, x1, x2, x3, x4, x5; x1 = x + 10; // x1 = 17 x2 = x - 8; // x2 = -1 x3 = x2 * x; // x3 = -7 x4 = x / 4; // x4 = 1 (quando si dividono interi // la parte frazionaria viene scartata) x5 = x% 4 // x5 = 3 (resto della divisione// 7 per 4)

Operazioni bit a bit

• Le operazioni bit a bit trattano i valori numerici originali come campi di bit e su di essi effettuano le seguenti operazioni:
• 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.

Esempi di operazioni bit a bit:

1. AND . bit a bit

   intero x = 112; int y = 94; int z; z = x & y; //z = 80: 00000000 00000000 00000000 01010000

2. OR 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 01111110

3. OR 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 00101110

4. Spostati a sinistra, tenendo conto del segno

   int x = 31, z; // x: 00000000 00000000 00000000 00011111 z = x<< 2 ; //z = 124: 00000000 00000000 00000000 01111100

5. Spostati a destra, tenendo conto del segno

   int x = - 17, z; z = x >> 2; //z = -5: 11111111 11111111 11111111 11111011

6. Sposta 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:

1. L'espressione x + = b significa x = x + b.
2. L'espressione x - = b significa x = x - b.
3. L'espressione x * = b significa x = x * b.
4. L'espressione x / = b significa x = x / b.
5. L'espressione x% = b significa x = x% b.
6. L'espressione x & = b significa x = x & b.
7. L'espressione x | = b significa x = x | B.
8. L'espressione x ^ = b significa x = x ^ b.
9. Espressione x<<= b означает x = x << b .
10. L'espressione x >> = b significa x = x >> b.
11. 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),
• " < " (меньше) " <= " (меньше или равно)

hanno due operandi e restituiscono un valore booleano corrispondente al risultato del confronto ( falso o vero). Nota che quando si confrontano due valori per l'uguaglianza in Java, come in C e C ++, i simboli " == "(due segni di uguale senza spazio), in contrasto con l'operatore di assegnazione, che utilizza il" = ". L'utilizzo del simbolo" = "quando si confrontano due valori provoca un errore di compilazione o produce un risultato errato. Esempi di operazioni di confronto: booleano isEqual, isNonEqual, isGreater, isGreaterOrEqual, isLess, isLessOrEqual; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; èuguale = x1 == x2; // isEqual = true isNonEqual = x1! = x2; // isNonEqual = false isGreater = x1> x3; // isGreater = true // isGreaterOrEqual = true isGreaterOrEqual = x2> = x3; è minore = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

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.

Gli operatori "&", "|" e "^", così come i corrispondenti operatori bit per bit, possono essere utilizzati negli operatori di assegnazione composti: "& =", "| =" e "^ =" Inoltre, le operazioni " = sono applicabili agli operandi booleani. = "(uguale) e"! = "(non uguale). Come puoi vedere dalla definizione di OR e AND, l'operazione OR restituisce true quando il primo operando è vero, indipendentemente dal valore del secondo operando, e l'operatore AND restituisce false quando il primo operando è falso, indipendentemente da il valore del secondo operando. Java definisce altre due operazioni booleane: le seconde versioni dell'AND booleano e dell'OR, note come operazioni logiche di cortocircuito: l'AND abbreviato "&&" e l'OR abbreviato "||". Quando si utilizzano queste operazioni, il secondo operando non verrà affatto valutato, il che è utile nei casi in cui l'operazione corretta dell'operando destro dipende dal fatto che l'operando sinistro sia vero o falso. Esempi di operazioni booleane: booleano isInRange, isValid, isNotValid, isEqual, isNotEqual; intero x = 8; isInRange = x> 0 && x< 5 ; // isInRange = false isValid = x >0 || x> 5; // isValid = true isNotValid =! è valido; // isNotValid = false isEqual = isInRange == isValid; // isEqual = false // isNotEqual = true isNotEqual = isInRange! = isValid

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 primo

Ultimo aggiornamento: 30.10.2018

La maggior parte delle operazioni in Java sono simili a quelle utilizzate in altri linguaggi di tipo C. Esistono operazioni unarie (eseguite su un operando), operazioni binarie su due operandi e operazioni ternarie su tre operandi. Un operando è una variabile o un valore (ad esempio un numero) coinvolto in un'operazione. Consideriamo tutti i tipi di operazioni.

Partecipano alle operazioni aritmetiche con i numeri. Java ha operazioni aritmetiche binarie (eseguite su due operandi) e unarie (eseguite su un operando). Le operazioni binarie includono quanto segue:

l'operazione di somma di due numeri:

Int a = 10; intero b = 7; int c = a + b; // 17 int d = 4 + b; // undici

operazione di sottrazione di due numeri:

Int a = 10; intero b = 7; int c = a - b; // 3 int d = 4 - a; // -6

l'operazione di moltiplicare due numeri

Int a = 10; intero b = 7; int c = a * b; // 70 int d = b * 5; // 35

operazione di divisione di due numeri:

Int a = 20; intero b = 5; int c = a / b; // 4 doppie d = 22,5/4,5; // 5,0

Vale la pena considerare durante la divisione, poiché se nell'operazione sono coinvolti due interi, il risultato della divisione verrà arrotondato a un numero intero, anche se il risultato è assegnato a una variabile float o double:

Doppio k = 10/4; // 2 System.out.println (k);

Affinché il risultato sia un numero in virgola mobile, uno degli operandi deve rappresentare anche un numero in virgola mobile:

Doppio k = 10,0 / 4; // 2.5 System.out.println (k);

ottenendo il resto dalla divisione di due numeri:

Int a = 33; intero b = 5; int c = a% b; // 3 int d = 22% 4; // 2 (22 - 4 * 5 = 2)

Esistono anche due operazioni aritmetiche unarie che vengono eseguite sullo stesso numero: ++ (incremento) e - (decremento). Ciascuna delle operazioni ha due tipi: prefisso e suffisso:

++ (incremento prefisso)

Suppone di aumentare la variabile di uno, ad esempio, z = ++ y (prima, il valore della variabile y viene aumentato di 1, quindi il suo valore viene assegnato alla variabile z)

Int a = 8; int b = ++ a; System.out.println (a); // 9 System.out.println (b); // 9

++ (incremento postfisso)

Rappresenta anche un aumento di una variabile di uno, ad esempio z = y ++ (prima il valore di y viene assegnato a z, quindi il valore di y viene aumentato di 1)

Int a = 8; int b = a++; System.out.println (a); // 9 System.out.println (b); // otto

- (decremento prefisso)

diminuendo la variabile di uno, ad esempio, z = - y (prima il valore della variabile y viene diminuito di 1, quindi il suo valore viene assegnato alla variabile z)

Int a = 8; int b = --a; System.out.println (a); // 7 System.out.println (b); // 7

- (decremento postfisso)

z = y-- (prima il valore della variabile y è assegnato alla variabile z, quindi il valore della variabile y è diminuito di 1)

Int a = 8; int b = a--; System.out.println (a); // 7 System.out.println (b); // otto

Priorità aritmetica

Alcune operazioni hanno la precedenza su altre e vengono quindi eseguite per prime. Operazioni in ordine di priorità decrescente:

++ (incremento), - (decremento)

* (moltiplicazione), / (divisione),% (resto della divisione)

+ (addizione), - (sottrazione)

La priorità delle operazioni dovrebbe essere presa in considerazione quando si esegue una serie di espressioni aritmetiche:

Int a = 8; intero b = 7; int c = a + 5 * ++ b; System.out.println (c); // 48

Innanzitutto, verrà eseguita l'operazione di incremento ++ b, che ha una priorità più alta: aumenterà il valore della variabile b e lo restituirà come risultato. Quindi viene eseguita la moltiplicazione 5 * ++ b e solo l'ultima addizione è a + 5 * ++ b

Le parentesi consentono di ridefinire l'ordine dei calcoli:

Int a = 8; intero b = 7; int c = (a + 5) * ++ b; System.out.println (c); //104

Nonostante il fatto che l'operazione di addizione abbia una priorità inferiore, verrà eseguita prima l'addizione e non la moltiplicazione, poiché l'operazione di addizione è racchiusa tra parentesi.

Associatività delle operazioni

Oltre alla priorità, le operazioni si distinguono per un concetto come associatività... Quando le operazioni hanno la stessa precedenza, l'ordine di valutazione è determinato dall'associatività degli operatori. Esistono due tipi di operatori a seconda dell'associatività:

Operatori associativi di sinistra che vengono eseguiti da sinistra a destra

Operatori associativi di destra che vengono eseguiti da destra a sinistra

Ad esempio, alcune operazioni, come la moltiplicazione e la divisione, hanno la stessa priorità. Quale sarà quindi il risultato nell'espressione:

Int x = 10/5 * 2;

Dovremmo interpretare questa espressione come (10/5) * 2 o come 10 / (5 * 2)? Infatti, a seconda dell'interpretazione, otterremo risultati diversi.

Poiché tutti gli operatori aritmetici (ad eccezione dell'incremento e del decremento del prefisso) sono associativi a sinistra, ovvero vengono eseguiti da sinistra a destra. Pertanto, l'espressione 10/5 * 2 deve essere interpretata come (10/5) * 2, ovvero il risultato sarà 4.

Operazioni in virgola mobile

Va notato che i numeri in virgola mobile non sono adatti per calcoli finanziari e di altro tipo in cui gli errori di arrotondamento possono essere critici. Ad esempio:

Doppio d = 2.0 - 1.1; System.out.println (d);

In questo caso la variabile d non sarà uguale a 0,9, come si potrebbe supporre inizialmente, ma a 0,8999999999999999. Errori di precisione come questo si verificano perché il sistema binario viene utilizzato a un livello basso per rappresentare i numeri in virgola mobile, ma non esiste una rappresentazione binaria per 0.1, così come per altri valori frazionari. Pertanto, se in tali casi, viene solitamente utilizzata la classe BigDecimal, che consente di aggirare tali situazioni.

Appunti delle lezioni Java. Sessione 4

(nessuno) (nessuno) ::
(nessuno)
(V. Fesyunov)

Operatori Java

La maggior parte delle operazioni Java sono semplici e intuitive. Queste sono operazioni come +, -, *, /,<,>e altri Le operazioni hanno il proprio ordine di esecuzione e le proprie priorità. Quindi nell'espressione

viene eseguita prima la moltiplicazione e poi l'addizione, poiché la moltiplicazione ha una priorità maggiore rispetto all'addizione. Nell'espressione

prima si calcola a + b e poi si sottrae c dal risultato, poiché l'ordine di queste operazioni va da sinistra a destra.

Ma le operazioni Java hanno le loro peculiarità. Senza entrare in una descrizione dettagliata delle operazioni più semplici, soffermiamoci sulle caratteristiche.

Iniziamo con Compiti... A differenza di molti altri linguaggi di programmazione in Java, l'assegnazione non è un operatore, ma un'operazione. La semantica di questa operazione può essere descritta come segue.

• L'operazione di assegnazione è indicata dal simbolo "=". Calcola il valore del suo operando di destra e lo assegna all'operando di sinistra e come risultato restituisce il valore assegnato. Questo valore può essere utilizzato da altre operazioni. Una sequenza di più assegnazioni viene eseguita da destra a sinistra.

Nel caso più semplice, tutto sembra come al solito.

Qui accade esattamente ciò che intendiamo intuitivamente: viene calcolata la somma di a e b, il risultato viene inserito in x. Ma ecco altri due esempi.

Nella prima, prima viene inserito 1 in b, il risultato dell'operazione è 1, quindi questo risultato viene inserito in a. Nel secondo esempio, viene calcolata la somma di aeb e il risultato viene perso. È inutile, ma sintatticamente valido.

Operazioni di confronto

Queste sono operazioni>,<, >=, <=, != и ==. Следует обратить внимание, что сравнение на равенство обозначается двумя знаками "=". Операндами этих операций могут быть арифметические данные, результат — типа boolean.

Operazioni di incremento, decremento

Queste sono le operazioni ++ e -. Quindi y ++ (incremento) è una scorciatoia per y = y +1, in modo simile all'operazione di decremento (-).

Ma c'è una sottigliezza con queste operazioni. Sono disponibili in due forme, prefisso (++ y) e postfisso (y ++). L'effetto di queste operazioni è lo stesso: aumentano (decrementano le operazioni - diminuiscono) il loro operando di 1, ma il loro risultato è diverso. La forma del prefisso di conseguenza fornisce il valore dell'operando già modificato di 1 e la forma del suffisso fornisce il valore dell'operando prima della modifica.

A = 5; x = a++; y = ++ a;

In questo frammento, x sarà impostato su 5 e y su 7.

Operazione di divisione intera

Va tenuto presente che dividendo un intero per un altro produce un intero e non arrotonda, ma scarta la parte frazionaria.

Resto della divisione (valore modulo)

Java ha l'operatore%, che denota il resto di una divisione.

Operazioni di assegnazione estese

Oltre alla consueta operazione "=" in Java, ci sono operazioni + =, - =, * =, / =, ecc. Queste sono notazioni abbreviate. Quindi a + = b è completamente equivalente a a = a + b. Allo stesso modo, con altre operazioni simili.

Operazioni logiche

! - negazione && - "e" logico || - logico "o"

Gli operandi di queste operazioni devono essere di tipo booleano, il risultato è booleano. && e || hanno una particolarità: il loro operando di destra potrebbe non essere calcolato se il risultato è già noto dall'operando di sinistra. Quindi, se l'operando sinistro dell'operazione && è falso, l'operando destro non verrà calcolato, poiché il risultato è ancora falso.

Questa proprietà deve essere presa in considerazione, specialmente quando l'operando di destra contiene una chiamata a qualche funzione.

Operazioni logiche bit a bit

Queste sono operazioni

& - bit a bit "e" | - "o" bit a bit ^ - "o esclusivo" bit a bit ~ - negazione bit a bit

Vengono eseguiti per ogni coppia di bit dei loro operandi.

Operazioni di spostamento

<< — сдвиг влево >> - shift a destra >>> - shift a destra senza segno

Queste operazioni spostano il valore del loro operando sinistro del numero di bit specificato dall'operando destro.

Operazione condizionale

Questa è l'unica operazione ternaria, ad es. un'operazione che ha tre operandi. Di conseguenza, non viene utilizzato un segno di operazione, ma due.

<условие> ? <выражение1> : < выражение2>

Se<условие>è vero, il risultato è< выражение1>, altrimenti< выражение2>.

Ad esempio, "a< b ? a: b" вычисляет минимум из a и b.

Operazione di colata

Questa è un'operazione molto importante. Per impostazione predefinita, tutte le conversioni che possono causare problemi sono vietate in Java. Quindi, non è possibile assegnare un valore long a un operando int. Nei casi in cui è ancora necessario, è necessario inserire una conversione di tipo esplicita.

Ad esempio, supponiamo che il metodo f (...) restituisca long.

int x = (int) f (10);

Qui (int) è un'operazione di conversione del tipo. Un'operazione di conversione del tipo è indicata dal nome del tipo racchiuso tra parentesi.

Questa operazione si applica non solo ai tipi di base, ma anche alle classi. Daremo un'occhiata più da vicino a questo quando esamineremo l'ereditarietà.

Letterali (costanti)

Aritmetica

Esempi di costanti aritmetiche

10 - 010 è 8 - 0123 è 83 (1 * 64 + 2 * 8 + 3) - 0x10 è 16 - 0x123 è 291 (1 * 256 + 2 * 16 +3) - 1e5 è 100000 - 1,23 e-3 è 0,00123

Per indicare il tipo di una costante, vengono utilizzati i suffissi: l (o L) - long, f (o F) - float, d (o D) - double. Ad esempio,

1L è uno, ma di tipo lungo.

letterali booleani

I letterali booleani sono veri e falsi

Letterali stringa

Sono scritti tra virgolette, per esempio

"questa è una stringa"

Caratteri letterali

Sono scritti in apostrofi, ad esempio "F", "w".

Nelle stringhe e nei caratteri letterali, ci sono regole per scrivere speciali. caratteri. Innanzitutto, c'è una serie di offerte speciali predefinite. caratteri. Questo

- "\ n" - fine riga (avanzamento riga) - "\ r" - ritorno a capo - "\ t" - tab

e un certo numero di altri.

In secondo luogo, puoi scrivere esplicitamente il codice del carattere (hai solo bisogno di conoscerlo). Il codice è solitamente scritto nel sistema ottale: "\ 001" è un carattere con codice 1, ecc.

Dichiarazioni

Operatore - Espressione

Sintassi

<выражение>;

Tale operatore è costituito da un'espressione, alla fine è ";". La sua azione è valutare l'espressione, il valore calcolato da questa espressione è perso. Quelli. di solito tale espressione contiene un operatore di assegnazione, sebbene ciò non sia richiesto dalla sintassi.

A = 0; x = (a> b? a: b); cnt++;

Dichiarazione condizionale (se)

Sintassi

Se (<условие>) <оператор1>

Qui<условие>È un'espressione logica, ad es. un'espressione che restituisce vero o falso. Come puoi vedere dalla sintassi, la parte else è facoltativa. C'è un operatore dopo il if e dopo l'else. Se hai bisogno di mettere lì più operatori, allora devi mettere bloccare . Bloccare inizia con "(" e termina con ")".

In Java, è consuetudine inserire sempre un blocco, anche se c'è un'istruzione dopo if o else.

If (a> b) (x = a;) else (x = b;) if (flag) (flag = false; init ();)

Nell'ultimo esempio, flag è una variabile o un campo booleano, init() è un metodo chiamato se il flag è vero (si dice "se flag è impostato").

Il resoconto (già visto)

Operatore loop per precondizione (while)

Sintassi

Mentre (<условие>) <оператор>

Come con l'istruzione if, è consuetudine in Java<оператор>racchiudere tra parentesi graffe.

Int i = 0; mentre (più) (x / = 2; più = (++ i< 10); }

In questo esempio, more dovrebbe essere una variabile o un campo booleano, x una variabile o un campo aritmetico. Il ciclo viene eseguito 10 volte.

Operatore di ciclo postcondizione (fai mentre)

Sintassi

Fare<оператор>mentre (<условие>);

L'operatore di ciclo per postcondizione differisce dall'operatore di ciclo per precondizione solo in quanto l'iterazione del ciclo viene sempre eseguita almeno una volta, mentre nell'operatore di precondizione potrebbe non esserci una singola iterazione del ciclo (se la condizione è immediatamente falsa).

Int i = 0; do (x \ = 2; più = (++ i< 10); } while (more);

Operatore contro loop (per)

Sintassi

Per (<инициализация>; <условие>; <инкремент>) <оператор>

L'intestazione di tale ciclo contiene tre espressioni (nel caso più semplice). Dal nome dell'operatore si capisce che serve per organizzare un ciclo con contatore. Pertanto l'espressione<инициализация>viene eseguito una volta prima della prima iterazione del ciclo. Dopo ogni iterazione del ciclo, l'espressione viene eseguita<инкремент>e poi l'espressione<условие>... L'ultima espressione deve essere logica e serve per impostare la condizione per la continuazione del ciclo. Quelli. fintanto che è vero, il ciclo continuerà a ripetersi.

Per comodità di comporre operatori di loop con un contatore, sono state introdotte molte estensioni in questa costruzione.

• <инициализация>potrebbe non essere un'espressione, ma una descrizione con inizializzazione di tipo "int i = 0".
• <инициализация>può essere un elenco di espressioni separate da virgole, ad esempio "i = 0, r = 1".
• <инкремент>può anche essere un elenco di espressioni, ad esempio "i ++, r * = 2"
• Tutti i componenti (<инициализация>, <условие>e<инкремент>) sono facoltativi. per esprimere<условие>ciò significa che la condizione è sempre considerata vera (cioè l'uscita dal ciclo deve essere organizzata in qualche modo all'interno del ciclo stesso).

Quelli. diciamo il seguente ciclo (ciclo infinito):

Per (;;) (...)

Per (int i = 0; i< 10; i++) x /=2;

Questa è l'implementazione del ciclo più "economica" degli esempi precedenti.

Interrompi e continua le dichiarazioni

Non ci sono istruzioni goto in Java. Come sai, goto porta a programmi non strutturati. Le istruzioni break e continue sono analoghi strutturati di goto.

Possono essere utilizzati nei cicli e break può essere utilizzato anche in un'istruzione switch. L'esecuzione dell'istruzione break fa terminare immediatamente il ciclo. L'istruzione continue provoca la fine dell'iterazione corrente del ciclo e l'inizio di una nuova. In questo caso, il controllo delle condizioni viene ancora eseguito, quindi continua può causare anche la fine del ciclo.

For (int i = 0;; i ++) (if (dispariSolo && i% 2 == 0) continue; y = (x + 1) / x; if (y - x< 0.001) break; x = y; }

Qui oddOnly è una variabile booleana. Se è impostato, tutte le iterazioni del ciclo con numeri pari vengono saltate utilizzando l'istruzione continue;

La condizione di terminazione del ciclo in questo esempio viene verificata a metà del ciclo e, se è soddisfatta, il ciclo viene terminato utilizzando l'istruzione break.

Con i cicli annidati, le istruzioni break e continue possono fare riferimento non solo al ciclo in cui si trovano, ma anche al ciclo che li racchiude. Per fare ciò, l'istruzione del ciclo di inclusione deve essere contrassegnata con un'etichetta, che deve essere specificata nell'istruzione break o continue. Ad esempio,

Lbl: while (...) (... For (...) (... If (...) break lbl;)...)

Qui, l'istruzione break farà terminare sia il ciclo for che il ciclo while.

Dichiarazione di selezione (switch)

Serve per organizzare una selezione da un certo valore di uno dei diversi rami di esecuzione.

Sintassi

Interruttore (<выражение>) (Astuccio<константа1>: <операторы1>Astuccio<константа2>: <операторы2> . . . }

L'espressione deve restituire un valore intero o carattere e le costanti devono essere dello stesso tipo del valore di questa espressione.

Elementi della cassa<константа>: "sono etichette di salto, se il valore dell'espressione coincide con una costante, verrà effettuato un salto a questa etichetta. Se il valore dell'espressione non corrisponde a nessuna delle costanti, tutto dipende dalla presenza del frammento predefinito. Se è, allora si verifica la transizione all'etichetta predefinita in caso contrario, l'intera istruzione switch viene ignorata.

• In un'istruzione switch, i frammenti di case non formano alcun blocco. Se dopo l'ultima istruzione di questo frammento di caso c'è il caso successivo, l'esecuzione continuerà, a partire dalla prima istruzione di questo frammento di caso.
• Per questo motivo, un'istruzione break viene solitamente utilizzata in un'istruzione switch. È posto alla fine di ogni frammento di caso.

Esempio (file SymbolTest.java)

Considera un programma demo che utilizza le istruzioni for e switch.

Questo programma genera casualmente 100 caratteri dell'alfabeto latino e li classifica come "vocali", "consonanti" e "a volte vocali". L'ultima categoria comprende i simboli "y" e "w".

Classe pubblica SymbolTest (public static void main (String args) (for (int i = 0; i< 100; i++) { char c = (char)(Math.random()*26 + "a"); System.out.print(c + ": "); switch (c) { case "a": case "e": case "i": case "o": case "u": System.out.println("гласная"); break; case "y": case "w": System.out.println("иногда гласная"); break; default: System.out.println("согласная"); } } } }

In questo esempio, ci sono diversi elementi che sono nuovi per noi.

• Viene utilizzato il metodo random() della classe Math. Diamo un'occhiata alla documentazione per la classe Math e vediamo cosa fa.
• Nell'istruzione char c = (char) (Math.random () * 26 + "a"); il valore aritmetico viene aggiunto al simbolo. Con questa aggiunta in Java, il simbolo viene convertito in un numero uguale al codice di questo simbolo.
• Nell'istruzione System.out.print (c + ":"); non viene utilizzato println (...), ma print (...). Il metodo print (...) differisce da println (...) solo per il fatto che non stampa su una nuova riga, quindi la successiva istruzione print (...) o println (...) continuerà a stampare su la stessa linea.

Dovresti anche prestare attenzione ai frammenti del caso. Formalmente, ci sono 7 di questi frammenti, ma 5 di essi non contengono operatori. Quindi, possiamo supporre che ci siano 2 frammenti di casi, ma ognuno di essi ha diverse etichette di casi.

Compiti a casa

• 1 Modificare SymbolTest.java in modo che il numero di simboli generati sia specificato dal parametro di chiamata del programma.
• 2 Scrivi un programma che prenda due numeri come parametri di chiamata: le lunghezze delle gambe di un triangolo rettangolo e di conseguenza stampi gli angoli in gradi.

(nessuno)