Kontakty

Základné operátory Java. Operácie na primitívnych typoch v Jave

  • 17.04.2019

Väčšina operácií na primitívne typy sa nerobí metódami, ale pomocou špeciálne znaky volal prevádzkový znak.

priraďovacia operácia

Pridelenie hodnotová premenná konštanta, zavolá sa iná premenná alebo výraz (premenné a/alebo konštanty oddelené znamienkami operátora). priraďovacia operácia a je označený „ = ", napríklad: x = 3 ; y = x; z = x; V Jave je možné použiť operátor priradenia viackrát v jednom výraze, napríklad: x1 = x2 = x3 = 0 ; Táto operácia sa vykonáva od sprava doľava, tj najprv sa premennej x3 priradí hodnota 0 , potom sa x2 priradí hodnota x3 (0) a nakoniec x1 sa priradí hodnota x2 (0) Znaky operácií, ktorých argumentom sú čísla, spadajú do dvoch kategórií : unárne(unárne) znaky operácie s jedným argumentom a binárne(binárne) s dvoma argumentmi.

Unárne operácie

Java definuje nasledujúce unárne operácie:
  • unárne mínus "-" - zmení znamienko čísla alebo výrazu na opak;
  • unary plus " + " - nevykonáva žiadne operácie s číslom alebo výrazom;
  • bitový doplnok "~" (len pre celé čísla) - invertuje všetky bity číselného poľa (zmení 0 na 1 a 1 na 0);
  • increment " ++ " (len pre celé čísla) – zvýši hodnotu premennej o 1;
  • dekrementovať " -- " (len pre celé čísla) - znižuje hodnotu premennej o 1.
Príklady unárnych operácií "+" a "-": int i = 3 , j, k; j=-i; // j = -3 k = + i; // k = 3 Príklad operácie bitového doplnku: int a = 15 ; intb; b=~a; // b = -16 Čísla a a b sú čísla zadajte int, t.j. sú interne reprezentované počítačom ako binárne celé čísla so znamienkom, ktoré sú dlhé 32 bitov, takže binárna reprezentácia čísel a a b by vyzerala takto nasledujúcim spôsobom: a = 00000000 00000000 00000000 00001111 b = 11111111 11111111 11111111 11110000 Ako môžete vidieť z tohto znázornenia, všetky 0 bity v bitoch a v 1 sa zmenia na bit na b0 Desatinné znázorneniečíslo b bude -16. Značky operátora zvýšenia a zníženia možno umiestniť pred alebo za premennú. Tieto možnosti sa nazývajú resp predpona A postfix zaznamenávanie týchto transakcií. Zápis prefixu prihlásenia operátora vráti hodnotu svojho operandu po hodnotenie výrazu. S postfixovým zápisom znak operácie najprv vráti hodnotu svojho operandu a až potom vypočíta prírastok alebo zníženie, napríklad: int x = 1 , y, z; y=++x; z= x++; Premennej y bude priradená hodnota 2, pretože x sa najskôr zvýši o 1 a potom sa výsledok priradí premennej y. Premennej z bude priradená hodnota 1, pretože z bude najskôr priradená hodnota a potom sa x zvýši o 1 . V oboch prípadoch bude nová hodnota x 2 . Je potrebné poznamenať, že v jazyku Java, na rozdiel od jazyka C, možno operácie znižovania a prírastku použiť aj na skutočné premenné ( plavákový typ a dvojité). Binárne znaky operácií sa delia na operácie s číselným výsledkom a porovnávacie operácie, ktorých výsledkom je booleovská hodnota.

Aritmetické binárne operácie

Java definuje nasledovné aritmetické binárne operácie:
  • pridanie "+";
  • odčítanie "-";
  • násobenie " * ";
  • delenie "/";
  • výpočet zvyšku delenia celých čísel " % " (vráti zvyšok delenia prvého čísla druhým a výsledok bude mať rovnaké znamienko ako dividenda), napríklad výsledok operácie 5% 3 bude 2 a výsledok operácie (-7) %(-4) sa bude rovnať -3. V Jave je možné operáciu použiť aj pre reálne premenné (typu float alebo double).
