Aritmetické operácie. Operátory priraďovania bitov. Operácia odlievania

Pravdepodobne poznáte slovo „bit“. Ak nie, tak sa s ním zoznámime :) Trocha - minimálna jednotka meranie informácií v počítači. Jeho názov pochádza z angličtiny Binárna číslica” - “binárne číslo". Bit môže byť vyjadrený ako jedno z dvoch čísel: 1 alebo 0. Existuje špeciálny systém počet založený na jednotkách a nulách - binárne.

Nebudeme sa vŕtať v džungli matematiky a všimneme si len, že akékoľvek číslo v Jave je možné previesť do jeho binárnej podoby. Ak to chcete urobiť, musíte použiť obalové triedy. Napríklad tu je návod, ako to urobiť pre int: public class Main ( public static void main (String args) ( int x = 342 ; System. out. println (Integer. toBinaryString (x) ) ; ) ) Výstup na konzolu: 101010110 1010 10110 (pridal som medzeru pre čitateľnosť) je číslo 342 v binárny systém. Toto číslo sme vlastne rozdelili na samostatné bity – nuly a jednotky. Práve s nimi môžeme vykonávať operácie, ktoré sa nazývajú bitové.

~ - bitový operátor "NOT".

Funguje to veľmi jednoducho: prechádza každý bit nášho čísla a mení jeho hodnotu na opačnú: nuly na jednotky, jednotky na nuly. Ak to aplikujeme na naše číslo 342, stane sa toto: 101010110 - číslo 342 v dvojkovej sústave 010101001 - výsledok výrazu ~342 Skúsme si to v praxi: public class Main ( public static void main (String args) ( int x = 342 ; System. out. println (~ x) ; ) ) Výstup na konzolu: -343 -343 je náš bežný výsledok (číslo 010101001). desiatková sústava:)

& - bitový operátor "AND"

Ako vidíte, pravopis je dosť podobný logickému „AND“ (&&). Operátor &&, pamätajte, vracia hodnotu true iba vtedy, ak sú oba operandy pravdivé. Bitwise & funguje podobným spôsobom: porovnáva dve čísla bit po bite. Výsledkom tohto porovnania je tretie číslo. Vezmime si napríklad čísla 277 a 432: 100010101 - číslo 277 v binárnom tvare 110110000 - číslo 432 v binárnom tvare Operátor & potom porovná prvý bit horného čísla s prvým bitom spodného čísla. Keďže ide o operátor AND, výsledok bude 1, iba ak sú oba bity 1. Vo všetkých ostatných prípadoch bude výsledok 0. 100010101 & 110110000 _______________ 100010000 - výsledok práce & Najprv porovnáme prvé bity dvoch čísel medzi sebou, potom druhé bity, tretie atď. Ako vidíte, iba v dvoch prípadoch boli oba bity v číslach rovné 1 (prvý a piaty bit v rade). Všetky ostatné porovnania dopadli na 0. Preto sme skončili pri čísle 100010000. V desiatkovej sústave to zodpovedá číslu 272. Skontrolujeme: public class Main ( public static void main (String args) ( System. out. println (277 & 432 ;) ;) Výstup na konzolu: 272

• | - bitové "ALEBO". Princíp fungovania je rovnaký - porovnávame dve čísla bit po bite. Až teraz ak aspoň jeden z bitov je 1, výsledok bude 1. Pozrime sa na rovnaké čísla - 277 a 432:

100010101 | 110110000 _______________ 110110101 - výsledok práce | Tu je výsledok iný: iba tie bity, ktoré boli v oboch číslach nulové, zostali nulové. Výsledkom práce je číslo 110110101. V desiatkovej sústave zodpovedá číslu 437. Kontrola: public class Main ( public static void main (String args) ( System. out. println (277 | 432 ) ; ) ) Výstup na konzolu: 437 Všetci sme to pochopili správne! :)

• ^ - bitové exkluzívne "OR" (tiež známe ako XOR)

S takýmto operátorom sme sa ešte nestretli. Ale nie je v tom nič zložité. Je to podobné ako bežné „alebo“. Existuje len jeden rozdiel: zvyčajné „alebo“ vráti hodnotu true, ak je aspoň jeden operand pravdivý. Ale nie nevyhnutne jeden – ak sú obe pravdivé – potom je výsledok pravdivý. Ale výhradné „alebo“ sa vráti ako pravdivé iba ak je jeden z operandov pravdivý. Ak sú oba operandy pravdivé, zvyčajné „alebo“ sa vráti ako pravda („aspoň jedna je pravda“), ale výhradné alebo vrátenie falošný . Preto sa nazýva exkluzívny. Poznanie princípu predchádzajúceho bitové operácie, vy sami môžete jednoducho vykonať operáciu 277^432. Ale poďme na to ešte raz spolu prísť :) 100010101 ^ 110110000 _______________ 010100101 - výsledok práce ^ Tu je náš výsledok. Tie bity, ktoré boli rovnaké v oboch číslach, vrátili 0 (vzorec „jeden z“ nefungoval). Ale tie, ktoré tvorili pár 0-1 alebo 1-0, sa nakoniec zmenili na jednotku. Vo výsledku sme dostali číslo 010100101. V desiatkovej sústave to zodpovedá číslu 165. Pozrime sa, či sme počítali správne: public class Main ( public static void main (String args) ( System. out. println (277 ^ 432 ) ;)) Výstup na konzolu: 165 Super! Všetko je presne tak, ako sme si mysleli :) Teraz je čas zoznámiť sa s operáciami, ktoré sú tzv bitové posuny. Názov v podstate hovorí sám za seba. Zoberieme nejaké číslo a presunieme jeho bity doľava a doprava :) Pozrime sa, ako to vyzerá:

