Operatii aritmetice. Operații pe tipuri primitive în Java

Operatorii în limbajul Java sunt caractere speciale care îi spun traducătorului că doriți să efectuați o operație asupra unor operanzi. Unii operatori necesită un singur operand, sunt numiți unar. Unii operatori sunt plasați înaintea operanzilor și sunt apelați prefix, alții – după, sunt chemați postfix operatori. Majoritatea operatorilor sunt plasați între doi operanzi, astfel de operatori sunt numiți infix operatori binari. Există un operator ternar care lucrează cu trei operanzi.

Java are 44 de operatori încorporați. Ele pot fi împărțite în 4 clase - operatori aritmetici, pe biți, de comparațieși joc de inteligență.

Operatori aritmetici

Operatorii aritmetici sunt utilizați pentru calcule în același mod ca în algebră (vezi tabelul pentru un rezumat al operatorilor aritmetici de mai jos). Operanzii validi trebuie să fie de tipuri numerice. De exemplu, utilizați acești operatori pentru a lucra tipuri booleene este imposibil, dar pentru a lucra cu tipul char este posibil, deoarece în tip Java char este un subset de tip int.

Operator	Rezultat	Operator	Rezultat
	Plus		sarcina suplimentară
	scădere (de asemenea, minus unar)		atribuirea de scădere
	Multiplicare		sarcina de înmulțire
			împărțire cu sarcină
	diviziune modulo		alocare modulo
	Creştere		scăderea

Patru operații aritmetice

Mai jos, ca exemplu, este un program simplu care demonstrează utilizarea operatorilor. Rețineți că operatorii lucrează atât pe literali întregi, cât și pe variabile.

clasa BasicMath (public static void int a = 1 + 1;

intb = a * 3;

main (Argumente șiruri) (

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);

} }

Prin rularea acestui program, ar trebui să obțineți următorul rezultat:

C: \> Java BasicMath

a = 2

b = 6

c = 1

d = 4

e = -4

Operator de modul

Operatorul modulo, sau operatorul mod, este notat cu simbolul %. Acest operator returnează restul împărțirii primului operand cu al doilea. Spre deosebire de C ++, funcția mod din Java funcționează nu numai cu numere întregi, ci și cu tipuri reale... Programul de mai jos ilustrează modul în care funcționează acest operator.

Modulul clasei (

public static void main (Argumente șir ) {

int x = 42;

dublu y = 42,3;

System.out.println ("x mod 10 =" + x% 10);

System.out.println ("y mod 10 =" + y% 10);

} }

Prin rularea acestui program, veți obține următorul rezultat:

C: \> Modulul

x mod 10 = 2

y mod 10 = 2,3

Operatori de atribuire aritmetică

Pentru fiecare dintre operatori aritmetici există o formă în care o atribuire este efectuată simultan cu o operaţie dată. Mai jos este un exemplu care ilustrează utilizarea acestui tip de operator.

clasa OpEquals (

int a = 1;

int b = 2;

int c = 3;

a + = 5;

b * = 4;

c + = a * b;

cu% = 6;

} }

Și iată rezultatul obținut la rularea acestui program:

C:> Java OpEquals

a = 6

b = 8

c = 3

Creștere și descreștere

Există 2 operatori în C numiți operatori de creștere și decrementare (++ și -), care sunt prescurtare pentru a adăuga sau scădea unul dintr-un operand. Acești operatori sunt unici prin faptul că pot fi utilizați atât în ​​forme de prefix, cât și de postfix. Următorul exemplu ilustrează utilizarea operatorilor de creștere și decrementare.

clasa IncDec (

public static void main (Argumente șir) (

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);

} }

Rezultatul executării acestui program va fi următorul:

C: \ java IncDec

a = 2

b = 3

c = 4

d = 1

Operatori întregi pe biți

Pentru tipurile de date numerice întregi - long, int, short, char și byte, este definit set suplimentar operatori cu care puteți verifica și modifica starea biților individuali ai valorilor corespunzătoare. Tabelul oferă un rezumat al acestor operatori. Operatorii aritmetici de biți lucrează cu fiecare bit ca valoare independentă.

Operator	Rezultat	Operator	Rezultat
	negație unară pe biți (NU)
	ȘI pe biți		pe biți și (ȘI) cu alocare
	biți SAU (SAU)		biți SAU (SAU) cu alocare
	SAU exclusiv pe biți (XOR)		SAU exclusiv pe biți (XOR) cu atribuire
	schimba la dreapta		schimbare la dreapta cu atribuire
	shift la dreapta captusit cu zerouri		Shift la dreapta adăugat cu zerouri cu atribuire
	schimbare la stânga		schimbare la stânga cu misiunea

Un exemplu de program care manipulează biți

Tabelul de mai jos arată modul în care fiecare dintre operatorii aritmetici de biți afectează posibilele combinații de biți ale operanzilor lor. Exemplul care urmează tabelului ilustrează utilizarea acestor operatori într-un program Java.