Príklady binárnych aritmetických operácií: 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 (pri delení celých čísel // zlomková časť vyradené) x5 = x%4 // x5 = 3 (zvyšok z delenia// 7 x 4)

Bitové operácie

  • Bitové operácie berú do úvahy originál číselné hodnoty ako bitové polia a vykonajte s nimi nasledujúce akcie:
  • nastavenie rytmu na i-tá pozícia výsledkového poľa je 1, ak sú oba bity in i-té pozície operandov sú rovné 1 alebo 0, inak sú bitové AND (" & ");
  • nastavenie rytmu na i-tá pozícia výsledkového poľa je 1, ak je tam aspoň jeden bit i-tá pozícia operandov je 1 alebo 0 inak - bitové OR (" | ");
  • nastavenie rytmu na i-tá pozícia výsledkového poľa je 1, ak sú bity v i-té pozície operandov sa navzájom nerovnajú, inak sú 0 - bitové exkluzívne OR (" ^ ");
  • posun doľava od bitov poľa prvého operandu o počet bitov určený druhým operandom (znakový bit čísla sa v tomto prípade nemení) - bitový posun doľava, berúc do úvahy znamienko "<< ";
  • posun doprava od bitov poľa prvého operandu o počet bitov určený druhým operandom (znakový bit čísla sa v tomto prípade nemení) – bitový posun doprava s prihliadnutím na znamienko " >>";
  • posun doprava od bitov poľa prvého operandu o počet bitov určený druhým operandom (v tomto prípade je posunutý aj znamienkový bit čísla) - bitový posun doprava bez zohľadnenia ">>>" znamenie.
Príklady bitových operácií:

  1. Bitové AND

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

  2. Bitové ALEBO

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

  3. Bitový XOR

    int x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 intz; z=x^y; // z = 46: 00000000 00000000 00000000 00101110

  4. Ľavý posun so znakom

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

  5. Pravý posun so znamienkom

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

  6. Posun doprava bez znamienka

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

Kombinované operácie

V jazyku Java pre binárne aritmetické operácie môžete použiť kombinované(zložené) znaky operácie: identifikátor operácie = výraz Toto je ekvivalentné nasledujúcej operácii: identifikátor = výraz identifikátora operácie Príklady:
  1. Výraz x += b znamená x = x + b .
  2. Výraz x -= b znamená x = x - b .
  3. Výraz x *= b znamená x = x * b .
  4. Výraz x/= b znamená x = x/b.
  5. Výraz x %= b znamená x = x % b.
  6. Výraz x &= b znamená x = x & b.
  7. Výraz x |= b znamená x = x | b.
  8. Výraz x ^= b znamená x = x ^ b .
  9. Výraz x<<= b означает x = x << b .
  10. Výraz x >>= b znamená x = x >> b .
  11. Výraz x >>>= b znamená x = x >>> b .

Porovnávacie operácie

Java definuje nasledujúce operátory porovnávania:
  • " == " (rovná sa), " !=" (nerovná sa),
  • " > " (väčšie ako), " >= " (väčšie alebo rovné),
  • " < " (меньше) " <= " (меньше или равно)
majú dva operandy a vrátia boolovskú hodnotu zodpovedajúcu výsledku porovnania ( falošné alebo pravda). Všimnite si, že pri porovnávaní dvoch hodnôt pre rovnosť v Jave, ako v C a C++, symboly " == " (dve po sebe idúce znamienka rovnosti bez medzery), na rozdiel od operátora priradenia, ktorý používa znak " = ". Použitie symbolu "=" pri porovnávaní dvoch hodnôt buď spôsobí chybu pri kompilácii, alebo spôsobí nesprávny výsledok. Príklady porovnávacích operácií: boolean isEqual, isNoEqual, is Greater, is GreatororrEqual, isLess, isLessOrEqual; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; jeEqual = x1 == x2; // isEqual = true isNonEqual = x1 != x2; // isNonEqual = false isGreater = x1 > x3; // isGreater = true // isGreaterOrEqual = true isGreaterOrEqual = x2 >= x3; jeMenej = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

boolovské operácie

boolovské operácie sa vykonávajú na booleovských premenných a ich výsledkom je aj hodnota typu boolovská hodnota. Java definuje nasledujúce boolovské operácie:
  • negácia "!" – nahradenie nepravdy pravdivou alebo naopak;
  • operátor AND "&" – výsledok je pravdivý, iba ak sú oba operandy pravdivé, inak je výsledok nepravdivý ;
  • Operácia OR " | " - výsledok je pravdivý iba vtedy , ak je aspoň jeden z operandov pravdivý , inak je výsledok nepravdivý .
  • Operátor XOR "^" - výsledok je pravdivý iba vtedy, ak sa operandy navzájom nerovnajú, inak je výsledok nepravdivý.
Operátory "&", "|" a "^", ako aj zodpovedajúce bitové operátory možno použiť v operátoroch zloženého priraďovania: " &= ", " |= " a " ^= " Okrem toho operácie " =" sú použiteľné pre booleovské operandy = " (rovná sa) a " !=" (nerovná sa). Ako môžete vidieť z definície operátorov OR a AND, operácia OR sa vyhodnotí ako pravdivá, keď je prvý operand pravdivý, bez ohľadu na hodnotu druhého operandu, a operácia AND sa vyhodnotí ako nepravda, keď je prvý operand nepravdivý. bez ohľadu na hodnotu druhého operandu. Java definuje ďalšie dva boolovské operátory: druhé verzie boolovských operátorov AND a OR, známe ako skratové boolovské operátory: skrat AND " && " a skratové OR " || ". Pri použití týchto operácií sa druhý operand vôbec nevyhodnotí, čo je užitočné v prípadoch, keď správne fungovanie pravého operandu závisí od toho, či je ľavý operand pravdivý alebo nepravdivý. Príklady boolovských operácií: boolean isInRange, isValid, isNotValid, isEqual, isNotEqual; int x = 8; isInRange = x > 0 && x< 5 ; // isInRange = false isValid = x >0 || x > 5; // isValid = true isNotValid = ! je platné; // isNotValid = false isEqual = isInRange == isValid; // isEqual = false // isNotEqual = true isNotEqual = isInRange != isValid

Podmienená prevádzka

Podmienkový operátor sa zapisuje v tvare výraz-1?výraz-2:výraz-3 . Toto najprv vyhodnotí výraz-1 , čo by malo poskytnúť boolovskú hodnotu, a potom, ak sa výraz-1 vyhodnotí ako true , vyhodnotí a vráti výraz-2 ako výsledok operácie, alebo (ak sa výraz-1 vyhodnotí ako nepravda), vyhodnotí a výraz-3 sa vráti ako výsledok operácie. Príklad podmienenej operácie: x= n> 1? 0:1; Premennej x bude priradená hodnota 0, ak n>1 (výraz n>1 sa vyhodnotí ako pravdivý) alebo 1, ak n≤1 (výraz n>1 sa vyhodnotí ako nepravda).

Prednosť operácie

Operácie vo výrazoch sa vykonávajú zľava doprava, avšak podľa ich priority. Takže operácie násobenia vo výraze y = x + z* 5 ; sa vykoná pred operáciou sčítania, pretože operácia násobenia má vyššiu prioritu ako operácia sčítania. Priority operácií (v poradí klesajúcej priority) v Jave sú uvedené v tabuľke. jeden.
Zátvorky zvyšujú prioritu operácií, ktoré sú v nich. Ak teda do vyššie uvedeného výrazu vložíte zátvorky: y = (x + z) * 5 ; potom sa najskôr vykoná operácia sčítania a potom operácia násobenia. Niekedy sa zátvorky používajú jednoducho na to, aby bol výraz čitateľnejší, napríklad: (x > 1 ) && (x<= 5 ) ;

Konverzia typu a odlievanie pri vykonávaní operácií

Operácie priraďovania a aritmetické výrazy môžu používať literály, premenné a výrazy rôznych typov, napríklad: double y; bytex; y = x + 5; Tento príklad pridá bajtovú premennú x a literál 5 (typ int) a výsledok priradí dvojitej premennej y. V Jave, podobne ako v jazyku C, je možné typové konverzie pri vyhodnocovaní výrazov vykonávať automaticky, prípadne pomocou operátora pretypovania. Pravidlá pre pretypovanie sú však trochu odlišné od pravidiel jazyka C a vo všeobecnosti sú prísnejšie ako v jazyku C. Pri vykonávaní operácie priradenia dôjde k prevodu typu automaticky, ak rozširujúca sa transformácia(rozšírenie konverzie) a dva typy sú kompatibilné. Rozširujúce sa transformácie sú transformácie byte® krátky® int® dlhý® plavák® dvojitý. Pre prevody rozšírenia sú číselné typy, vrátane celého čísla a pohyblivej rádovej čiarky, navzájom kompatibilné. Číselné typy však nie sú kompatibilné s typmi char a boolean. Typy char a boolean tiež nie sú navzájom kompatibilné. Jazyk Java tiež vykonáva automatickú konverziu typu pri ukladaní konštanty doslovného celého čísla (ktorá má štandardne typ int) do premenných typu byte , short alebo long (ak však literál má hodnotu mimo rozsahu platných hodnôt pre pri tomto type sa zobrazí chybové hlásenie: možná strata presnosti). Ak je prevod zúžený (zužujúci prevod), teda prevod je bajt ¬ krátky ¬ znak ¬ int ¬ dlhý ¬ float ¬ double , potom môže takýto prevod viesť k strate presnosti čísla alebo k jeho skresleniu. Preto zužujúce konverzie generujú diagnostiku typovej nekompatibility pri kompilácii programu a súbory tried sa negenerujú. Takáto správa sa zobrazí aj pri pokuse o konverziu výrazov typu byte alebo short na premennú typu char . Ak stále potrebujete vykonať takéto prevody, použite operáciu cast, ktorá má nasledujúci formát: ( typ konverzie) význam, kde typ konverzie definuje typ, na ktorý sa má daný previesť význam, napríklad v dôsledku vykonávania príkazov: byte x = 71 ; char symbol = (char ) x; premenná symbolu bude nastavená na „G“. Ak je hodnota s pohyblivou rádovou čiarkou priradená celočíselnému typu, potom (ak má hodnota s pohyblivou rádovou čiarkou zlomkovú časť) dôjde aj k explicitnej konverzii typu skrátenie(skrátené) čísla. Takže ako výsledok vykonania operátora int x = (int ) 77,85 ; premenná x dostane hodnotu 77 . Ak je priradená hodnota mimo rozsahu typ-konverzia , potom výsledkom prepočtu bude zvyšok vydelenia hodnoty modulom rozsahu priradeného typu (pre čísla typu byte bude modul rozsahu 256 , skrátene - 65536 , pre int - 4294967296 a dlhodobo - 18446744073709551616). Napríklad v dôsledku vykonania príkazu byte x = (byte) 514 ; premenná x dostane hodnotu 2 . Pri prevode celých čísel alebo čísel s pohyblivou rádovou čiarkou na znak , konverzia na znak nastane, ak je pôvodné číslo medzi 0 a 127, inak je znak nastavený na "?". Pri vykonávaní aritmetických a bitových konverzií sa všetky bajtové a krátke hodnoty, ako aj hodnoty char rozšíria na int , (zatiaľ čo číselná hodnota znakového kódu sa používa pri výpočtoch pre char), potom, ak je aspoň jeden operand typu long, typ celočíselného výrazu sa rozšíri na long. Ak je jeden z operandov typu float, potom sa typ úplného výrazu rozšíri na float, a ak je jeden z operandov typu double, potom je typ výsledku double. Takže, ak premenné byte a, c; krátke b; potom vo výraze a + b * c - 15 L + 1,5 F + 1,08 - 10; najprv sa pred vyhodnotením a + b*c hodnoty premenných rozšíria na int, potom, keďže konštanta 15 je typu long, sa výsledok výpočtu rozšíri na dlho pred odčítaním. Potom, keďže literál 1.5 je typu float , výsledok vyhodnotenia a + b*c - 15L sa pred pridaním do tohto literálu rozšíri na float. Pred vykonaním sčítania s číslom 1,08 sa výsledok predchádzajúcich výpočtov rozšíri na dvojnásobok (keďže skutočné konštanty sú štandardne dvojité) a nakoniec, pred vykonaním posledného sčítania, sa rozšíri doslovná 10 (štandardne int). zdvojnásobiť . Výsledok vyhodnotenia výrazu teda bude typu double . Automatické rozšírenia typu (najmä rozšírenia short a byte to int) môžu spôsobiť zle rozpoznateľné chyby počas kompilácie. Napríklad v príkazoch: byte x = 30 , y = 5 ; x = x + y; hodnota x a y sa rozšíri na int pred vykonaním sčítania a potom sa pri pokuse o priradenie výsledku výpočtu typu int bajtovej premennej vyvolá chyba. Aby sa tomu zabránilo, v druhom operátore sa musí použiť explicitná konverzia typu: x = (byte ) (x + y) ; Výraz x + y musí byť v zátvorkách, pretože priorita operácie pretypovania v zátvorkách je vyššia ako priorita operátora sčítania. Mimochodom, ak napíšeme druhý operátor ako: x += y; potom nebude žiadne chybové hlásenie. Odkaz na prvý

Väčšina operácií na primitívnych typoch sa nevykonáva pomocou metód, ale pomocou špeciálnych symbolov tzv prevádzkový znak.

priraďovacia operácia

Priradenie hodnoty konštanty, inej premennej alebo výrazu (premenné a/alebo konštanty oddelené znamienkami operátora) sa nazýva priraďovacia operácia a je označený „ = ", napríklad: x = 3 ; y = x; z = x; V Jave je možné použiť operátor priradenia viackrát v jednom výraze, napríklad: x1 = x2 = x3 = 0 ; Táto operácia sa vykonáva od sprava doľava, tj najprv sa premennej x3 priradí hodnota 0 , potom sa x2 priradí hodnota x3 (0) a nakoniec x1 sa priradí hodnota x2 (0) Znaky operácií, ktorých argumentom sú čísla, spadajú do dvoch kategórií : unárne(unárne) znaky operácie s jedným argumentom a binárne(binárne) s dvoma argumentmi.

Unárne operácie

Java definuje nasledujúce unárne operácie:
  • unárne mínus "-" - zmení znamienko čísla alebo výrazu na opak;
  • unary plus " + " - nevykonáva žiadne operácie s číslom alebo výrazom;
  • bitový doplnok "~" (len pre celé čísla) - invertuje všetky bity číselného poľa (zmení 0 na 1 a 1 na 0);
  • increment " ++ " (len pre celé čísla) – zvýši hodnotu premennej o 1;
  • dekrementovať " -- " (len pre celé čísla) - znižuje hodnotu premennej o 1.
Príklady unárnych operácií "+" a "-": int i = 3 , j, k; j=-i; // j = -3 k = + i; // k = 3 Príklad operácie bitového doplnku: int a = 15 ; intb; b=~a; // b = -16 Čísla a a b sú int , t.j. sú interne reprezentované počítačom ako binárne celé čísla so znamienkom, ktoré sú dlhé 32 bitov, takže binárne znázornenie a a b by vyzeralo takto: na 1 bit v b a 1 bit v a sa zmení na nulový bit. Desatinná reprezentácia čísla b by bola -16. Značky operátora zvýšenia a zníženia možno umiestniť pred alebo za premennú. Tieto možnosti sa nazývajú resp predpona A postfix zaznamenávanie týchto transakcií. Zápis prefixu prihlásenia operátora vráti hodnotu svojho operandu po hodnotenie výrazu. S postfixovým zápisom znak operácie najprv vráti hodnotu svojho operandu a až potom vypočíta prírastok alebo zníženie, napríklad: int x = 1 , y, z; y=++x; z= x++; Premennej y bude priradená hodnota 2, pretože x sa najskôr zvýši o 1 a potom sa výsledok priradí premennej y. Premennej z bude priradená hodnota 1, pretože z bude najskôr priradená hodnota a potom sa x zvýši o 1 . V oboch prípadoch bude nová hodnota x 2 . Treba poznamenať, že v Jave, na rozdiel od jazyka C, možno operácie znižovania a prírastku aplikovať aj na reálne premenné (typu float a double). Binárne znaky operácií sa delia na operácie s číselným výsledkom a porovnávacie operácie, ktorých výsledkom je booleovská hodnota.

Aritmetické binárne operácie

Java definuje nasledovné aritmetické binárne operácie:
  • pridanie "+";
  • odčítanie "-";
  • násobenie " * ";
  • delenie "/";
  • výpočet zvyšku delenia celých čísel " % " (vráti zvyšok delenia prvého čísla druhým a výsledok bude mať rovnaké znamienko ako dividenda), napríklad výsledok operácie 5% 3 bude 2 a výsledok operácie (-7) %(-4) sa bude rovnať -3. V Jave je možné operáciu použiť aj pre reálne premenné (typu float alebo double).
Príklady binárnych aritmetických operácií: 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 (pri delení celých čísel // zlomková časť sa zahodí) x5 = x%4 // x5 = 3 (zvyšok z delenia// 7 x 4)

Bitové operácie

  • Bitové operácie považujú pôvodné číselné hodnoty za polia bitov a vykonávajú s nimi nasledujúce operácie:
  • nastavenie rytmu na i-tá pozícia výsledkového poľa je 1, ak sú oba bity in i-té pozície operandov sú rovné 1 alebo 0, inak sú bitové AND (" & ");
  • nastavenie rytmu na i-tá pozícia výsledkového poľa je 1, ak je tam aspoň jeden bit i-tá pozícia operandov je 1 alebo 0 inak - bitové OR (" | ");
  • nastavenie rytmu na i-tá pozícia výsledkového poľa je 1, ak sú bity v i-té pozície operandov sa navzájom nerovnajú, inak sú 0 - bitové exkluzívne OR (" ^ ");
  • posun doľava od bitov poľa prvého operandu o počet bitov určený druhým operandom (znakový bit čísla sa v tomto prípade nemení) - bitový posun doľava, berúc do úvahy znamienko "<< ";
  • posun doprava od bitov poľa prvého operandu o počet bitov určený druhým operandom (znakový bit čísla sa v tomto prípade nemení) – bitový posun doprava s prihliadnutím na znamienko " >>";
  • posun doprava od bitov poľa prvého operandu o počet bitov určený druhým operandom (v tomto prípade je posunutý aj znamienkový bit čísla) - bitový posun doprava bez zohľadnenia ">>>" znamenie.
Príklady bitových operácií:

  1. Bitové AND

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

  2. Bitové ALEBO

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

  3. Bitový XOR

    int x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 intz; z=x^y; // z = 46: 00000000 00000000 00000000 00101110

  4. Ľavý posun so znakom

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

  5. Pravý posun so znamienkom

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

  6. Posun doprava bez znamienka

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

Kombinované operácie

V jazyku Java pre binárne aritmetické operácie môžete použiť kombinované(zložené) znaky operácie: identifikátor operácie = výraz Toto je ekvivalentné nasledujúcej operácii: identifikátor = výraz identifikátora operácie Príklady:
  1. Výraz x += b znamená x = x + b .
  2. Výraz x -= b znamená x = x - b .
  3. Výraz x *= b znamená x = x * b .
  4. Výraz x/= b znamená x = x/b.
  5. Výraz x %= b znamená x = x % b.
  6. Výraz x &= b znamená x = x & b.
  7. Výraz x |= b znamená x = x | b.
  8. Výraz x ^= b znamená x = x ^ b .
  9. Výraz x<<= b означает x = x << b .
  10. Výraz x >>= b znamená x = x >> b .
  11. Výraz x >>>= b znamená x = x >>> b .

Porovnávacie operácie

Java definuje nasledujúce operátory porovnávania:
  • " == " (rovná sa), " !=" (nerovná sa),
  • " > " (väčšie ako), " >= " (väčšie alebo rovné),
  • " < " (меньше) " <= " (меньше или равно)
majú dva operandy a vrátia boolovskú hodnotu zodpovedajúcu výsledku porovnania ( falošné alebo pravda). Všimnite si, že pri porovnávaní dvoch hodnôt pre rovnosť v Jave, ako v C a C++, symboly " == " (dve po sebe idúce znamienka rovnosti bez medzery), na rozdiel od operátora priradenia, ktorý používa znak " = ". Použitie symbolu "=" pri porovnávaní dvoch hodnôt buď spôsobí chybu pri kompilácii, alebo spôsobí nesprávny výsledok. Príklady porovnávacích operácií: boolean isEqual, isNoEqual, is Greater, is GreatororrEqual, isLess, isLessOrEqual; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; jeEqual = x1 == x2; // isEqual = true isNonEqual = x1 != x2; // isNonEqual = false isGreater = x1 > x3; // isGreater = true // isGreaterOrEqual = true isGreaterOrEqual = x2 >= x3; jeMenej = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

boolovské operácie

boolovské operácie sa vykonávajú na booleovských premenných a ich výsledkom je aj hodnota typu boolovská hodnota. Java definuje nasledujúce boolovské operácie:
  • negácia "!" – nahradenie nepravdy pravdivou alebo naopak;
  • operátor AND "&" – výsledok je pravdivý, iba ak sú oba operandy pravdivé, inak je výsledok nepravdivý ;
  • Operácia OR " | " - výsledok je pravdivý iba vtedy , ak je aspoň jeden z operandov pravdivý , inak je výsledok nepravdivý .
  • Operátor XOR "^" - výsledok je pravdivý iba vtedy, ak sa operandy navzájom nerovnajú, inak je výsledok nepravdivý.
Operátory "&", "|" a "^", ako aj zodpovedajúce bitové operátory možno použiť v operátoroch zloženého priraďovania: " &= ", " |= " a " ^= " Okrem toho operácie " =" sú použiteľné pre booleovské operandy = " (rovná sa) a " !=" (nerovná sa). Ako môžete vidieť z definície operátorov OR a AND, operácia OR sa vyhodnotí ako pravdivá, keď je prvý operand pravdivý, bez ohľadu na hodnotu druhého operandu, a operácia AND sa vyhodnotí ako nepravda, keď je prvý operand nepravdivý. bez ohľadu na hodnotu druhého operandu. Java definuje ďalšie dva boolovské operátory: druhé verzie boolovských operátorov AND a OR, známe ako skratové boolovské operátory: skrat AND " && " a skratové OR " || ". Pri použití týchto operácií sa druhý operand vôbec nevyhodnotí, čo je užitočné v prípadoch, keď správne fungovanie pravého operandu závisí od toho, či je ľavý operand pravdivý alebo nepravdivý. Príklady boolovských operácií: boolean isInRange, isValid, isNotValid, isEqual, isNotEqual; int x = 8; isInRange = x > 0 && x< 5 ; // isInRange = false isValid = x >0 || x > 5; // isValid = true isNotValid = ! je platné; // isNotValid = false isEqual = isInRange == isValid; // isEqual = false // isNotEqual = true isNotEqual = isInRange != isValid

Podmienená prevádzka

Podmienkový operátor sa zapisuje v tvare výraz-1?výraz-2:výraz-3 . Toto najprv vyhodnotí výraz-1 , čo by malo poskytnúť boolovskú hodnotu, a potom, ak sa výraz-1 vyhodnotí ako true , vyhodnotí a vráti výraz-2 ako výsledok operácie, alebo (ak sa výraz-1 vyhodnotí ako nepravda), vyhodnotí a výraz-3 sa vráti ako výsledok operácie. Príklad podmienenej operácie: x= n> 1? 0:1; Premennej x bude priradená hodnota 0, ak n>1 (výraz n>1 sa vyhodnotí ako pravdivý) alebo 1, ak n≤1 (výraz n>1 sa vyhodnotí ako nepravda).

Prednosť operácie

Operácie vo výrazoch sa vykonávajú zľava doprava, avšak podľa ich priority. Takže operácie násobenia vo výraze y = x + z* 5 ; sa vykoná pred operáciou sčítania, pretože operácia násobenia má vyššiu prioritu ako operácia sčítania. Priority operácií (v poradí klesajúcej priority) v Jave sú uvedené v tabuľke. jeden.
Zátvorky zvyšujú prioritu operácií, ktoré sú v nich. Ak teda do vyššie uvedeného výrazu vložíte zátvorky: y = (x + z) * 5 ; potom sa najskôr vykoná operácia sčítania a potom operácia násobenia. Niekedy sa zátvorky používajú jednoducho na to, aby bol výraz čitateľnejší, napríklad: (x > 1 ) && (x<= 5 ) ;

Konverzia typu a odlievanie pri vykonávaní operácií

Operácie priraďovania a aritmetické výrazy môžu používať literály, premenné a výrazy rôznych typov, napríklad: double y; bytex; y = x + 5; Tento príklad pridá bajtovú premennú x a literál 5 (typ int) a výsledok priradí dvojitej premennej y. V Jave, podobne ako v jazyku C, je možné typové konverzie pri vyhodnocovaní výrazov vykonávať automaticky, prípadne pomocou operátora pretypovania. Pravidlá pre pretypovanie sú však trochu odlišné od pravidiel jazyka C a vo všeobecnosti sú prísnejšie ako v jazyku C. Pri vykonávaní operácie priradenia dôjde k prevodu typu automaticky, ak rozširujúca sa transformácia(rozšírenie konverzie) a dva typy sú kompatibilné. Rozširujúce sa transformácie sú transformácie byte® krátky® int® dlhý® plavák® dvojitý. Pre prevody rozšírenia sú číselné typy, vrátane celého čísla a pohyblivej rádovej čiarky, navzájom kompatibilné. Číselné typy však nie sú kompatibilné s typmi char a boolean. Typy char a boolean tiež nie sú navzájom kompatibilné. Jazyk Java tiež vykonáva automatickú konverziu typu pri ukladaní konštanty doslovného celého čísla (ktorá má štandardne typ int) do premenných typu byte , short alebo long (ak však literál má hodnotu mimo rozsahu platných hodnôt pre pri tomto type sa zobrazí chybové hlásenie: možná strata presnosti). Ak je prevod zúžený (zužujúci prevod), teda prevod je bajt ¬ krátky ¬ znak ¬ int ¬ dlhý ¬ float ¬ double , potom môže takýto prevod viesť k strate presnosti čísla alebo k jeho skresleniu. Preto zužujúce konverzie generujú diagnostiku typovej nekompatibility pri kompilácii programu a súbory tried sa negenerujú. Takáto správa sa zobrazí aj pri pokuse o konverziu výrazov typu byte alebo short na premennú typu char . Ak stále potrebujete vykonať takéto prevody, použite operáciu cast, ktorá má nasledujúci formát: ( typ konverzie) význam, kde typ konverzie definuje typ, na ktorý sa má daný previesť význam, napríklad v dôsledku vykonávania príkazov: byte x = 71 ; char symbol = (char ) x; premenná symbolu bude nastavená na „G“. Ak je hodnota s pohyblivou rádovou čiarkou priradená celočíselnému typu, potom (ak má hodnota s pohyblivou rádovou čiarkou zlomkovú časť) dôjde aj k explicitnej konverzii typu skrátenie(skrátené) čísla. Takže ako výsledok vykonania operátora int x = (int ) 77,85 ; premenná x dostane hodnotu 77 . Ak je priradená hodnota mimo rozsahu typ-konverzia , potom výsledkom prepočtu bude zvyšok vydelenia hodnoty modulom rozsahu priradeného typu (pre čísla typu byte bude modul rozsahu 256 , skrátene - 65536 , pre int - 4294967296 a dlhodobo - 18446744073709551616). Napríklad v dôsledku vykonania príkazu byte x = (byte) 514 ; premenná x dostane hodnotu 2 . Pri prevode celých čísel alebo čísel s pohyblivou rádovou čiarkou na znak , konverzia na znak nastane, ak je pôvodné číslo medzi 0 a 127, inak je znak nastavený na "?". Pri vykonávaní aritmetických a bitových konverzií sa všetky bajtové a krátke hodnoty, ako aj hodnoty char rozšíria na int , (zatiaľ čo číselná hodnota znakového kódu sa používa pri výpočtoch pre char), potom, ak je aspoň jeden operand typu long, typ celočíselného výrazu sa rozšíri na long. Ak je jeden z operandov typu float, potom sa typ úplného výrazu rozšíri na float, a ak je jeden z operandov typu double, potom je typ výsledku double. Takže, ak premenné byte a, c; krátke b; potom vo výraze a + b * c - 15 L + 1,5 F + 1,08 - 10; najprv sa pred vyhodnotením a + b*c hodnoty premenných rozšíria na int, potom, keďže konštanta 15 je typu long, sa výsledok výpočtu rozšíri na dlho pred odčítaním. Potom, keďže literál 1.5 je typu float , výsledok vyhodnotenia a + b*c - 15L sa pred pridaním do tohto literálu rozšíri na float. Pred vykonaním sčítania s číslom 1,08 sa výsledok predchádzajúcich výpočtov rozšíri na dvojnásobok (keďže skutočné konštanty sú štandardne dvojité) a nakoniec, pred vykonaním posledného sčítania, sa rozšíri doslovná 10 (štandardne int). zdvojnásobiť . Výsledok vyhodnotenia výrazu teda bude typu double . Automatické rozšírenia typu (najmä rozšírenia short a byte to int) môžu spôsobiť zle rozpoznateľné chyby počas kompilácie. Napríklad v príkazoch: byte x = 30 , y = 5 ; x = x + y; hodnota x a y sa rozšíri na int pred vykonaním sčítania a potom sa pri pokuse o priradenie výsledku výpočtu typu int bajtovej premennej vyvolá chyba. Aby sa tomu zabránilo, v druhom operátore sa musí použiť explicitná konverzia typu: x = (byte ) (x + y) ; Výraz x + y musí byť v zátvorkách, pretože priorita operácie pretypovania v zátvorkách je vyššia ako priorita operátora sčítania. Mimochodom, ak napíšeme druhý operátor ako: x += y; potom nebude žiadne chybové hlásenie. Odkaz na prvý

Operátory v jazyku Java sú špeciálne znaky, ktoré oznamujú kompilátoru, že chcete vykonať operáciu na niektorých operandoch. Niektorí operátori vyžadujú jeden operand, sú volaní unárne. Niektoré operátory sú umiestnené pred operandmi a sú volané predpona, iní - po, sú tzv postfix operátorov. Väčšina operátorov je umiestnená medzi dva operandy, takéto operátory sa nazývajú infixovať binárne operátory. Existuje ternárny operátor, ktorý funguje na troch operandoch.

Java má zabudovaných 44 operátorov. Možno ich rozdeliť do 4 tried - aritmetické, bitové, porovnávacie operátory A hlavolam.

Aritmetické operátory

Aritmetické operátory sa používajú na výpočty rovnakým spôsobom ako v algebre (prehľad aritmetických operátorov nájdete v tabuľke nižšie). Platné operandy musia byť číselného typu. Napríklad tieto operátory nemôžete použiť s boolovskými typmi, ale môžete ich použiť s char, pretože v jazyku Java je typ char podmnožinou typu int.

Operátor

Výsledok

Operátor

Výsledok

Doplnenie

doplnenie so zadaním

odčítanie (aj unárne mínus)

odčítanie s priradením

Násobenie

násobenie s priradením

rozdelenie so zadaním

modulo

modulo s priradením

Prírastok

dekrementovať

Štyri aritmetické operácie

Nasleduje jednoduchý program, ktorý ako príklad demonštruje použitie operátorov. Všimnite si, že operátory pracujú s celočíselnými literálmi aj premennými.

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

intb = a*3;

main(String args) (

int c = b / 4;

int d \u003d b - a;

int e = -d;

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

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

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

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

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

} }

Po spustení tohto programu by ste mali dostať nasledujúci výsledok:

C:\>java BasicMath

a = 2

b = 6

c = 1

d = 4

e = -4

Modulový operátor

Operátor modulo alebo mod operátor sa označuje symbolom %. Tento operátor vráti zvyšok po vydelení prvého operandu druhým. Na rozdiel od C++ funkcia mod v Jave pracuje nielen s celými číslami, ale aj so skutočnými typmi. Nižšie uvedený program ilustruje fungovanie tohto operátora.

classModulus(

verejné statické neplatné hlavné (Stringargs ) {

int x = 42;

dvojité y = 42,3;

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

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

} }

Keď spustíte tento program, dostanete nasledujúci výsledok:

C:\>Modul

x mod 10 = 2

y mod 10 = 2,3

Aritmetické operátory priraďovania

Pre každú z aritmetické operátory existuje formulár, v ktorom sa priradenie vykonáva súčasne s danou operáciou. Nasleduje príklad, ktorý ilustruje použitie tohto druhu operátora.

trieda OpEquals(

int a = 1;

int b = 2;

int c = 3;

a + = 5;

b*= 4;

c + = a * b;

s %= 6;

} }