Shift doľava

Bitový posun doľava je označený znamienkom << Príklad: public class Main ( public static void main (String args) ( int x = 64 ; //hodnota int y = 3 ; //číslo int z = (x<< y) ; System. out. println (Integer. toBinaryString (x) ) ; System. out. println (Integer. toBinaryString (z) ) ; } } В этом примере число x=64 называется význam. Sú to jeho kúsky, ktoré posunieme. Posunieme bity doľava (to sa dá určiť podľa smeru znamienka<<) В двоичной системе число 64 = 1000000 Число y=3 называется množstvo. Množstvo odpovedá na otázku" koľko bitov doprava / doľava, musíte posunúť bity čísla X“ V našom príklade ich posunieme 3 bity doľava. Aby bol proces radenia jasnejší, pozrime sa na obrázok. V našom príklade sú použité čísla typu int. Int zaberá 32 bitov v pamäti počítača. Takto vyzerá naše pôvodné číslo 64:

A teraz, v pravom zmysle slova, vezmeme každý z našich bitov a posunieme sa doľava o 3 bunky:

Tu je to, čo máme. Ako môžete vidieť, všetky naše bity sa posunuli a pridali sa ďalšie 3 nuly mimo rozsahu. 3 - pretože sme sa posúvali o 3. Ak by sme sa posúvali o 10, pridalo by sa 10 núl. Takže výraz x<< y означает “сдвинуть биты числа х на y ячеек влево”. Результатом нашего выражения стало число 1000000000, которое в десятичной системе равно 512. Проверим: public class Main { public static void main (String args) { int x = 64 ; //значение int y = 3 ; //количество int z = (x << y) ; System. out. println (z) ; } } Výstup na konzolu: 512 V poriadku! Teoreticky je možné bity posúvať donekonečna. Ale keďže máme int , je k dispozícii iba 32 buniek. Z nich je 7 už obsadených číslom 64 (1000000). Ak teda urobíme napríklad 27 posunov doľava, naša jediná jednotka sa dostane mimo dosah a „prepíše sa“. Zostali len nuly! public class Main ( public static void main (String args) ( int x = 64 ; //hodnota int y = 26 ; //číslo int z = (x<< y) ; System. out. println (z) ; } } Výstup na konzolu: 0 Ako sme očakávali, ten prekročil 32 bunkových bitov a zmizol. Získali sme 32-bitové číslo pozostávajúce iba z núl.

Prirodzene, v desiatkovej sústave to zodpovedá 0. Jednoduché pravidlo na zapamätanie posunov doľava: Každý posun doľava vynásobí číslo 2. Skúsme napríklad vypočítať výsledok výrazu 111111111 bez obrázkov s bitmi<< 3 Нам нужно трижды умножить число 111111111 на 2. В результате у нас получается 888888888. Давай напишем код и проверим: public class Main { public static void main (String args) { System. out. println (111111111 << 3 ) ; } } Výstup na konzolu: 888888888

Posúva doprava

Sú označené s >> . Robia to isté, len v opačnom smere! :) Neobjavujme koleso a skúsme to urobiť s rovnakým číslom int 64. public class Main ( public static void main (String args) ( int x = 64 ; // hodnota int y = 2 ; // počet int z = ( x >> y) ; System.out.println(z) ; ) )

V dôsledku posunu o 2 doprava sa dve krajné nuly nášho čísla dostali mimo rozsah a boli vymazané. Dostali sme číslo 10000, ktoré v desiatkovej sústave zodpovedá číslu 16 Výstup na konzolu: 16 Jednoduché pravidlo na zapamätanie si posunov doprava: Každý posun doprava sa delí dvomi, pričom sa zahodí akýkoľvek zvyšok. Napríklad 35 >> 2 znamená, že musíme 35 deliť 2 2-krát, pričom zvyšok zahodíme 35/2 = 17 (zahodíme zvyšok 1) 17:2 = 8 (zahodíme zvyšok 1) Takže 35 >> 2 by sa malo rovnať 8 Kontrola: public class Main ( public static void main (String args) ( System. out. println (35 >> 2) ; ) ) Výstup na konzolu: 8

Priorita operácie v jazyku Java

V procese písania alebo čítania kódu sa často stretnete s výrazmi, v ktorých sa vykonáva niekoľko operácií súčasne. Je veľmi dôležité pochopiť, v akom poradí budú vykonané, inak môže byť výsledok neočakávaný. Keďže v Jave existuje veľa operácií, všetky boli rozdelené do špeciálnej tabuľky:

Prednosť operátora

Operátori	prednosť
postfix	expr++ expr--
unárne	++expr --expr +expr ~ !
multiplikatívne	* / %
aditívum	+ -
posun	<< >> >>>
vzťahový	< > <= >= inštancia
rovnosť	== !=
bitové AND	&
bitový exkluzívny OR	^
bitové vrátane OR	|
logické AND	&&
logické ALEBO	||
trojčlenný	? :
zadanie	= += -= *= /= %= &= ^= |= <<= >>= >>>=

Všetky operácie sa vykonávajú zľava doprava berúc však do úvahy jeho prioritu. Napríklad, ak napíšeme: int x = 6 - 4/2; najprv sa vykoná operácia delenia (4/2). Hoci je druhá v poradí, má vyššiu prioritu. Zátvorky alebo hranaté zátvorky menia akúkoľvek prioritu na maximum. Určite si to pamätáte zo školy. Napríklad, ak ich pridáte do výrazu: int x = (6 - 4)/2; odčítanie sa vykoná ako prvé, pretože sa vyhodnocuje v zátvorkách. o logický operátor Priorita && je pomerne nízka, ako vidno z tabuľky. Preto sa najčastejšie vykoná ako posledný. Napríklad: boolovská hodnota x = 6 – 4/2 > 3 && 12*12<= 119; Это выражение будет выполняться так:

• boolovská hodnota x = 6 - 2 > 3 && 12 * 12<= 119 ;



12*12 = 144


boolovská hodnota x = 6 - 2 > 3 && 144<= 119 ;

• boolovská hodnota x = 4 > 3 && 144<= 119 ;



• 4 > 3 = pravda
  

  boolean x = pravda && 144<= 119 ;



• 144 <= 119 = false
  

  boolean x = true && false ;



• Nakoniec sa operátor AND && vykoná ako posledný.

  boolean x = pravda && nepravda;
  boolean x = nepravda;
  

  Napríklad operátor sčítania (+) má vyššiu prioritu ako operátor porovnávania != (“nerovná sa”);

  Takže vo výraze:

  Booleovské x = 7 != 6+1;

  najprv sa vykoná operácia 6 + 1, potom kontrola 7!=7 (nepravda) a na konci - priradenie výsledku false k premennej X. Priradenie má vo všeobecnosti najnižšiu prioritu zo všetkých operácií – pozrite sa do tabuľky.

Fíha! Naša prednáška bola dlhá, ale zvládli ste to! Ak niektorým častiam tejto a predchádzajúcich prednášok úplne nerozumiete - nebojte sa, v budúcnosti sa týchto tém dotkneme viackrát. Tu je niekoľko užitočných odkazov pre vás:

• Vynikajúce v obrázkoch o bitových operáciách



• - JavaRush prednáška o logických a numerických operáciách. Čoskoro sa k nim nedostaneme, ale môžete si to prečítať už teraz, nebude to nič zlé

Posledná aktualizácia: 30.10.2018

Väčšina operácií v jazyku Java je podobná tým, ktoré sa používajú v iných jazykoch podobných C. Existujú unárne operácie (vykonávané na jednom operande), binárne operácie na dvoch operandoch a ternárne operácie na troch operandoch. Operand je premenná alebo hodnota (napríklad číslo), ktorá sa zúčastňuje operácie. Zvážte všetky typy operácií.

Aritmetické operácie zahŕňajú čísla. Java má binárne aritmetické operácie (vykonávané na dvoch operandoch) a unárne aritmetické operácie (vykonávané na jednom operande). Binárne operácie zahŕňajú:

operácia sčítania dvoch čísel:

int a = 10; int b = 7; int c = a + b; // 17 int d = 4 + b; // jedenásť

operácia na odčítanie dvoch čísel:

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

operácia násobenia dvoch čísel

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

operácia delenia dvoch čísel:

int a = 20; int b = 5; int c = a / b; // 4 dvojité d = 22,5 / 4,5; // 5.0

Pri delení stojí za zváženie, pretože ak sú do operácie zapojené dve celé čísla, výsledok delenia sa zaokrúhli na celé číslo, aj keď je výsledok priradený k premennej s pohyblivou alebo dvojitou hodnotou:

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

Aby výsledkom bolo číslo s pohyblivou rádovou čiarkou, jeden z operandov musí byť tiež číslo s pohyblivou rádovou čiarkou:

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

získanie zvyšku po delení dvoch čísel:

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

Existujú tiež dve unárne aritmetické operácie, ktoré sa vykonávajú s jedným číslom: ++ (prírastok) a -- (zníženie). Každá z operácií má dve odrody: prefix a postfix:

++ (prírastok predpony)

Predpokladajme, že premenná je inkrementovaná o jednotku, napr. z=++y (najprv sa hodnota premennej y zvýši o 1 a potom sa jej hodnota priradí k premennej z)

Int a = 8; intb = ++a; System.out.println(a); // 9 System.out.println(b); // deväť

++ (prírastok po prípone)

Predstavuje tiež zvýšenie premennej o jednu, napríklad z=y++ (najprv sa k z priradí hodnota y a potom sa hodnota y zvýši o 1)

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

-- (zníženie predpony)

znížiť premennú o jednu, napríklad z=--y (najprv sa hodnota premennej y zníži o 1 a potom sa jej hodnota priradí premennej z)

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

-- (postfixové zníženie)

z=y-- (najprv sa y priradí k z, potom sa y zníži o 1)

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

Priorita aritmetických operácií

Niektoré operácie majú vyššiu prioritu ako iné, a preto sa vykonávajú ako prvé. Operácie v zostupnom poradí priority:

++ (prírastok), -- (zníženie)

* (násobenie), / (delenie), % (zvyšok po delení)

+ (sčítanie), - (odčítanie)

Pri vykonávaní súboru aritmetických výrazov by sa mala brať do úvahy priorita operácií:

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

Ako prvá sa vykoná operácia inkrementácie ++b, ktorá má vyššiu prioritu - zvýši hodnotu premennej b a vráti ju ako svoj výsledok. Potom sa vykoná násobenie 5 * ++b a až posledné je sčítanie a + 5 * ++b

Zátvorky vám umožňujú predefinovať poradie hodnotenia:

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

Napriek skutočnosti, že operácia sčítania má nižšiu prioritu, bude to sčítanie, ktoré sa vykoná ako prvé, a nie násobenie, pretože operácia sčítania je uzavretá v zátvorkách.

Asociativita operácií

Okrem priority sa prevádzky líšia aj takou koncepciou, ako napr asociatívnosť. Keď majú operácie rovnakú prioritu, poradie vyhodnocovania je určené asociatívnosťou operátorov. V závislosti od asociatívnosti existujú dva typy operátorov:

Ľavé asociatívne operátory, ktoré sa vykonávajú zľava doprava

Pravé asociatívne operátory, ktoré sa vykonávajú sprava doľava

Napríklad niektoré operácie, ako je násobenie a delenie, majú rovnakú prednosť. Aký bude potom výsledok vo výraze:

int x = 10/5 * 2;

Mali by sme tento výraz interpretovať ako (10 / 5) * 2 alebo ako 10 / (5 * 2)? Koniec koncov, v závislosti od interpretácie dostaneme rôzne výsledky.

Pretože všetky aritmetické operátory (okrem prírastku a znižovania predpony) sú ľavo-asociatívne, to znamená, že sa vykonávajú zľava doprava. Preto sa výraz 10 / 5 * 2 musí interpretovať ako (10 / 5) * 2, to znamená, že výsledok bude 4.

Operácie s číslami s pohyblivou rádovou čiarkou

Treba poznamenať, že čísla s pohyblivou rádovou čiarkou nie sú vhodné pre finančné a iné výpočty, kde môžu byť kritické chyby zaokrúhľovania. Napríklad:

Dvojité d = 2,0 - 1,1; System.out.println(d);

IN tento prípad premenná d sa nebude rovnať 0,9, ako by sa dalo spočiatku predpokladať, ale 0,8999999999999999. Tieto chyby presnosti sa vyskytujú, pretože čísla s pohyblivou rádovou čiarkou sú v binárnej podobe reprezentované na nízkej úrovni, ale neexistuje žiadna binárna reprezentácia pre 0,1, ako aj pre iné zlomkové hodnoty. Ak sa teda v takýchto prípadoch zvyčajne používa trieda BigDecimal, ktorá vám umožňuje obísť takéto situácie.

Poznámky k prednáške o Jave. Lekcia 4

(žiadne) (žiadne) ::
(žiadny)
( V. Fesyunov )

Operácie (operátory) v jazyku Java

Väčšina operácií Java je jednoduchá a intuitívna. Sú to operácie ako +, -, *, /,<,>atď. Operácie majú svoje vlastné poradie vykonávania a priority. Takže vo výraze

najprv sa vykoná násobenie a potom sčítanie, pretože operácia násobenia má vyššiu prioritu ako operácia sčítania. Vo výraze

najprv sa vyhodnotí a + b a potom sa od výsledku odpočíta c, keďže poradie týchto operácií je zľava doprava.

Ale operácie Java majú svoje vlastné zvláštnosti. Bez toho, aby sme zachádzali do podrobného opisu najjednoduchších operácií, zamerajme sa na funkcie.

Začnime s úlohy. Na rozdiel od mnohých iných programovacích jazykov v Jave priradenie nie je operátor, ale operácia. Sémantiku tejto operácie možno opísať nasledovne.

• Operátor priradenia je označený symbolom "=". Vyhodnotí hodnotu svojho pravého operandu a priradí ju ľavému operandu a vráti priradenú hodnotu ako výsledok. Túto hodnotu môžu použiť iné operácie. Postupnosť viacerých operácií priradenia sa vykonáva sprava doľava.

V najjednoduchšom prípade všetko vyzerá ako obvykle.

Tu sa deje presne to, čo intuitívne myslíme – vypočíta sa súčet a a b, výsledok sa uloží do x. Ale tu sú dva ďalšie príklady.

V prvej sa najprv zadá 1 do b, výsledok operácie je 1, potom sa tento výsledok zapíše do a. V druhom príklade sa vypočíta súčet a a b a výsledok sa stratí. Je to nezmyselné, ale syntakticky platné.

Porovnávacie operácie

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

Operácie prírastku, znižovania

Toto sú operácie ++ a --. Takže y++ (prírastok) je skratka pre y = y +1 a rovnako aj operátor dekrementácie (--).

Ale s týmito operáciami je tu jedna jemnosť. Existujú v dvoch formách – prefix (++y) a postfix (y++). Pôsobenie týchto operácií je rovnaké - zväčšujú (zmenšujú operácie - znižujú) svoj operand o 1, ale ich výsledok je iný. Predponový formulár vráti hodnotu operandu, ktorá už bola zmenená o 1, a postfixový formulár vráti hodnotu operandu pred zmenou.

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

V tomto úryvku bude x nastavené na 5 a y na 7.

Operácia celočíselného delenia

Treba mať na pamäti, že delením jedného celého čísla druhým vznikne celé číslo, ktoré sa nezaokrúhľuje, ale zahodí zlomkovú časť.

Zvyšok delenia (hodnota modulo)

Java má operátor %, ktorý predstavuje zvyšok divízie.

Rozšírené operácie pridelenia

Okrem bežnej operácie "=" v Jave existujú operácie +=, -=, *=, /= atď. Sú to skratky. Takže a += b je úplne ekvivalentné a = a + b. To isté platí pre iné takéto operácie.

Booleovské operácie

! - negácia && - logické "a" || - logické "alebo"

Operandy týchto operácií musia byť typu boolean, výsledkom je boolean. Operácie && a || majú jednu vlastnosť - ich pravý operand sa nemusí vypočítať, ak je výsledok už známy z ľavého operandu. Ak je teda ľavý operand operácie && nepravdivý, potom sa pravý operand nevyhodnotí, pretože výsledok je stále falošný.

Túto vlastnosť treba brať do úvahy najmä vtedy, keď pravý operand obsahuje volanie nejakej funkcie.

Bitové logické operácie

Toto sú operácie

& - bitové "a" | - bitové "alebo" ^ - bitové "výlučné alebo" ~ - bitová negácia

Vykonajú sa pre každý pár bitov ich operandov.

Posunové operácie

<< — сдвиг влево >> - pravý posun >>> - pravý posun bez znamienka

Tieto operácie posúvajú hodnotu svojho ľavého operandu o počet bitov daný ich pravým operandom.

Podmienená prevádzka

Ide o jedinú ternárnu operáciu, t.j. operácia, ktorá má tri operandy. Preto sa na to nepoužíva jeden operačný znak, ale dva.

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

Ak<условие>pravda, vysledok bude< выражение1>, inak< выражение2>.

Napríklad „a< b ? a: b" вычисляет минимум из a и b.

Operácia odlievania

Toto je veľmi dôležitá operácia. V predvolenom nastavení sú v jazyku Java zakázané všetky konverzie, ktoré by mohli spôsobiť problémy. Takže operandu int nemôžete priradiť dlhú hodnotu. V prípadoch, keď je to stále potrebné, musíte zadať explicitnú konverziu typu.

Napríklad, nech metóda f(...) vytvorí long.

intx = (int)f(10);

Tu (int) je operácia konverzie typu. Operácia konverzie typu je označená názvom typu v zátvorkách.

Táto operácia platí nielen pre základné typy, ale aj do tried. Podrobnejšie to preskúmame, keď sa pozrieme na dedičstvo.

Literály (konštanty)

Aritmetika

Príklady aritmetických konštánt

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

Prípony sa používajú na označenie typu konštanty: l (alebo L) - dlhá, f (alebo F) - pohyblivá, d (alebo D) - dvojitá. Napríklad,

1L je jednotka, ale typu dlhá.

Booleovské literály

Booleovské literály sú true (true) a false (false)

Reťazové literály

Zaznamenané v dvojité úvodzovky, napríklad

"toto je reťazec"

Charakterové literály

Napísané v apostrofoch, napríklad "F", "w".

Reťazcové a znakové literály majú pravidlá pre písanie špeciálov. postavy. Po prvé, existuje súbor preddefinovaných špeciálov. postavy. Toto

- "\n" - koniec riadku (odriadok) - "\r" - návrat vozíka - "\t" - zarážka tabulátora

a rad ďalších.

Po druhé, môžete si výslovne zapísať kód znaku (stačí vám ho poznať). Zápis kódu sa zvyčajne vykonáva v osmičkový systém: "\001" je znak s kódom 1 atď.

Vyhlásenia

Operátor - Výraz

Syntax

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

Takýto operátor pozostáva z jedného výrazu s ";" na konci. Jeho úlohou je vyhodnotiť výraz, vypočítanú hodnotu daný výraz, je stratené. Tie. zvyčajne takýto výraz obsahuje operátor priradenia, hoci to syntax nevyžaduje.

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

Podmienečné vyhlásenie (ak)

Syntax

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

Tu<условие>je boolovský výraz, t.j. výraz, ktorý vracia true alebo false. Ako môžete vidieť zo syntaxe, časť else je voliteľná. Existuje jeden výrok po if a po else. Ak tam potrebujete dať niekoľko operátorov, potom musíte dať blokovať . Blokovať začína na „(“ a končí na „)“.

V Jave je zvykom vždy vložiť blok, aj keď je za príkazom if alebo else jeden príkaz.

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

IN posledný príklad flag je boolovská premenná alebo pole, init() je metóda volaná, ak je príznak pravdivý (povedzme „ak je nastavený príznak“).

návratové vyhlásenie (už zahrnuté)

Operátor slučky predbežných podmienok (zatiaľ)

Syntax

Kým (<условие>) <оператор>

Podobne ako pri príkaze if, aj v Jave je zvykom<оператор>vložiť do zložených zátvoriek.

Int i = 0; pričom (viac) ( x /= 2; viac = (++i< 10); }

V tomto príklade musí byť viac boolovská premenná alebo pole, x nejaká aritmetická premenná alebo pole. Cyklus sa vykoná 10-krát.

Operátor slučky po podmienke (urobiť zatiaľ)

Syntax

Do<оператор>zatiaľ čo (<условие>);

Operátor slučky postcondition sa od operátora slučky precondition líši len tým, že iterácia cyklu v ňom sa vykoná vždy aspoň raz, pričom v operátore precondition nemusí byť jedna iterácia slučky (ak je podmienka okamžite nepravdivá).

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

Príkaz slučky "s počítadlom" (pre)

Syntax

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

Názov takéhoto cyklu obsahuje tri výrazy (v najjednoduchšom prípade). Z názvu operátora môžete pochopiť, že slúži na organizáciu cyklu s počítadlom. Preto ten výraz<инициализация>sa vykoná raz pred prvou iteráciou cyklu. Po každej iterácii cyklu sa výraz vykoná<инкремент>a potom výraz<условие>. Posledný výraz musí byť logický a slúži na nastavenie podmienky pre pokračovanie cyklu. Tie. aj keď je to pravda, iterácie cyklu budú pokračovať.

Pre pohodlie pri zostavovaní operátorov slučiek s počítadlom má táto konštrukcia veľa rozšírení.

• <инициализация>nemusí byť výraz, ale popis s inicializáciou ako "int i = 0".
• <инициализация>môže byť čiarkami oddelený zoznam výrazov, napr. "i = 0, r = 1" .
• <инкремент>môže to byť aj zoznam výrazov, napr. "i++, r*=2"
• Všetky komponenty (<инициализация>, <условие>A<инкремент>) sú voliteľné. Pre vyjadrenie<условие>to znamená, že podmienka sa považuje za vždy pravdivú (to znamená, že výstup zo slučky musí byť organizovaný nejakými prostriedkami v rámci samotnej slučky).

Tie. nasledujúca slučka (nekonečná slučka) je tiež možná:

Pre (;;) (...)

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

Toto je najhospodárnejšia implementácia slučky z predchádzajúcich príkladov.

prerušte a pokračujte vo vyhlásení

V jazyku Java nie sú žiadne príkazy goto. Ako viete, goto vedie k neštruktúrovaným programom. Príkazy break a continue sú štruktúrovanými analógmi goto.

Môžu byť použité v slučkách a break možno použiť aj v príkaze switch. Vykonanie príkazu break spôsobí okamžité ukončenie cyklu. Príkaz continue spôsobí koniec aktuálnej iterácie cyklu a začiatok nového. Kontrola stavu sa v tomto prípade stále vykonáva, takže pokračovanie môže tiež spôsobiť koniec cyklu.

Pre (int i = 0; ;i++) ( ak (nepárne Iba && i%2 == 0) pokračovať; y = (x + 1)/x; ak (y - x< 0.001) break; x = y; }

Tu oddOnly je boolovská premenná. Ak je nastavený, potom sa pomocou príkazu continue preskočia všetky iterácie cyklu s párnymi číslami;

Podmienka ukončenia slučky v tento príklad sa kontroluje v strede cyklu a ak je pravdivé, cyklus sa ukončí príkazom break.

Pri vnorených slučkách môžu príkazy break a continue odkazovať nielen na slučku, v ktorej sa nachádzajú, ale aj na slučku, ktorá ju obklopuje. Za týmto účelom musí byť ohraničujúci príkaz slučky označený štítkom, ktorý musí byť špecifikovaný v príkaze break alebo continue. Napríklad,

Lbl: zatiaľ čo (...) ( ... pre (...) ( ... ak (...) break lbl; ) ...

Tu príkaz break spôsobí ukončenie ako pre slučku, a kým.

Vybrať výpis (prepnúť)

Slúži na organizáciu výberu na niektorú hodnotu jedného z niekoľkých odvetví vykonávania.

Syntax

prepínač (<выражение>) (prípad<константа1>: <операторы1>prípad<константа2>: <операторы2> . . . }

Výraz sa musí vyhodnotiť ako celé číslo resp hodnota znaku, konštanty musia byť rovnakého typu ako hodnota tohto výrazu.

„prípadové“ prvky<константа>:" sú označenia prechodu, ak sa hodnota výrazu zhoduje s konštantou, potom sa vykoná skok na toto označenie. Ak sa hodnota výrazu nezhoduje so žiadnou z konštánt, potom všetko závisí od prítomnosti predvoleného fragmentu Ak existuje, potom dôjde k skoku na predvolené označenie, ak nie je prítomné, potom sa celý príkaz switch preskočí.

• IN príkaz prepnúť fragmenty puzdra netvoria žiadne bloky. Ak za posledným príkazom tohto fragmentu prípadu nasleduje ďalší prípad, vykonávanie bude pokračovať od prvého príkazu tohto fragmentu prípadu.
• Z tohto dôvodu sa v príkaze switch zvyčajne používa príkaz break. Je umiestnený na konci každého fragmentu puzdra.

Príklad (súbor SymbolTest.java)

Zvážte demo program, ktorý používal za výpisy a prepnúť.

Tento program generuje náhodne 100 znakov latinská abeceda a klasifikuje ich ako "samohlásky", "súhlásky" a "niekedy samohlásky". Posledná kategória obsahuje znaky „y“ a „w“.

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

V tomto príklade je pre nás niekoľko nových prvkov.

• Používa sa metóda random() triedy Math. Pozrime sa na dokumentáciu pre triedu matematiky a uvidíme, čo robí.
• Vo vyhlásení char c = (char)(Math.random()*26 + "a"); k symbolu sa pripočíta aritmetická hodnota. S takýmto dodatkom k symbol Java sa skonvertuje na číslo, ktoré sa rovná kódu daného znaku.
• Vo výpise System.out.print(c + ": "); nepoužíva sa println(...), ale print(...). Metóda print(...) sa od println(...) líši len tým, že nemení tlač na Nový riadok, takže nasledujúci príkaz print(...) alebo println(...) bude pokračovať v tlači na rovnakom riadku.

Mali by ste tiež venovať pozornosť fragmentom prípadu. Formálne existuje 7 takýchto fragmentov, ale 5 z nich neobsahuje žiadne operátory. Môžeme teda uvažovať, že existujú 2 fragmenty prípadu, ale každý z nich má niekoľko označení prípadu.

Domáca úloha

• 1 Zmeňte SymbolTest.java tak, aby počet generovaných symbolov bol nastavený parametrom volania programu.
• 2 Napíšte program, ktorý bude brať dve čísla ako parametre volania - dĺžky ramien pravouhlého trojuholníka, a ako výsledok vypíše uhly v stupňoch.

(žiadny)

Posledná aktualizácia: 30.10.2018

Bitovo resp bitové operácie sa vykonávajú na jednotlivých čísliciach alebo bitoch čísel. V týchto operáciách môžu ako operandy fungovať iba celé čísla.

Každé číslo má špecifickú binárnu reprezentáciu. Napríklad číslo 4 v binárnom systéme je 100 a číslo 5 je 101 atď.

Vezmime si napríklad nasledujúce premenné:

Bajt b = 7; // 0000 0111 krátke s = 7; // 0000 0000 0000 0111

Typ bajtu zaberá 1 bajt alebo 8 bitov, v tomto poradí reprezentovaných 8 bitmi. Preto hodnota premennej b in binárny kód sa bude rovnať 00000111. Krátky typ zaberá 2 bajty alebo 16 bitov v pamäti, takže číslo tohto typu budú reprezentované 16 číslicami. A v tomto prípade bude mať premenná s v binárnom formáte hodnotu 0000 0000 0000 0111 .

Ak chcete písať čísla so znamienkom v jazyku Java, použite dodatočný kód (dvojkový doplnok), v ktorom je najvýznamnejším bitom znamienkový bit. Ak je jeho hodnota 0, potom je číslo kladné a jeho binárne vyjadrenie je rovnaké ako pri čísle bez znamienka. Napríklad 0000 0001 v desiatkovej 1.

Ak je najvýznamnejšia číslica 1, potom máme čo do činenia záporné číslo. Napríklad 1111 1111 predstavuje -1 v desiatkovej sústave. V súlade s tým 1111 0011 predstavuje -13.

Booleovské operácie

Booleovské operácie s číslami predstavujú bitové operácie. V tomto prípade sa čísla berú do úvahy v binárne zobrazenie, napríklad 2 v binárnom systéme sa rovná 10 a má dve číslice, číslo 7 je 111 a má tri číslice.

& (boolovské násobenie)

Násobenie sa vykonáva bit po bite a ak majú oba operandy bitové hodnoty rovné 1, operácia vráti 1, inak sa vráti číslo 0. Napríklad:

Int a1 = 2; //010 int b1 = 5;//101 System.out.println(a1&b1); // vysledok 0 int a2 = 4; //100 int b2 = 5; //101 System.out.println(a2 & b2); // vysledok 4

V prvom prípade máme dve čísla 2 a 5. 2 v binárnom kóde predstavuje číslo 010 a 5 predstavuje 101. Bitovým násobením čísel (0*1, 1*0, 0*1) dostaneme výsledok 000.

V druhom prípade namiesto dvoch máme číslo 4, ktoré má v prvej číslici 1, rovnako ako číslo 5, takže tu je výsledok operácie (1 * 1, 0 * 0, 0 * 1) = 100 bude číslo 4 v desiatkovom formáte.

| (logický dodatok)

Táto operácia sa vykonáva aj s binárnymi číslicami, ale teraz je vrátená jednotka, ak aspoň jedno číslo v tomto bite má jednotku (operácia "logické OR"). Napríklad:

Int a1 = 2; //010 int b1 = 5;//101 System.out.println(a1|b1); // výsledok 7 - 111 int a2 = 4; //100 int b2 = 5;//101 System.out.println(a2 | b2); // výsledok 5 - 101

^ (logické XOR)

Táto operácia sa tiež nazýva XOR, často sa používa na jednoduché šifrovanie:

int číslo = 45; // 1001 Hodnota, ktorá sa má zašifrovať - ​​v binárnom tvare 101101 int key = 102; // Šifrovací kľúč - v binárnom systéme 1100110 int šifrovanie = číslo ^ kľúč; //Výsledok bude 1001011 alebo 75 System.out.println("Šifrované číslo: " +šifrovať); int decrypt=šifrovať^kľúč; // Výsledkom bude pôvodné číslo 45 System.out.println("Dešifrované číslo: " + dešifrovať);

Vykonávajú sa tu aj bitové operácie. Ak máme rôzne hodnoty aktuálnej číslice pre obe čísla, vráti sa 1, inak sa vráti 0. Napríklad výsledkom výrazu 9 ^ 5 bude číslo 12. A na dešifrovanie čísla použijeme inverzná operácia k výsledku.

~ (logická negácia)

Bitová operácia, ktorá invertuje všetky bity čísla: ak je hodnota bitu 1, stane sa nulou a naopak.

Bajt a = 12; // 0000 1100 System.out.println(~a); // 1111 0011 alebo -13

Posunové operácie

Operácie posunu sa vykonávajú aj s číslicami čísel. Posun môže nastať doprava a doľava.

a<

a>>b - posunie číslo a doprava o b číslic. Napríklad 16>>1 posunie číslo 16 (čo je 10 000 v binárnom systéme) o jednu číslicu doprava, výsledkom čoho je 1 000 alebo 8 v desiatkovej sústave.

a>>>b - na rozdiel od predchádzajúcich typov posunov túto operáciu predstavuje posun bez znamienka - posunie číslo a doprava o b bitov. Napríklad výraz -8>>>2 sa bude rovnať 1073741822.

Ak sa teda pôvodné číslo, ktoré sa musí posunúť jedným alebo druhým smerom, vydelí dvoma, v skutočnosti sa získa násobenie alebo delenie dvoma. Preto je možné takúto operáciu použiť namiesto priameho násobenia alebo delenia dvomi, pretože operácia posunu na hardvérovej úrovni je lacnejšia ako operácia delenia alebo násobenia.

Za celú číselné typy data - 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 4.2 sumarizuje tieto operátory. Bitové aritmetické operátory pracujú s každým bitom, ako keby to bola nezávislá hodnota.

Tabuľka 4.2. Bitové aritmetické operátory

	Operátor	Výsledok		Operátor	Výsledok
		bitové AND(A)			Bitové AND (AND) s priradením
		bitový ALEBO(ALEBO)			bitový ALEBO (ALEBO) s priradením
		bitový XOR(XOR)			bitový XOR (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
		bitová unárna negácia(NIE)

Tabuľka 4.3 ukazuje, ako každý z bitových aritmetických operátorov ovplyvňuje možné bitové kombinácie svojich operandov.

Tabuľka 4.3

Shift doľava

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

posun doprava

Operátor >> znamená in jazyk Java pravý posun. Posúva všetky bity svojho ľavého operandu doprava o počet pozícií daný jeho pravým operandom. Keď sa bity ľavého operandu presunú za polohu 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. To sa deje tak, že pri posunutí doprava si čísla zachovajú svoje znamienko.

Nepopísaný pravý posun

Často sa vyžaduje, aby pri posune doprava nenastalo rozšírenie znamienkového bitu a voľné ľavé bity boli vyplnené nulami. Na tento účel sa používa operátor posunu vpravo >>> bez znamienka.

4.3. Operátori vzťahov

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 4.4.

Tabuľka 4.4

	Operátor	Výsledok
		rovná sa
		nerovná sa
		viac
		menej
		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ť!=. Všimnite si, že v Jave je rovnosť označená sekvenciou (==). Jediný znak (=) je operátor priradenia.

Relačné operátory možno použiť iba na operandy číselných typov. S ich pomocou môžete pracovať s celým číslom, skutočným a typy postáv. Každý z relačných operátorov vracia boolovský výsledok, t.j. alebo pravda, alebo falošné.