clasa Bitlogic (

public static void main (Argumente șir) (

Binar șir = ("OOOO", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011 "," 1100 "," 1101 ",

"1110", "1111" };

int a = 3; // 0 + 2 + 1 sau binar 0011

int b = 6; // 4 + 2 + 0 sau binar 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 =" + binar [a]);

System.out.println ("b =" + binar [b]);

System.out.println ("ab =" + binar [c]);

System.out.println ("a & b =" + binar [d]);

System.out.println ("a ^ b =" + binar [e]);

System.out.рrintln ("~ a & b | a ^ ~ b =" + binar [f]);

System.out.println ("~ a = „+ binar [g]);

} }

Mai jos este rezultatul acestui program:

C: \> Java BitLogic

a = 0011

b = 0110

a | b = 0111

a și b = 0010

a ^ b = 0101

~ a & b | a & ~ b = 0101

~ a = 1100

Schimbă la stânga și la dreapta

Operator<< выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями. В предыдущей главе уже говорилось об автоматическом повышении типа всего выражения до int в том слу­чае если в выражении присутствуют операнды de tip int sau tipuri de numere întregi mai mici. Dacă cel puțin unul dintre operanzii din expresie este de tip lung, atunci tipul întregii expresii este promovat la lung.

Operatorul >> înseamnă schimbare la dreapta în Java. Mută ​​toți biții operandului său din stânga la dreapta cu numărul de poziții specificat de operandul din dreapta. Când biții operandului din stânga sunt avansați dincolo de poziția din cea mai dreaptă a cuvântului, ei se pierd. Când treceți la dreapta, cifrele superioare (stânga) eliberate ale numărului deplasat sunt completate cu conținutul anterior al cifrei semnate. Acest comportament se numește extindere a semnelor.

Următorul program convertește o valoare de octet într-un șir care conține reprezentarea sa hexazecimală. Vă rugăm să rețineți că valoarea deplasată trebuie mascată, adică trebuie înmulțită logic cu valoarea 0 x0 f, pentru a șterge biții umpluți ca urmare a extinderii semnului și pentru a reduce valoarea la limitele permise la indexarea unui matrice de cifre hexazecimale.

classHexByte (

char hex = ("0", "1," 2 "," 3 "," 4 "," 5 "," 6 "," 7 "," 8 "," 9 "," a "," b " , "c", "d", "e", "f);

octet b = (octet) 0xf1;

System.out.println („b = 0x” + hex [(b >> 4) & 0x0f] + hex);

} }

Mai jos este rezultatul acestui program:

C: \> java HexByte

b = 0xf1

Schimb dreapta nesemnat

De multe ori este necesar ca atunci când treceți la dreapta, bitul de semn să nu se extindă, iar cifrele din stânga libere să fie pur și simplu umplute cu zerouri.