A tu je výsledok získaný pri spustení tohto programu:

C:>Java OpEquals

a = 6

b = 8

c = 3

zvýšenie a zníženie

V C sú 2 operátory, nazývané operátory prírastku a znižovania (++ a --), ktoré sú skratkou na pridanie alebo odčítanie jedného od operandu. Tieto operátory sú jedinečné v tom, že môžu byť použité vo forme prefixu alebo postfixu. Nasledujúci príklad ilustruje použitie operátorov prírastku a znižovania.

trieda IncDec(

public static void main (String args) (

int a = 1;

int b = 2;

int c = ++b;

int d = a++;

c++;

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

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

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

} }

Výsledkom spustenia tohto programu bude:

C:\java IncDec

a = 2

b = 3

c=4

d = 1

Operátory celočíselných bitov

Pre celočíselné číselné dátové typy - long, int, short, char a byte je definovaná doplnková množina operátorov, pomocou ktorých môžete kontrolovať a upravovať stav jednotlivých bitov zodpovedajúcich hodnôt. Tabuľka poskytuje súhrn týchto operátorov. Bitové aritmetické operátory pracujú s každým bitom, ako keby to bola nezávislá hodnota.

Operátor

Výsledok

Operátor

Výsledok

bitová unárna negácia (NIE)

