Java oferă un set bogat de operatori pentru manipularea variabilelor. Toți operatorii Java pot fi împărțiți în următoarele grupuri:
- operatori aritmetici;
- operatori de comparare;
- operatori pe biți;
- operatori logici;
- operatori de atribuire;
- alti operatori.
Operatori aritmetici
Operatori aritmetici- folosit in expresii matematice la fel sunt folosite în algebră. Să presupunem că variabila întreagă A este 10 și variabila B este 20. Următorul tabel listează operatorii aritmetici în Java:
Exemplu
Următorul exemplu simplu arată operatorii aritmetici programatic. Copiați și inserați următorul cod java în fișierul test.java, compilați și rulați acest program:
Public class Test (public static void main (String args) (int a = 10; int b = 20; int c = 25; int d = 25; System.out.println ("a + b =" + (a + b) )); System.out.println ("a - b =" + (a - b)); System.out.println ("a * b =" + (a * b)); System.out.println (" b / a = "+ (b / a)); System.out.println (" b% a = "+ (b% a)); System.out.println (" c% a = "+ (c% a) )); System.out.println ("a ++ =" + (a ++)); System.out.println ("b-- =" + (a--)); // Verificați diferența în d ++ și ++ d System .out.println ("d ++ =" + (d ++)); System.out.println ("++ d =" + (++ d));))
A + b = 30 a - b = -10 a * b = 200 b / a = 2 b% a = 0 c% a = 5 a ++ = 10 b-- = 11 d ++ = 25 ++ d = 27
Operatori de comparare
Următorii operatori de comparare sunt acceptați în limbajul Java. Să presupunem că variabila A este 10 și variabila B este 20. Următorul tabel listează operatorii relaționali sau de comparație în Java:
| Operator | Descriere | Exemplu |
| == | Verifică dacă valorile a doi operanzi sunt egale sau nu, dacă da, atunci condiția devine adevărată | (A == B) - nu este corect |
| != | Verifică dacă valorile a doi operanzi sunt egale sau nu, dacă valorile nu sunt egale, atunci condiția devine adevărată | (A! = B) - valoarea este adevărată |
| > | Verifică dacă valoarea operandului din stânga este mai mare decât valoarea operandului din dreapta, dacă da, atunci condiția devine adevărată | (A> B) - nu este adevărat |
| Verifică dacă valoarea operandului din stânga este mai mică decât valoarea operandului din dreapta, dacă da, atunci condiția devine adevărată | (A | |
| >= | Verifică dacă valoarea operandului din stânga este mai mare sau egală cu valoarea operandului din dreapta, dacă da, atunci condiția devine adevărată | (A> = B) - valorile nu sunt corecte |
| Verifică dacă valoarea operandului din stânga este mai mică sau egală cu valoarea operandului din dreapta, dacă da, atunci condiția devine adevărată | (A |
Exemplu
Următorul exemplu simplu arată programatic operatorii de comparație în Java. Copiați și inserați următorul cod java în fișierul test.java, compilați și rulați acest program:
Public class Test (public static void main (String args) (int a = 10; int b = 20; System.out.println ("a == b =" + (a == b)); System.out.println ("a! = b =" + (a! = b)); System.out.println ("a> b =" + (a> b)); System.out.println ("a = a =" + (b> = a)); System.out.println ("b
A == b = fals a! = B = adevărat a> b = fals a = a = adevărat b
Operatori pe biți
Java definește câțiva operatori pe biți care pot fi aplicați la tipurile întregi: int, long, short, char și byte. În Java, operatorul pe biți lucrează pe biți și efectuează operația bit cu bit. Să presupunem că a = 60; și b = 13; apoi în binar vor fi după cum urmează:
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~ a = 1100 0011
Să presupunem că variabila întreagă A este 60 și variabila B este 13. Următorul tabel listează operatorii pe biți în Java:
| Operator | Descriere | Exemplu |
| & (pe bit și) | Operatorul binar AND copiază un pic în rezultat dacă acesta există în ambii operanzi. | (A și B) vor da 12 care este 0000 1100 |
| | (pe bit sau) | Operatorul binar SAU copiază un bit dacă există în oricare dintre operanzi. | (A | B) va da 61, care este 0011 1101 |
| ^ (boolean pe biți sau) | Operatorul binar XOR copiază un bit dacă este setat într-un operand, dar nu în ambele. | (A ^ B) va da 49 care este 0011 0001 |
| ~ (complement pe biți) | Operatorul de complement al binarului și are ca efect „întorsătura” biților. | (~ A) va da -61, care este forma complementului lui 1100 0011 în notație binară |
| Operator binar de deplasare la stânga. Valoarea operanzilor din stânga este mutată la stânga cu numărul de biți specificat de operandul din dreapta. | A | |
| >> (schimba la dreapta) | Operator binar de schimbare la dreapta. Valoarea operanzilor din dreapta este mutată la dreapta cu numărul de biți specificat de operandul din stânga. | A >> 2 va da 15 care este 1111 |
| >>> (deplasare zero la dreapta) | Operator de schimbare la dreapta zero. Valoarea operanzilor din stânga este mutată la dreapta cu numărul de biți specificat de operandul din dreapta, iar valorile deplasate sunt umplute cu zerouri. | Un >>> 2 va da 15 care este 0000 1111 |
Exemplu
Următorul exemplu simplu arată operatorii pe biți în Java. Copiați și inserați următorul cod java în fișierul test.java, compilați și rulați acest program:
Public class Test (public static void main (String args) (int a = 60; / * 60 = 0011 1100 * / int b = 13; / * 13 = 0000 1101 * / int c = 0; c = a & b; / * 12 = 0000 1100 * / System.out.println ("a & b =" + c); c = a | b; / * 61 = 0011 1101 * / System.out.println ("a | b =" + c); c = a ^ b; / * 49 = 0011 0001 * / System.out.println ("a ^ b =" + c); c = ~ a; / * - 61 = 1100 0011 * / System. out.println ("~ a =" + c); c = a> 2; / * 215 = 1111 * / System.out.println ("a >> 2 =" + c); c = a >>> 2 ; / * 215 = 0000 1111 * / System.out.println ("a >>> 2 =" + c);))
Veți obține următoarea ieșire:
A & b = 12 a | b = 61 a ^ b = 49 ~ a = -61 a> 15 a >>> 15
Operatori logici
Să presupunem că variabila booleană A este adevărată și variabila B este falsă. Următorul tabel listează operatorii logici din Java:
Exemplu
Clasa publică Test (public static void main (String args) (boolean a = true; boolean b = false; System.out.println ("a && b =" + (a && b)); System.out.println (" a | | b = "+ (a || b)); System.out.println ("! (a && b) = "+! (a && b));))
Aceasta va produce următorul rezultat:
A && b = fals a || b = adevărat! (a && b) = adevărat
Operatori de atribuire
Următorii operatori de atribuire sunt acceptați de limbajul Java:
| Operator | Descriere | Exemplu |
| = | Operator de atribuire simplă, atribuie valori din partea dreaptă a operanzilor în partea stângă | C = A + B, va atribui valoarea lui A + B lui C |
| += | Operatorul de atribuire „Adăugați”, atribuie operandului din stânga valorile din dreapta | C + = A, echivalent cu C = C + A |
| -= | Operatorul de atribuire „Scădere”, acesta scade operandul din stânga din operandul din dreapta | C - = A, echivalent cu C = C - A |
| *= | Operatorul de atribuire „Multiplicare”, înmulțește operandul din dreapta cu operandul din stânga | C * = A este echivalent cu C = C * A |
| /= | Operatorul de atribuire „Diviziune”, împarte operandul din stânga cu operandul din dreapta | C / = A este echivalent cu C = C / A |
| %= | Operatorul de atribuire „Modul”, preia un modul folosind doi operanzi și atribuie rezultatul acestuia operandului din stânga | C% = A, echivalent cu C = C% A |
| Operator de atribuire a turei la stânga | C | |
| >>= | Schimbați la dreapta operator de atribuire | C >> = 2, este ca C = C >> 2 |
| &= | Operatorul de atribuire „ȘI” pe biți | C & = 2, este ca C = C & 2 |
| ^= | Operatorul de atribuire „SAU” exclusiv pe biți („XOR”) | C ^ = 2, este ca C = C ^ 2 |
| |= | Operator de atribuire pe biți SAU (SAU). | C | = 2, este ca C = C | 2 |
Exemplu
Următorul exemplu simplu arată operatori logici programatic în Java. Copiați și inserați următorul cod java în fișierul test.java, compilați și rulați acest program:
Public class Test (public static void main (String args) (int a = 10; int b = 20; int c = 0; c = a + b; System.out.println ("c = a + b =" + c) ); c + = a; System.out.println ("c + = a =" + c); c - = a; System.out.println ("c - = a =" + c); c * = a ; System.out.println ("c * = a =" + c); a = 10; c = 15; c / = a; System.out.println ("c / = a =" + c); a = 10; c = 15; c% = a; System.out.println ("c% = a =" + c); c> = 2; System.out.println ("c >> = 2 =" + c) ; c >> = 2; System.out.println ("c >> = a =" + c); c & = a; System.out.println ("c & = 2 =" + c); c ^ = a; System.out.println ("c ^ = a =" + c); c | = a; System.out.println ("c | = a =" + c);))
Veți obține următoarea ieșire:
C = a + b = 30 c + = a = 40 c - = a = 30 c * = a = 300 c / = a = 1 c% = a = 5 c> = 2 = 5 c >> = 2 = 1 c & = a = 0 c ^ = a = 10 c | = a = 10
Alti operatori
Există câțiva alți operatori acceptați de limbajul Java.
Operator ternar sau operator condiționat (? :)
Operator ternar- un operator care constă din trei operanzi și este folosit pentru a evalua expresii de tip boolean. Operatorul ternar în Java este cunoscut și ca operator condiționat. Acest. Ținta operatorului ternar sau operator condițional este de a decide ce valoare trebuie atribuită variabilei. Operatorul este scris astfel:
Variabila x = (expresie)? dacă adevărat: dacă este fals
Exemplu
Mai jos este un exemplu:
Public class Test (public static void main (String args) (int a, b; a = 10; b = (a == 1)? 20: 30; System.out.println ("Valoare b:" + b); b = (a == 10)? 20:30; System.out.println ("Valoarea b:" + b);))
Veți obține următoarea ieșire:
Valoare B: 30 Valoare b: 20
Instanța operatorului
Instanța operatorului- verifică dacă obiectul este de un anumit tip(tip de clasă sau tip de interfață) și este utilizat numai pentru variabilele obiectului referit. Operatorul instanceof este scris ca:
(variabilă obiect de referință) instanceof (clasa/tipul interfeței)
Exemple de
Dacă variabila obiectului referit din partea stângă a instrucțiunii trece verificarea pentru tipul de clasă/interfață de partea dreapta, rezultatul este adevărat. Mai jos este un exemplu și descrierea operatorului instanceof:
Clasa publică Test (public static void main (String args) (Nume șir = „Oleg”; // Următoarele vor returna adevărat deoarece tipul este String boolean rezultat = nume instanceof String; System.out.println (rezultat);))
Veți obține următoarea ieșire:
Acest operator va returna în continuare true dacă obiectul comparat este compatibil cu tipul pentru dreptul de atribuire. Urmează un alt exemplu:
Class Vehicle () public class Car extins Vehicle (public static void main (String args) (Vehicul a = mașină nouă (); rezultat boolean = o instanță de mașină; System.out.println (rezultat);))
Veți obține următoarea ieșire:
Precedența operatorului în Java
Prioritatea operatorului determină gruparea termenilor într-o expresie. Acest lucru afectează modul în care este evaluată expresia. Unii operatori au prioritate mai mare decât alții; de exemplu, operatorul de înmulțire are o prioritate mai mare decât operatorul de adunare:
De exemplu, x = 7 + 3 * 2. Aici lui x i se atribuie valoarea 13, nu 20, deoarece operatorul „*” are o prioritate mai mare decât „+”, deci mai întâi se înmulțește „3 * 2” și apoi „7”. „se adaugă”.
În tabel, operatorii cu cea mai mare prioritate sunt plasați în partea de sus, iar nivelul de prioritate este coborât spre partea de jos a tabelului. Într-o expresie, operatorii cu prioritate mare în Java vor fi evaluați de la stânga la dreapta.
| Categorie | Operator | Asociativitatea |
| Postfix | (). (punct) | De la stanga la dreapta |
| Unar | ++ - - ! ~ | De la dreapta la stânga |
| Multiplicativ | * / % | De la stanga la dreapta |
| Aditiv | + - | De la stanga la dreapta |
| Schimb | >> >>> | De la stanga la dreapta |
| Relațional | > >= | De la stanga la dreapta |
| Egalitate | == != | De la stanga la dreapta |
| „ȘI” pe biți | & | De la stanga la dreapta |
| „SAU” („XOR”) exclusiv pe biți | ^ | De la stanga la dreapta |
| „SAU” („SAU”) pe biți | | | De la stanga la dreapta |
| „ȘI” logic | && | De la stanga la dreapta |
| „SAU” logic („SAU”) | || | De la stanga la dreapta |
| Condiţional | ?: | De la dreapta la stânga |
| Misiune | = += -= *= /= %= >>= | De la dreapta la stânga |
| Virgulă | , | De la stanga la dreapta |
În lecția următoare, vom vorbi despre controlul buclei în programarea Java. Această lecție va descrie diferitele tipuri de bucle, cum pot fi utilizate buclele în dezvoltarea de software și în ce scopuri sunt utilizate.
Operatori în Java
Următorii operatori aritmetici sunt acceptați în Java (Tabelul 2.4).
Tabelul 2.4. Operatori aritmetici
Plus
- Scăderea
* Înmulțirea
/ Divizia
% Calculul restului
++ Creștere
- Scăderea
+ = Atribuire cu adaos
- = Scădere de atribuire
* = Atribuire cu înmulțire
/ = Atribuire cu împărțire
% = Atribuire cu calcul al restului
Primii cinci operatori sunt familiari tuturor curs şcolar matematică, cu doi așa-numiți operatori unari, și poate fi folosit pentru a indica semnul unui număr dat. Acesta este urmat de operatori numiți increment (++) și decrement (- -).
Una dintre ele (increment) se adaugă la valoare unitate variabilă, celălalt (scădere), dimpotrivă, scade unul.
Acești operatori sunt indicați fără spațiu lângă valoarea variabilei. Dacă sunt la stânga variabilei, atunci aceasta se numește forma de prefix a unei creșteri sau decrementări, iar aceasta înseamnă că mai întâi se adaugă (sau scade din ea) o unitate variabilei și apoi este folosită în expresie. . Dacă creșterea (sau decrementarea) este plasată după numele variabilei, atunci aceasta se numește forma postfixă, iar aceasta înseamnă că variabila este mai întâi folosită în expresie, iar apoi se adaugă (sau se scad din) una.
Ceilalți cinci operatori sunt utilizați după cum urmează:
a + = b
similar cu scrisul:
a = a + b
Un exemplu de utilizare a tuturor acestor operatori este prezentat în Lista 2.9.
Lista 2.9.
Exemplu de utilizare operatori aritmetici
Exemplu de clasă (
{
int a, b, c, d, e;
a = 10
b = 11;
c = 12;
a + = b; // a = 21
a * = c; // a = 252
a = a - c; // a = 240
a - = c; // a = 228
d = 5;
e = 10;
System.out.println (++ d); Va afișa 6
System.out.println (d ++); Va afișa 6
System.out.println (e--); Va afișa 10
System.out.println (--e); Ieșirea 8
}
}
Acum luați în considerare operatorii pe biți (pe pe biți) (Tabelul 2.5).
Tabelul 2.5. Operatori pe biți (pe pe biți).
Descrierea operatorului
- Negație unară
& ȘI pe biți
| SAU pe biți
^ SAU exclusiv pe biți
<< Сдвиг битов влево
>> Schimbați biții la dreapta
>>> Deplasați biții la dreapta, umplând bitul cel mai semnificativ cu zero
&=, | =, ^=, <<=, >> =, >>> = Atribuire cu aceeași operațiune
Cu ajutorul acestor operatori, lucrăm asupra numerelor în reprezentarea lor binară. Luați în considerare, de exemplu, scrierea numărului 15 în binar. 00001111
Primul operator, numit negație unară, transformă 0 la 1 și 1 la 0. Operatorul „și” pe biți ajunge să fie unul dacă ambii biți similari ai numerelor comparate au și 1. Dacă au o combinație diferită de numere, totalul va fi 0. De exemplu:
C = A și B
Să presupunem că A = 15 (00001111) și B este 10 (00001010). Numărul C în acest caz va fi egal cu 10 (00001010). „SAU” pe biți înseamnă următoarele: dacă cel puțin unul dintre biți este 1, atunci totalul este de asemenea 1. „SAU” exclusiv pe biți returnează 1 dacă doar unul dintre biții numerelor comparate este egal cu 1. Următorii trei operatorii mută biții la stânga cu numărul specificat de cifre, în plus, deplasarea biților la stânga umple pozițiile goale cu zerouri. Un exemplu de utilizare a acestor operatori este prezentat în tabel. 2.6 și Listarea 2.10.
Tabelul 2.6. Operatori Bit Shift
Lista 2.10.
Un exemplu de utilizare a operatorilor de deplasare de biți
Exemplu de clasă
{
public static void main (Argumente șir)
{
int a = 3, b = 4, c = 5;
int d = a * b;
System.out.println (d);
d = a | c;
System.out.println (d);
d & = a;
System.out.println (d);
}
}
Operatorii booleeni sunt acceptați și în Java, așa cum se arată în tabel. 2.7.
Tabelul 2.7. Operatori logici
Descrierea operatorului
= = Egal
! = Nu este egal
< Меньше
< = Меньше или равно
> Mai multe
> = Mai mare sau egal
& logic și
| boolean sau
^ Exclusiv logic sau
! Negare
&& Condițional și
| | Condițional sau
& =, | =, ^ = Atribuire cu același operator
Primii șase operatori se numesc operatori de comparație. Vă permit să comparați numere și să returnați fie adevărat, fie fals. Următorii patru operatori lucrează cu date de tip boolean, dar sunt similari în funcționare cu operatori de biți similari (numai trebuie să înlocuiți bitul 0 cu fals și bitul 1 cu adevărat).
Următorii doi operatori sunt utilizați pentru două condiții simultan, adică sunt specificate două condiții și între ele este plasat operatorul „ȘI condiționat”. Dacă ambele sunt adevărate, atunci adevărat este rezultat; dacă cel puțin unul dintre ele este fals, atunci totalul va fi fals.
Operatorul „condițional sau” va returna adevărat dacă cel puțin una dintre condiții este adevărată. Ele sunt utilizate în mod obișnuit în declarațiile if (vom vorbi despre asta în capitolul următor). Un exemplu de utilizare a tuturor acestor operatori este prezentat în Lista 2.11.
Lista 2.11.
Exemplu de utilizare operatori logici
Exemplu de clasă
{
public static void main (Argumente șir)
{
int a = 10, b = 15, c = 20;
boolean b1 = a! = b;
boolean b2 = c> a;
boolean b3 = b1 & b2;
boolean b4 = b3 ^ b1;
dacă (b1 && b4 = = fals) // Dacă b1! = b4, atunci:
bЗ = adevărat;
else // Dacă nu, atunci:
b2 = fals;
}
}
Iată o diagramă de utilizare a operatorilor logici (Tabelul 2.8).
Tabelul 2.8. Valorile operatorului logic pentru două variabile
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.
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).
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 modifică î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 >>";
- 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 este, de asemenea, deplasat în acest caz) - deplasare pe biți la dreapta fără a lua în considerare " >>>" semn.
ȘI pe biți
int x = 112; int y = 94; int z; z = x & y; // z = 80: 00000000 00000000 00000000 01010000SAU 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 01111110SAU 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 00101110Schimbaț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 01111100Schimbați la dreapta, ținând cont de semn
int x = - 17, z; z = x >> 2; // z = -5: 11111111 11111111 11111111 11111011Schimbaț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:- Expresia x + = b înseamnă x = x + b.
- Expresia x - = b înseamnă x = x - b.
- Expresia x * = b înseamnă x = x * b.
- Expresia x / = b înseamnă x = x / b.
- Expresia x% = b înseamnă x = x% b.
- Expresia x & = b înseamnă x = x & b.
- Expresia x | = b înseamnă x = x | b.
- Expresia x ^ = b înseamnă x = x ^ b.
- Expresia x<<= b означает x = x << b .
- Expresia x >> = b înseamnă x = x >> b.
- 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),
- " < " (меньше) " <= " (меньше или равно)
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.
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; va fi executat înainte de operația 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ă o conversie este efectuată byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ dublu, 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 provoca 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 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 primulOperatorii din 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, nu puteți folosi acești operatori pentru a lucra cu tipuri booleene, dar puteți folosi acești operatori pentru a lucra cu tipul char, deoarece în Java, tipul char este un subset al tipului 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 operatorii 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 un set suplimentar de operatori, cu ajutorul cărora 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 в том случае если в выражении присутствуют операнды типа int или целых типов меньшего размера. Если же хотя бы один из операндов в выражении имеет тип long, то и тип всего выражения повышается до long.
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 sunt pierduți. 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ă. Atenție - 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 a scădea 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. V următorul exemplu se creează mai multe variabile întregi, cu care se efectuează diverse operații folosind operatorii indicați 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 uzuale & ș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 lizibil.
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.
Scurtcircuitați operatorii logici && și || sunt destinate operațiilor logice ȘI (ȘI) și SAU (SAU) pe expresii de tip boolean. Rețineți că nu există un operator logic scurt pentru operația XOR (SAU exclusiv).
Operatorii booleeni trunchiați sunt similari cu & și |, dar sunt diferiți. numai la expresii de tip boolean și nu se aplică niciodată la tipuri integrale... Totuși, && și || au o proprietate remarcabilă: ele scurtează evaluarea unei expresii dacă rezultatul poate fi dedus dintr-o parte a expresiei (voi explica acest lucru cu exemple puțin mai târziu). Datorită acestei proprietăți, && și || sunt utilizate pe scară largă pentru a trata expresii nule. De asemenea, ajută la creșterea eficacității întregului program.
Proprietatea de scurtare rezultă direct din diferențele dintre && / || și &/ |: ultima pereche de operatori trebuie să primească valorile operatorilor stânga și dreapta, în timp ce pentru prima pereche de operatori este uneori suficient să cunoașteți valoarea doar a operandului din stânga pentru a returna valoarea întregului expresie. Acest comportament al operatorilor logici trunchiați se bazează pe doi reguli matematice tabel de adevăr logic:
- o expresie cu un operator AND este falsă (falsă) dacă valoarea a cel puțin unuia dintre operanzii săi este falsă;
- o expresie cu un operator SAU este adevărată dacă valoarea a cel puțin unuia dintre operanzii săi este adevărată.
- fals ȘI X = fals
- adevărat SAU X = adevărat
Luați în considerare un exemplu de cod care afișează un mesaj String dacă șirul nu este nul și are mai mult de 20 de caractere:
1.dacă ((s! = Null) && (s.lungime ()> 20)) (
2. System.out.println (s);
3. }
Aceeași sarcină poate fi codificată diferit:
1.dacă (s! = Null) (
2.dacă (lungimea s. ()> 20) (
3. System.out.println (s);
4. }
5. }
Dacă s ar fi nul, atunci am obține o NullPointerException atunci când apelăm metoda s.length (). Niciunul dintre cele două exemple de cod, însă, nu va avea această situație. În special, în al doilea exemplu, s.length () nu este apelat atunci când s = null, din cauza utilizării operatorului && scurtat. Dacă testul (s! = Null) a returnat false, adică s este un șir inexistent, atunci întreaga expresie este garantată a fi falsă. Aceasta înseamnă că nu este nevoie să se calculeze valoarea celui de-al doilea operand, adică expresia (s.length ()> 20).
Cu toate acestea, acești operatori au efecte secundare. De exemplu, dacă operandul din dreapta este o expresie care efectuează o operație, atunci când se utilizează operatori trunchiați, această operație poate eșua dacă operandul din stânga este fals.
Să luăm în considerare un exemplu:
// primul exemplu 1. int val = (int) (2 * Math.random ()); 2.test boolean = (val == 0) || (++ val == 2); 3. System.out.println („test =“ + test + „\ nval =“ + val); // al doilea exemplu 1. int val = (int) (2 * Math.random ()); 2.test boolean = (val == 0) | (++ val == 2); 3. System.out.println („test =“ + test + „\ nval =“ + val);
Primul exemplu va imprima uneori:
test = adevărat
val = 0
Și uneori asta:
test = adevărat
val = 2
Al doilea exemplu va imprima uneori:
test = adevărat
val = 1
Și uneori asta:
test = adevărat
val = 2
Și iată chestia. Dacă val este 0, atunci al doilea operand (++ val) nu va fi niciodată evaluat, adică val va rămâne egal cu zero... Dacă inițial val este egal cu unu, apoi ca rezultat această variabilă va fi incrementată și vom vedea val = 2. În al doilea exemplu, când se utilizează nu operatori scurtați, incrementul este întotdeauna executat și rezultatul va fi întotdeauna fie 1, fie 2, în funcție de valoarea aleatoare aleasă în primul pas. În ambele exemple, testul variabilei se evaluează la adevărat deoarece fie val = 0, fie val = 1 și este incrementat la valoarea 2.
Să rezumăm informațiile despre operatorii prescurtați && și ||:
- Se aplică operanzilor booleeni;
- Ei calculează valoarea operandului din dreapta numai dacă rezultatul nu poate fi calculat pe baza valorii operandului din stânga:
- fals ȘI X = fals
- adevărat SAU X = adevărat