clasa ByteUShift (

static public void main (Argumente șir) (

char hex = ("0", "1 '," 2 "," 3 "," 4 "," 5 "," 6 "," 7 "," 8 "," 9 "," a "," b "," c "," d "," e "," f ');

octet b = (octet) 0xf1;

octet c = (octet) (b >> 4);

octet d = (octet) (b >> 4);

octet e = (octet) ((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);

} }

Pentru acest exemplu, variabila b ar putea fi inițializată cu un număr negativ arbitrar, am folosit un număr cu reprezentare hexazecimală 0xf1. Variabilei c i se atribuie rezultatul unei deplasări cu semn b la dreapta cu 4 biți. După cum era de așteptat, lărgirea bitului semnat face ca 0xf1 să devină 0xff. Apoi rezultatul unei deplasări fără semn a lui b la dreapta cu 4 biți este introdus în variabila d. Vă puteți aștepta ca d să conțină 0x0f ca rezultat, dar în realitate obținem din nou 0xff. Acesta este rezultatul expansiunii semnului efectuată atunci când variabila b este promovată automat la int înainte de operația de schimbare la dreapta. În final, în expresia pentru variabila e, reușim să obținem rezultatul dorit - valoarea 0x0f. Pentru a face acest lucru, înainte de a trece la dreapta, a trebuit să înmulțim logic valoarea variabilei b cu masca 0xff, ștergând astfel biții de ordin înalt umpluți în timpul creșterii automate a tipului. Rețineți că nu mai este nevoie să folosiți deplasarea la dreapta nesemnată, deoarece cunoaștem starea bitului de semn după operația AND.

C: \> java ByteUShift

b = 0xf1

b >> 4 = 0xff

b >>> 4 = 0xff

b & 0xff) >> 4 = 0x0f

Operatori de atribuire pe biți

Ca și în cazul operatorilor aritmetici, toți operatorii binari pe biți au o formă înrudită care permite ca rezultatul unei operații să fie atribuit automat operandului din stânga. Următorul exemplu creează mai multe variabile întregi și efectuează diverse operații folosind operatorii de mai sus.

clasa OpBitEquals (

public static void main (Argumente șir) (

int a = 1;

int b = 2;

int c = 3;

a | = 4;

b >> = 1;

Cu<<= 1;

a ^ = c;

System.out.println ("a =" + a);

System.out.println ("b =" + b);

System.out.println ("c =" + c);

} }

Rezultatele execuției programului sunt următoarele:

C: \> Java OpBitEquals

a = 3

b = 1

c = 6

Operatori relaționali

Pentru a putea compara două valori, Java are un set de operatori care descriu relația și egalitatea. Lista acestor operatori este dată în tabel.

Operator	Rezultat
	mai mult sau egal
	mai putin sau egal

Valorile de orice tip, inclusiv numere întregi, numere reale, simboluri, booleeni și referințe, pot fi comparate folosind operatorul de egalitate == și operatorul de inegalitate! =. Vă rugăm să rețineți că în Java, la fel ca în C și C ++, testarea egalității este indicată de secvența (==). Un semn (=) este operatorul de atribuire.

Operatori logici booleeni

Operatorii logici booleeni, rezumați în tabelul de mai jos, operează numai pe operanzi booleeni. Toți operatorii logici binari acceptă două valori booleene ca operanzi și returnează același tip.

Operator	Rezultat	Operator	Rezultat
	ȘI logic (ȘI)		ȘI (ȘI) cu atribuire
	SAU logic (SAU)		SAU (SAU) cu atribuire
	SAU exclusiv logic (XOR)		SAU exclusiv (XOR) cu atribuire
	operatorul SAU al evaluării rapide a expresiei ( scurt circuit SAU)
	scurtcircuit SI operator
	negație unară logică (NU)		operator ternar dacă-atunci-altfel

Rezultatele influenței operatorilor logici asupra diferitelor combinații ale valorilor operanzilor sunt prezentate în tabel.

Programul de mai jos repetă aproape complet exemplul BitLogic pe care îl cunoașteți deja. Numai că de data aceasta lucrăm cu valori booleene.

clasa BoolLogic (

public static void main (Argumente șir) (

boolean a = adevărat;

boolean b = fals;

boolean c = a | b;

boolean d = a & b;

boolean e = a ^ b;

boolean f = (! a & b) | (a &! b);

boolean 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 = adevărat

b = fals

a | b = adevărat

a & b = fals

a ^ b = adevărat

! a & b | a &! b = adevărat

!a = fals

Operatori de evaluare rapidă expresii logice(operatori logici de scurtcircuit)

Există două completări interesante la suita de operatori boolean. Acestea sunt versiuni alternative ale operatorilor AND și SAU pentru evaluarea rapidă a expresiilor booleene. Știți că dacă primul operand al unui operator SAU este adevărat, atunci indiferent de valoarea celui de-al doilea operand, rezultatul operației este adevărat. În mod similar, în cazul operatorului AND, dacă primul operand este fals, atunci valoarea celui de-al doilea operand nu afectează rezultatul - acesta va fi întotdeauna fals. Dacă utilizați && și || în loc de formele obișnuite & și |, Java nu evaluează operandul din dreapta al unei expresii booleene dacă răspunsul este clar din valoarea operandului din stânga. Este o practică obișnuită să folosiți && și || în aproape toate cazurile, evaluarea expresiilor logice booleene. Versiunile acestor operatori & și | se aplică numai la aritmetica de biți.

Operatorul ternar dacă-atunci-altfel

Forma generală a instrucțiunii if-then-use este următoarea:

expresia1? expresie2: expresie3

Ca prim operand - "expresie1" - poate fi folosită orice expresie, al cărei rezultat este o valoare booleană. Dacă rezultatul este adevărat, atunci se execută operatorul specificat de al doilea operand, adică „expression2”. Dacă primul operand este fals, atunci al treilea operand este executat - „expresie3”. Al doilea și al treilea operanzi, adică expresia2 și expresia3, trebuie să returneze valori de același tip și nu trebuie să fie nule.

Programul de mai jos folosește acest operator pentru a testa divizorul înainte de a efectua operația de divizare. În cazul unui divizor zero, se returnează valoarea 0.

clasa ternară (

public static void main (Argumente șir) (

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);

} }

Acest program nu ridică o diviziune cu zero excepție și dă următoarele rezultate:

C: \> java Ternar

a = 42

b = 2

c = 99

d = 0

a/b = 21

s/d = 0

Prioritățile operatorului

Java are o ordine specifică, sau o prioritate, a operațiilor. În algebra elementară, am fost învățați că înmulțirea și împărțirea au o prioritate mai mare decât adunarea și scăderea. În programare, trebuie să urmăriți și prioritățile operațiunilor. Tabelul listează în ordine descrescătoare prioritățile tuturor operațiunilor în limbajul Java.

Prima linie a tabelului enumeră trei operatori neobișnuiți despre care nu am vorbit încă. Parantezele () sunt folosite pentru a seta în mod explicit prioritatea. După cum ați învățat în capitolul anterior, parantezele drepte sunt folosite pentru a indexa o variabilă matrice. Operator. (punctul) este folosit pentru a separa elementele dintr-o referință de obiect - vom vorbi despre asta în capitolul 7. Toți ceilalți operatori au fost deja discutați în acest capitol.

Priorități explicite

Întrucât se acordă cea mai mare prioritate paranteze rotunde, puteți adăuga oricând mai multe perechi de paranteze la o expresie dacă aveți îndoieli cu privire la ordinea evaluării sau doriți doar să faceți codul mai ușor de citit.

a >> b + 3

Cu care dintre cele două expresii, a >> (b + 3) sau (a >> b) + 3, se potrivește prima linie? Deoarece operatorul de adăugare are o prioritate mai mare decât operatorul de schimbare, răspunsul corect este a >> (b + A). Deci, dacă trebuie să efectuați o operație (a >> b )+ 3 parantezele sunt indispensabile.

Deci, am acoperit toate tipurile de operatori în limbajul Java. Acum puteți construi orice expresie Cu tipuri diferite date... În capitolul următor, ne vom familiariza cu constructele de ramificare, organizarea buclelor și vom învăța cum să controlăm execuția programului.

Operatorii logici funcționează numai cu operanzi ca boolean... Toți operatorii booleeni cu doi operanzi combină două valori booleene pentru a forma valoarea booleană rezultată. Nu confunda cu.

Tabel operator boolean în Java

Operatori logici & , | , ^ se aplică valorilor de tip boolean exact la fel ca și în cazul biților de valori întregi. Operator logic ! inversează (inversează) starea booleană: ! adevărat == falsși ! fals == adevărat.

Masa. Rezultate operator logic

A	B	A | B	A și b	A ^ B	! A
fals	fals	fals	fals	fals	Adevărat
Adevărat	fals	Adevărat	fals	Adevărat	fals
fals	Adevărat	Adevărat	fals	Adevărat	Adevărat
Adevărat	Adevărat	Adevărat	Adevărat	fals	fals

Operatori booleeni abreviați

Pe lângă operatorii standard ȘI (&)și SAU (|) există operatori de stenografie && și || .

Dacă te uiți la tabel, poți vedea că rezultatul executării operatorului SAU este egal cu Adevărat Adevărat, indiferent de valoarea operandului B. La fel, rezultatul executării operatorului ȘI este egal cu fals când valoarea operandului A este fals, indiferent de valoarea operandului B. Se dovedește că nu trebuie să calculăm valoarea celui de-al doilea operand, dacă rezultatul poate fi determinat deja de primul operand. Acest lucru devine util în cazurile în care valoarea operandului din dreapta depinde de valoarea celui din stânga.

Considera exemplul următor... Să presupunem că am introdus o regulă - să hrănim sau nu pisica, în funcție de numărul de șoareci prinși pe săptămână. Mai mult decât atât, numărul de șoareci depinde de greutatea pisicii. Cu cât pisica este mai mare, cu atât trebuie să prindă mai mulți șoareci.

Pisica, care a citit starea problemei, a fost supărată de mine. A spus că am fost în urmă vremurilor, iar în curtea secolului XXI - șoarecii pot fi prinși cu ajutorul capcanelor de șoareci. A trebuit să-i explic că aceasta este doar o sarcină, și nu un exemplu din viața mea personală.

mouse int; // numărul de șoareci int greutate; // greutatea pisicii în grame șoarece = 5; greutate = 4500; dacă (mouse! = 0 & greutate / mouse< 1000) { mInfoTextView.setText("Можно кормить кота"); }

Dacă rulați programul, exemplul va funcționa fără probleme - cinci șoareci pe săptămână sunt suficiente pentru a vă răsfăța pisica cu un mic dejun delicios. Dacă prinde patru șoareci, atunci vor începe problemele cu alimentația pisicii, dar nu cu programul - va funcționa, pur și simplu nu va afișa un mesaj despre permisiunea de a hrăni parazitul.

Acum să luăm un caz limită. Pisica a lenevit si nu a prins un singur soricel. Valoare variabilă mouse va fi egal cu 0 și există un operator de divizare în expresie. Și nu puteți împărți la 0 și programul nostru se va închide cu o eroare. S-ar părea că am oferit o opțiune cu 0, dar Java evaluează ambele expresii mouse-ul! = 0și greutate / mouse< 1000 , în ciuda faptului că deja în prima expresie revine fals.

Să rescriem condiția după cum urmează (adăugăm doar un simbol):

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

Programul rulează acum fără să se blocheze. Odată ce Java a văzut că prima expresie se întoarce fals, atunci expresia a doua diviziune este pur și simplu ignorată.

Variante prescurtate de operator ȘIși SAU folosit de obicei în situaţiile în care sunt solicitaţi operatori logica booleana, iar verii lor cu un singur caracter sunt utilizați pentru operațiuni pe biți.

Operator ternar

Limbajul Java are și un ternar special operator condițional care poate înlocui anumite tipuri operatori dacă-atunci-altfel este operatorul ?:

Operatorul ternar folosește trei operanzi. Expresia este scrisă sub următoarea formă:

Condiție logică? expresie1: expresie2

Dacă Condiție logică egală Adevărat, apoi se calculează expresie1 iar rezultatul ei devine rezultatul executării întregului enunţ. Dacă Condiție logică egală fals, apoi se calculează expresie2, iar valoarea sa devine rezultatul muncii operatorului. Ambii operanzi expresie1și expresie2 trebuie să returneze o valoare de același tip (sau compatibil).

Luați în considerare un exemplu în care variabila absval se atribuie valoarea absolută a variabilei val.

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

Variabil absval se va atribui valoarea variabilei val dacă valoarea este mai mare sau egală cu zero (a doua parte a expresiei). Dacă valoarea variabilei val este negativ, apoi variabila absval valoarea variabilei este atribuită, luată cu semnul minus, ca urmare, minus cu minus va da un plus, adică o valoare pozitivă. Să rescriem codul folosind dacă-altfel:

Dacă (val< 0) absval = -val; else absval = val;

Puteți privi un alt exemplu cu operatorul ternar.

Cele mai multe operațiuni pe tipuri primitive se face nu cu metode, ci cu caractere speciale numit semn de operare.

Operațiune de atribuire

Misiune valoare variabilă constante, se numește o altă variabilă sau expresie (variabile și/sau constante separate prin semne de operație). operatiune de atribuireși este indicat prin semnul „ = ", de exemplu: x = 3; y = x; z = x; În Java, este posibil să se refolosească operația de atribuire într-o expresie, de exemplu: x1 = x2 = x3 = 0; Această operație se efectuează de la dreapta la stânga, adică mai întâi variabilei x3 i se atribuie valoarea 0, apoi variabilei x2 i se atribuie valoarea variabilei x3 (0), iar în final variabilei x1 i se atribuie valoarea variabilei x2 (0). semnele operațiilor ale căror argumente sunt numere se împart în două categorii: unar jetoane (unare) pentru operații cu un singur argument și binar(binar) cu două argumente.

Operații unare

Următoarele operații unare sunt definite în Java:

• unar minus "-" - schimbă semnul unui număr sau al unei expresii la opus;
• unar plus „+” - nu efectuează nicio acțiune asupra unui număr sau expresie;
• complement pe biți „~” (numai pentru numere întregi) - inversează toți biții câmpului numeric (schimbă de la 0 la 1 și de la 1 la 0);
• increment "++" (doar pentru numere întregi) - crește valoarea variabilei cu 1;
• decrementează „-” (numai pentru numere întregi) - scade valoarea variabilei cu 1.

Exemple de operatii unare„+” și „-”: int i = 3, j, k; j = - i; // j = -3 k = + i; // k = 3 Un exemplu de operație de complement pe biți: int a = 15; int b; b = ~ a; // b = -16 Numerele a și b sunt int, adică. sunt reprezentate intern ca numere întregi binare semnate pe 32 de biți, deci reprezentare binară numerele a și b vor arăta astfel: a = 00000000 00000000 00000000 00001111 b = 11111111 11111111 11111111 11110000 După cum puteți vedea de la această reprezentare, toate schimbările biți și numărul b sunt schimbate în biți unu și numărul b. la zero biți... Reprezentarea zecimală a lui b este –16. Semnele operației de creștere și decreștere pot fi plasate fie înainte, fie după variabilă. Aceste opțiuni sunt denumite corespunzător prefixși postfix prin înregistrarea acestor operaţii. Semnul operatorului în notația de prefix returnează valoarea operandului său după evaluarea unei expresii. Pentru notația postfix, semnul operației primul returnează valoarea operandului său și numai după aceea calculează creșterea sau decrementarea, de exemplu: int x = 1, y, z; y = ++ x; z = x ++; Variabilei y i se va atribui valoarea 2, deoarece mai întâi valoarea lui x va fi incrementată cu 1, iar apoi rezultatul va fi atribuit variabilei y. Variabilei z i se va atribui valoarea 1, deoarece mai întâi variabilei z i se va atribui o valoare, iar apoi valoarea lui x va fi incrementată cu 1. În ambele cazuri, noua valoare a lui x va fi 2. Trebuie remarcat faptul că în Java, spre deosebire de C, operațiile de decrementare și creștere pot fi aplicate și variabilelor reale ( plutiși dublu). Semne de operare binară sunt împărțite în operații cu rezultat numeric și operații de comparare, al căror rezultat este o valoare booleană.

Operații binare aritmetice

Java definește următoarele operații binare aritmetice:

• adăugare „+”;
• scăderea „-”;
• înmulțirea „*”;
• Divizia "/";
• calcularea restului de împărțire a numerelor întregi „%” (returnează restul împărțirii primului număr la al doilea, iar rezultatul va avea același semn ca și dividendul), de exemplu, rezultatul operațiunii 5% 3 va fi 2 și rezultatul operației (-7) % (- 4) va fi -3. V Operare Java poate fi folosit pentru variabile reale (float sau double).

Exemple binare operatii aritmetice: 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 (la împărțirea numerelor întregi // fracțiune aruncat) x5 = x% 4 // x5 = 3 (restul diviziunii// 7 cu 4)

Operații pe biți

• Operațiile pe biți iau în considerare originalul valori numerice ca câmpuri de biți și efectuați următoarele acțiuni asupra acestora:
• setarea bitului la i-a poziție a câmpului rezultat la 1, dacă ambii biți sunt în i--lea poziții ale operanzilor sunt egale cu 1, sau cu 0, în caz contrar - ȘI pe biți ("&");
• setarea bitului la i-a poziție a câmpului rezultat la 1, dacă cel puțin un bit în i--a poziție a operanzilor este egală cu 1, sau cu 0, în caz contrar - SAU pe biți ("|");
• setarea bitului la i-a poziție a câmpului rezultat la 1, dacă biții sunt introduși i pozițiile --lea ale operanzilor nu sunt egale între ele sau cu 0, în caz contrar - SAU exclusiv pe biți ("^");
• deplasarea la stânga a biților din câmpul primului operand cu numărul de biți determinat de cel de-al doilea operand (bitul de semn al numărului nu se schimbă în acest caz) - deplasare pe biți la stânga, ținând cont de semnul "<< ";
• deplasarea la dreapta a biților din câmpul primului operand cu numărul de biți determinat de al doilea operand (bitul de semn al numărului nu se modifică în acest caz) - deplasare pe biți la dreapta, ținând cont de " semnul >>";
• deplasare la dreapta biților din câmpul primului operand cu numărul de biți determinat de al doilea operand (bitul de semn al numărului este, de asemenea, deplasat în acest caz) - deplasare pe biți la dreapta fără a lua în considerare " >>>" semn.

Exemple de operații pe biți:

1. ȘI pe biți

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

2. SAU pe biți

   int x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z = x | y; // z = 126: 00000000 00000000 00000000 01111110

3. SAU exclusiv pe biți

   int 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. Schimbați la stânga, ținând cont de semn

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

5. Schimbați la dreapta, ținând cont de semn

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

6. Schimbați la dreapta fără a ține cont de semn

   int x = - 17, z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2; // z = 1073741819 // z: 00111111 11111111 11111111 11111011

Operații combinate

În Java, pentru operații aritmetice binare, puteți utiliza combinate Jetoane de operație (compuse): operațiune de identificare = expresie Aceasta este echivalentă cu următoarea operație: expresie de operare de identificare = identificator Exemple:

1. Expresia x + = b înseamnă x = x + b.
2. Expresia x - = b înseamnă x = x - b.
3. Expresia x * = b înseamnă x = x * b.
4. Expresia x / = b înseamnă x = x / b.
5. Expresia x% = b înseamnă x = x% b.
6. Expresia x & = b înseamnă x = x & b.
7. Expresia x | = b înseamnă x = x | b.
8. Expresia x ^ = b înseamnă x = x ^ b.
9. Expresia x<<= b означает x = x << b .
10. Expresia x >> = b înseamnă x = x >> b.
11. Expresia x >>> = b înseamnă x = x >>> b.

Operatii de comparatie

Java definește următorii operatori de comparație:

• "==" (egal), "! =" (nu este egal),
• ">" (mai mare decât), "> =" (mai mare sau egal),
• " < " (меньше) " <= " (меньше или равно)

au doi operanzi și returnează o valoare booleană corespunzătoare rezultatului comparației ( fals sau Adevărat). Rețineți că atunci când comparați două valori pentru egalitate în Java, ca în C și C ++, simbolurile " == „(două semne egale fără spațiu), spre deosebire de operatorul de atribuire, care folosește „ = ". Folosirea simbolului" = "la compararea a două valori fie provoacă o eroare de compilare, fie produce un rezultat incorect. Exemple de operații de comparare: boolean isEqual, isNonEqual, isGreater, isGreaterOrEqual, isLess, isLessOrEqual; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; este egal = x1 == x2; // este Egal = adevărat esteNonEqual = x1! = x2; // isNonEqual = false isGreater = x1> x3; // isGreater = adevărat // isGreaterOrEqual = adevărat isGreaterOrEqual = x2> = x3; isLess = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

Operații booleene

Operații booleene sunt executate pe variabile booleene iar rezultatul lor este tot o valoare de tip boolean... Următoarele operații booleene sunt definite în Java:

• negație "!" - înlocuirea falsului cu adevărat, sau invers;
• Operația AND „&” - rezultatul este adevărat numai dacă ambii operanzi sunt adevărati, în caz contrar rezultatul este fals;
• Operația SAU „|” - rezultatul este adevărat numai dacă cel puțin unul dintre operanzi este adevărat, în caz contrar rezultatul este fals.
• Operația XOR „^” - rezultatul este adevărat numai dacă operanzii nu sunt egali între ei, în caz contrar rezultatul este fals.

Operatorii „&”, „|” și „^” pot fi utilizați, precum și operatorii corespunzători pe biți, în operatorii de alocare compuși: „& =", "| =" și "^ =" În plus, operațiile " = sunt aplicabile operanzilor booleeni. = „(egal) și”! = „(nu este egal). După cum puteți vedea din definiția SAU și ȘI, operația OR evaluează la adevărat atunci când primul operand este adevărat, indiferent de valoarea celui de-al doilea operand, iar operatorul AND evaluează la fals atunci când primul operand este fals, indiferent de valoarea celui de-al doilea operand. Java mai definește două operații booleene: a doua versiune a AND și OR boolean, cunoscute sub numele de operații logice de scurtcircuit: ȘI scurtat „&&” și SAU scurtat „||”. Când se utilizează aceste operații, al doilea operand nu va fi evaluat deloc, ceea ce este util în cazurile în care funcționarea corectă a operandului din dreapta depinde dacă operandul din stânga este adevărat sau fals. Exemple de operații booleene: boolean isInRange, isValid, isNotValid, isEqual, isNotEqual; int x = 8; isInRange = x> 0 && x< 5 ; // isInRange = false isValid = x >0 || x> 5; // isValid = adevărat isNotValid =! este valabil; // isNotValid = fals isEqual = isInRange == isValid; // isEqual = fals // isNotEqual = adevărat isNotEqual = isInRange! = isValid

Funcționare condiționată

O operație condiționată se scrie sub forma expresie-1?Expresie-2: expresie-3. În acest caz, expresia-1 este evaluată mai întâi, ceea ce ar trebui să dea o valoare booleană, iar apoi, dacă expresia-1 este adevărată, expresia-2 este evaluată și returnată ca rezultat al operației sau (dacă expresia-1 este falsă ), iar expresia-3 este returnată ca rezultat al operației. Un exemplu de operație condiționată: x = n> 1? 0: 1; Variabilei x i se va atribui valoarea 0 dacă n> 1 (expresia n> 1 evaluează drept adevărat) sau 1 dacă n≤1 (expresia n> 1 evaluează fals).

Vechimea operațiunilor

Operațiile în expresii sunt efectuate de la stânga la dreapta, însă, în funcție de prioritatea lor. Deci operații de înmulțire în expresia y = x + z * 5; se va executa înaintea operaţiei de adunare deoarece prioritatea operaţiei de înmulţire este mai mare decât prioritatea operaţiei de adunare. Prioritățile de operare (în ordinea priorității descrescătoare) în Java sunt prezentate în tabel. unu.
Parantezele măresc prioritatea operațiilor care se află în interiorul lor. Deci, dacă introduceți paranteze în expresia de mai sus: y = (x + z) * 5; apoi se va executa mai întâi operația de adunare, iar apoi operația de înmulțire. Uneori, parantezele sunt folosite pur și simplu pentru a face expresia mai lizibilă, de exemplu: (x> 1) && (x<= 5 ) ;

Conversia tipului și turnarea atunci când efectuați operațiuni

În alocare și expresii aritmetice se pot folosi literale, variabile și expresii de diferite tipuri, de exemplu: y dublu; octet x; y = x + 5; Acest exemplu adaugă variabila octet x la literalul 5 (int) și atribuie rezultatul variabilei duble y. În Java, ca și în limbajul C, conversiile de tip în evaluarea expresiilor pot fi efectuate automat, sau folosind un operator cast. Cu toate acestea, regulile de turnare sunt oarecum diferite de cele ale limbajului C și, în general, sunt mai stricte decât în ​​limbajul C. La efectuarea unei operații de atribuire, conversia tipului are loc automat dacă transformare de lărgire(conversie de lărgire) și cele două tipuri sunt compatibile... Transformările de lărgire sunt transformări octet® mic de statura® int® lung® pluti® dubla... Pentru extinderea conversiilor, tipurile numerice, inclusiv numărul întreg și virgulă mobilă, sunt compatibile între ele. Cu toate acestea, tipurile numerice nu sunt compatibile cu tipurile char și boolean. Nici tipurile char și boolean nu sunt compatibile între ele. Java efectuează, de asemenea, conversie automată de tip atunci când stochează o constantă întreg literal (care este de tip int în mod implicit) în variabile de tip octet, scurt sau lung (cu toate acestea, dacă literalul are o valoare în afara intervalului de valori valide pentru aceasta tip, este afișat un mesaj de eroare: posibilă pierdere de precizie). Dacă conversia este o conversie de îngustare, adică byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ dublu este efectuată, atunci o astfel de conversie poate duce la pierderea preciziei sau la distorsiunea numărului. Prin urmare, odată cu restrângerea conversiilor, atunci când programul este compilat, este afișat un mesaj de diagnostic despre incompatibilitatea de tip și fișierele de clasă nu sunt create. Acest mesaj va fi afișat și atunci când se încearcă convertirea expresiilor de tip octet sau scurt într-o variabilă de tip char. Dacă totuși este necesar să se efectueze astfel de conversii, se folosește o operațiune de turnare, care are următorul format: ( tip de conversie) sens, Unde tip de conversie definește tipul la care ar trebui convertit datele date sens, de exemplu, ca urmare a executării operatorilor: octet x = 71; simbol char = (char) x; variabila simbol va fi setată la „G”. Dacă o valoare în virgulă mobilă este atribuită unui tip întreg, atunci (dacă valoarea în virgulă mobilă are o parte fracțională), are loc și o conversie explicită a tipului trunchiere(trunchiere) numere. Deci, ca urmare a executării operatorului int x = (int) 77,85; variabila x va fi setată la 77. Dacă valoarea atribuită este în afara intervalului conversii de tip , atunci rezultatul conversiei va fi restul împărțirii valorii la modulul intervalului tipului atribuit (pentru numere de tip octet, modulul intervalului va fi 256, pe scurt - 65536, pentru int - 4294967296 și pentru mult timp - 18446744073709551616). De exemplu, ca rezultat al instrucțiunii octet x = (octet) 514; variabila x va fi setată la 2. La conversia numerelor întregi sau reale în date de tip char, conversia într-un caracter are loc dacă numărul inițial este în intervalul de la 0 la 127, în caz contrar caracterul primește valoarea „?”. Când se efectuează conversii aritmetice și pe biți, toate valorile octet și scurte, precum și char, sunt extinse la int (în timp ce valoarea numerică a codului caracterului este utilizată în calculele pentru char), atunci, dacă cel puțin un operand este de tip lung , tipul expresiei întregi este extins la lung. Dacă unul dintre operanzi este de tip float, atunci tipul expresiei complete este extins la float, iar dacă unul dintre operanzi este de tip double, atunci tipul rezultatului va fi dublu. Deci, dacă variabilele sunt declarate octetul a, c; b scurt; apoi în expresia a + b * c - 15 L + 1,5F + 1,08 - 10; mai întâi, înainte de a calcula a + b * c, valorile variabilelor vor fi extinse la int, apoi, deoarece constanta 15 este de tip lung, rezultatul calculului va fi crescut cu mult înainte de scădere. După aceea, deoarece literalul 1.5 este de tip float, rezultatul calculării a + b * c - 15L va fi extins pentru a flota înainte de a fi adăugat la acest literal. Înainte de a efectua adunarea cu numărul 1.08, rezultatul calculelor anterioare va fi extins la dublu (deoarece constantele reale sunt de tip double implicit) și, în final, înainte de efectuarea ultimei adunări, va fi literal 10 (int implicit) extins la dublare. Astfel, rezultatul evaluării expresiei va fi de tip double. Extensiile de tip automat (în special extensiile scurte și de octeți la int) pot cauza erori de compilare prost recunoscute. De exemplu, în operatorii: octet x = 30, y = 5; x = x + y; înainte de efectuarea adunării, valoarea variabilelor x și y va fi extinsă la int și apoi va fi afișat un mesaj de eroare atunci când se încearcă atribuirea rezultatului unui calcul de tip int unei variabile de tip octet. Pentru a evita acest lucru este necesar să folosiți o conversie explicită de tip în al doilea operator: x = (octet) (x + y); Trebuie să includeți expresia x + y între paranteze deoarece prioritatea modelului inclus între paranteze este mai mare decât prioritatea operației de adăugare. Apropo, dacă scrieți al doilea operator ca: x + = y; nu va fi niciun mesaj de eroare. Link la primul

1. Operații aritmetice de bază

Următorul tabel listează operațiile aritmetice de bază utilizate în limbajul Java:

Să luăm în considerare câteva reguli pentru lucrul cu operații aritmetice:

• Expresiile sunt evaluate de la stânga la dreapta, cu excepția cazului în care sunt adăugate paranteze sau unele operații au prioritate.
• Operațiile *, / și% au prioritate față de + și -.

Exemplul 1. Operații aritmetice pe valori întregi

De exemplu, în acest cod, variabilele Ași b va avea semnificații diferite:

Clasa publică 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);))