bitový AND (AND)

bitový AND (AND) s priradením

bitový ALEBO (ALEBO)

bitové ALEBO (ALEBO) s priradením

bitový exkluzívny OR (XOR)

bitový exkluzívny OR (XOR) s priradením

pravý posun

pravý posun s priradením

posun doprava s nulovým polstrovaním

pravý posun s nulovou výplňou s priradením

posun doľava

posun doľava s priradením

Príklad programu, ktorý manipuluje s bitmi

Tabuľka nižšie ukazuje, ako každý z bitových aritmetických operátorov ovplyvňuje možné bitové kombinácie svojich operandov. Príklad za tabuľkou ilustruje použitie týchto operátorov v programe Java.

trieda Bitlogic(

public static void main(String args ) (

Binárny reťazec = ( "OOOO", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011" ", "1100", "1101",

"1110", "1111" };

int a = 3;//0+2+1 alebo binárne 0011

int b = 6;//4+2+0 alebo binárne 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 = " + binárne[a]);

System.out.println(" b = " + binárne[b]);

System.out.println(" ab = " + binárne[c]);

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

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

System.out.println("~a&b|a^~b = " + binárne[f]);

System.out.println("~a = " + binárne [g]);

} }

Nižšie je uvedený výsledok získaný spustením tohto programu:

C:\>Java BitLogic

a = 0011

b=0110

a | b=0111

a&b=0010

a^b=0101

~a & b | a&~b=0101

~a = 1100

Posúva doľava a doprava

Operátor<< выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями. В предыдущей главе уже говорилось об автоматическом повышении типа всего выражения до int в том слу­чае если в выражении присутствуют операнды типа int или целых типов меньшего размера. Если же хотя бы один из операндов в выражении имеет тип long, то и тип всего выражения повышается до long.

Operátor >> znamená v Jave posun doprava. Posúva všetky bity svojho ľavého operandu doprava o počet pozícií špecifikovaných pravým operandom.Keď sa bity ľavého operandu posunú za pozíciu slova úplne vpravo, stratia sa. Pri posune doprava sa uvoľnené nadradené (ľavé) bity posunutého čísla naplnia predchádzajúcim obsahom znamienkového bitu. Toto správanie sa nazýva expanzia znamienkového bitu.

Nasledujúci program skonvertuje bajtovú hodnotu na reťazec obsahujúci jej hexadecimálnu reprezentáciu. Upozorňujeme, že posunutá hodnota musí byť maskovaná, to znamená logicky vynásobená hodnotou 0 x 0 f, aby sa vymazali bity vyplnené v dôsledku rozšírenia znamienka a znížila sa hodnota na limity povolené pri indexovaní poľa hexadecimálnych číslic. .