Rezultatul executiei:

A = 3 b = 13

• Operația de scădere unară schimbă semnul singurului său operand.
• O operație de adăugare unară returnează pur și simplu valoarea operandului său. În principiu, nu este necesar, dar posibil.

Exemplul 2. Operații de adunare și scădere unare

clasă publică UnarySignOperation (public static void main (String args) (double a = -6; double b = +6; System.out.println (a); System.out.println (b);))

• Când se efectuează o operație de împărțire pe un tip de date întreg, rezultatul nu va conține o componentă fracțională.

Exemplul 3. Împărțirea numerelor întregi

clasă publică IntDivision (public static void main (String args) (int a = 16/5; System.out.println (a);))

Rezultatul rulării acestui program:

• Operanzii pentru operațiile aritmetice trebuie să fie de tip numeric. Operațiile aritmetice nu pot fi efectuate pe tipuri de date booleene, dar pot fi efectuate pe tipuri de date char deoarece în Java acest tip este în esență o variație a tipului int.

Exemplul 4. Operații aritmetice pe variabile de tip char

clasă publică BasicCharMath1 (public static void main (String args) (char c = "n"; System.out.println (c); System.out.println (c + 1); System.out.println (c / 5)) ;))

Rezultatul executiei:

N 111 22

Exemplul 5. Operații aritmetice pe variabile de tip char

clasă publică BasicCharMath2 (public static void main (String args) (char c1 = "1"; char c2 = "\ u0031"; char c3 = 49; System.out.println (c1 + c2 + c3);))

Rezultatul executiei:

Operator modul - notat cu%. Acest operator returnează restul primului număr împărțit la al doilea. La împărțirea unui număr întreg, rezultatul este, de asemenea, un număr întreg.

Exemplul 6. Diviziunea modulului

clasă publică 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);))

Rezultatul executiei:

1 1.2000000000000002

2. Operații aritmetice compuse cu atribuire

Java are operații speciale care combină aritmetica cu atribuirea. Luați în considerare următoarea expresie:

A = a + 4;

În Java, această operație poate fi scrisă după cum urmează:

A + = 4;

Operațiile de atribuire compusă nu numai că vă permit să reduceți cantitatea de cod, dar vă permit și să efectuați conversie automată, care nu se face prin operațiuni convenționale.

Exemplul 5. Operații de alocare aritmetică compusă

clasă publică CompoundOperations (public static void main (String args) (int a = 1; int b = 2; int c = 3; a + = 3; b * = 2; c + = a * b; System.out.println (a); System.out.println (b); System.out.println (c);))