classHexByte(

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

byte b = (bajt) 0xf1;

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

} }

Nižšie je uvedený výstup tohto programu:

C:\>java HexByte

b = 0xf1

Nepopísaný pravý posun

Často sa vyžaduje, aby pri posune doprava nenastalo rozšírenie znamienkového bitu a voľné ľavé bity sa jednoducho vyplnili nulami.

trieda ByteUShift(

static public void main (String args) (

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

byte b = (bajt) 0xf1;

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

byte d = (bajt) (b >> 4);

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

} }

V tomto príklade môže byť premenná b inicializovaná ľubovoľným záporné číslo, použili sme číslo s hexadecimálnym zobrazením 0xf1. Premennej c je priradený výsledok posunu b so znamienkom doprava o 4 bity. Ako sa očakávalo, rozšírenie znamienkového bitu spôsobí, že z 0xf1 sa stane 0xff. Potom sa do premennej d zapíše výsledok posunu b bez znamienka o 4 bity doprava. Dalo by sa očakávať, že d bude obsahovať 0x0f, ale v skutočnosti opäť dostaneme 0xff. Toto je výsledok rozšírenia znamienkového bitu vykonaného, ​​keď b bolo automaticky povýšené na int pred operáciou posunu doprava. Nakoniec sa nám vo výraze pre premennú e podarí dosiahnuť želaný výsledok – hodnotu 0x0f. Aby sme to dosiahli, museli sme pred posunom doprava logicky vynásobiť hodnotu premennej b maskou 0xff, čím sme vymazali bity vysokého rádu vyplnené pri automatickej propagácii typu. Všimnite si, že už nie je potrebné používať pravý posun bez znamienka, pretože poznáme stav znamienkového bitu po operácii AND.

C:\>java ByteUShift

b = 0xf1

b >> 4 = 0xff

b >>> 4 = 0xff

b & 0xff) >> 4 = 0x0f

Operátori bitového priradenia

Rovnako ako v prípade aritmetických operátorov, všetky binárne bitové operátory majú súvisiaci tvar, ktorý vám umožňuje automaticky priradiť výsledok operácie k ľavému operandu. Nasledujúci príklad vytvorí niekoľko celočíselných premenných a vykoná s nimi rôzne operácie pomocou vyššie uvedených operátorov.

trieda OpBitEquals(

public static void main (String args) (

int a = 1;

int b = 2;

int c = 3;

a |= 4;

b >>= 1;

od<<= 1;

a ^= c;

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

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

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

} }

Výsledky spustenia programu sú nasledovné:

C:\>Java OpBitEquals

a = 3

b = 1

c = 6

Vzťahoví operátori

Aby bolo možné porovnať dve hodnoty, Java má sadu operátorov, ktoré popisujú vzťah a rovnosť. Zoznam takýchto operátorov je uvedený v tabuľke.

Operátor

Výsledok

viac alebo rovné

menšie alebo rovné

Hodnoty akéhokoľvek typu vrátane celých čísel, reálnych čísel, znakov, boolovských hodnôt a odkazov možno porovnávať pomocou operátorov == rovnosť a nerovnosť!=. Upozorňujeme, že v jazyku Java, ako aj v jazykoch C a C ++, je kontrola rovnosti označená sekvenciou (==). Jediný znak (=) je operátor priradenia.

Booleovské logické operátory

Logické operátory typu boolean, zhrnuté v tabuľke nižšie, fungujú iba s operandmi typu boolean. Všetky binárne logické operátory berú dve boolovské hodnoty ako operandy a vracajú výsledok rovnakého typu.

Operátor

Výsledok

Operátor

Výsledok

logické AND (AND)

AND (AND) s priradením

logické ALEBO (ALEBO)

ALEBO (ALEBO) s priradením

logické exkluzívne OR (XOR)

výhradné OR (XOR) s priradením

Operátor OR pre rýchle vyhodnotenie výrazov ( skrat ALEBO)

Operátor AND pre rýchle vyhodnotenie výrazov (skrat AND)

logická unárna negácia (NIE)

ternárny operátor if-then-others

Výsledky pôsobenia logických operátorov na rôzne kombinácie hodnôt operandov sú uvedené v tabuľke.

Nižšie uvedený program takmer úplne opakuje príklad BitLogic, ktorý už poznáte. Ale tentoraz pracujeme s booleovskými booleanmi.

trieda BoolLogic(

public static void main (String args) (

boolean a = true;

boolean b = nepravda;

boolean c = a | b;

boolovské d = a&b;

booleane=a^b;

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

boolovské 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 = pravda

b = nepravda

a|b = pravda

a&b = nepravda

a^b = pravda

!a&b|a&!b = pravda

!a = nepravda

Skratové logické operátory

K množine logických operátorov pribudli dva zaujímavé prírastky. Toto sú alternatívne verzie operátorov AND a OR na rýchle vyhodnotenie boolovských výrazov. Viete, že ak je prvý operand operátora OR pravdivý, potom bez ohľadu na hodnotu druhého operandu je výsledok operácie pravdivý. Podobne v prípade operátora AND, ak je prvý operand nepravdivý, potom hodnota druhého operandu neovplyvní výsledok – vždy bude nepravdivý. Ak používate && a || namiesto pravidelné formy& a |, potom Java nevyhodnocuje pravý operand booleovského výrazu, ak je odpoveď jasná z hodnoty ľavého operandu. Bežnou praxou je použitie && a || takmer vo všetkých prípadoch vyhodnocovanie booleovských logických výrazov. Verzie týchto operátorov & a | platí len pre bitovú aritmetiku.

Ternárny operátor if-then-others

Všeobecná forma príkazu if-then-use je:

výraz 1? výraz2: výraz3

Ako prvý operand - "výraz1" - možno použiť akýkoľvek výraz, ktorého výsledkom je booleovská hodnota. Ak je výsledok pravdivý, potom sa vykoná príkaz zadaný druhým operandom, teda "výraz2". Ak je prvý operand nepravdivý, vykoná sa tretí operand - "výraz3". Druhý a tretí operand, t. j. výraz2 a výraz3, musia vrátiť hodnoty rovnakého typu a nesmú byť typu void.

Nižšie uvedený program používa tento operátor na kontrolu deliteľa pred vykonaním operácie delenia. V prípade nulového deliteľa sa vráti hodnota 0.

trieda Ternary(

public static void main (String args) (

int a = 42;

int b = 2;

int c = 99;

int d = 0;

int e = (b == 0) ? 0:(a/b);

int f = (d == 0) ? 0:(c/d);

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

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

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

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

System.out.println("a / b = " + e);

System.out.println("c / d = " + f);

} }

Tento program nevyvoláva výnimku delenia nulou a vytvára nasledujúce výsledky:

C:\>java Ternary

a = 42

b = 2

c = 99

d=0

a/b=21

c/d = 0

Prednosť operátora

Java má špecifické poradie alebo prednosť operácií. V elementárnej algebre nás učili, že násobenie a delenie má vyššiu prednosť ako sčítanie a odčítanie. Pri programovaní musíte sledovať aj priority operácií. Tabuľka uvádza v zostupnom poradí prioritu všetkých operácií v jazyku Java.

Prvý riadok tabuľky obsahuje tri neobvyklé operátory, o ktorých sme ešte nehovorili. Zátvorky () sa používajú na explicitné nastavenie priority. Ako ste sa dozvedeli v predchádzajúcej kapitole, hranaté zátvorky sa používajú na indexovanie premennej poľa. Operátor. (bodka) sa používa na oddelenie prvkov od referencie na objekt – o tom si povieme v kapitola 7. O všetkých ostatných operátoroch sme už hovorili v tejto kapitole.

Jednoznačné priority

Keďže najvyššia priorita je okrúhle zátvorky, vždy môžete k výrazu pridať viacero párov zátvoriek, ak máte pochybnosti o poradí hodnotenia alebo len chcete, aby bol váš kód čitateľnejší.

a >> b + 3

Ktorý z týchto dvoch výrazov, a >> (b + 3) alebo (a >> b) + 3, zodpovedá prvému riadku? Keďže operátor sčítania má vyššiu prioritu ako operátor shift, správna odpoveď je a>> (b + ale). Ak teda potrebujete vykonať operáciu (a>>b )+ 3 zátvorky sú nevyhnutné.

Takže sme zvážili všetky druhy operátorov jazyka Java. Teraz môžete vytvoriť akýkoľvek výraz od rôzne druhyúdajov. IN ďalšia kapitola zoznámime sa s rozvetvenými konštrukciami, organizáciou cyklov a naučíme sa ovládať vykonávanie programu.




Súvisiace články

Najnovšie články
Populárne články
Voľba redaktora
rzdoro.ru