Image
22.6.2016 0 Comments

Java pod lupou I. /4.časť

Späť na úvod >> Späť na programovanie >> Späť na seriál

Operátory (pokračovanie)

Vo štvrtej časti seriálu, poslednej v tomto storočí, pokračujeme opisom operátorov, ktoré jazyk Java poskytuje programátorovi na prácu s údajmi. Dosiaľ sme prebrali základné aritmetické operátory +, –, *, / a % a dva operátory inkrementácie/dekrementácie ++ a ––.

Relačné operátory

Ďalšou skupinou operátorov sú tzv. relačné operátory. Pojem relácia bude laikovi pravdepodobne evokovať nejaký vzťah. Skutočne, relačné operátory v Jave slúžia na zistenie, či sú dva výrazy v požadovanom vzťahu. Relácie, ktoré tieto operátory rozpoznávajú, sú dobre známe z matematiky: ide o rovnosť a ostrú a neostrú nerovnosť.

Operátory testujúce nerovnosť dvoch výrazov sú štyri: <, <=, >, >=. Vzťahy, ktoré reprezentujú, sú po rade „menší“, „menší alebo rovný“, „väčší“ a „väčší alebo rovný“. Znaky operátorov neostrej nerovnosti <= a >= treba zapisovať v uvedenom poradí, nikdy nie naopak.

Všetky štyri operátory sú binárne. Ich operandy musia byť povinne primitívne číselné typy a výsledok je vždy typu boolean. Z toho vyplýva, že i keď sa asociujú zľava doprava, nemá asociácia v tomto prípade nijaký význam, pretože zápis a < b < c povedie k chybe pri preklade (a < b je typu boolean, ktorý nemožno porovnávať s premennou c, nech by bola akéhokoľvek typu).

V prípade, že porovnávame výrazy typu float alebo double, je výsledkom NaN, ak je aspoň jeden z operandov NaN. Na účely porovnávania prostredníctvom operátorov <, >, <= a >= sú čísla „kladná nula“ a „záporná nula“ rovné a výraz –0.0 < +0.0 vráti false.

Ďalšie dva relačné operátory, == a !=, zisťujú rovnosť, resp. nerovnosť dvoch výrazov. Oba sú navzájom komplementárne a vždy platí, že a!=b má rovnakú hodnotu ako !(a==b). Aj tieto operátory sú binárne a ich výsledok je vždy typu boolean. Čo sa však týka typu ich operandov, máme k dispozícii trochu širšiu oblasť použitia.

Predovšetkým môžu byť operandmi == a != primitívne číselné typy. Pri porovnávaní výrazov typu float/double platí, že ak je aspoň jeden z operandov NaN, výsledok == je false, výsledok != je true. Kladná a záporná nula sú považované za navzájom rovné.

Druhá možnosť je porovnávať operandy typu boolean. Za pozornosť stojí, že v takom prípade je výsledok operátora != totožný s výsledkom operátora ^ (pozri ďalej).

Konečne môžeme pomocou operátorov == a != porovnávať výrazy referenčných typov. Treba si rýchlo spomenúť na predchádzajúcu časť seriálu, kde sme uviedli, že premenné referenčných typov obsahujú iba adresu, odkaz na skutočné údaje, uložené niekde inde v pamäti. (Na zopakovanie: referenčnými typmi sú v Jave objekty [inštancie tried] a polia). Po krátkej úvahe dospejeme k záveru, že operátor == aplikovaný na dve premenné referenčného typu vráti true len vtedy, ak obe premenné budú ukazovať na jeden a ten istý objekt či pole. Operátor != v takom prípade vráti, pochopiteľne, false.

Relačné operátory sa používajú najmä v podmienkových výrazoch príkazov if, for či while. Príkazom Javy budeme venovať samostatnú časť seriálu, preto na demonštráciu aplikácie operátorov použijeme len takýto jednoduchý príklad:

int a = –5;
int b = 14;
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 >= b) = " + (a >= b));
System.out.println("(a == b) = " + (a == b));
System.out.println("(a != b) = " + (a != b));
 
boolean c = true;
boolean d = false;
System.out.println("(c == d) = " + (c == d));
System.out.println("(c != d) = " + (c != d));
 
int pa[] = { 1, 2, 3 };
int pb[] = pa;
int pc[] = { 1, 2, 3 };
System.out.println("(pa == pb) = " + (pa == pb));
System.out.println("(pa == pc) = " + (pa == pc));

Výsledkom aplikácie jednotlivých operátorov budú po rade literály true, true, false, false, false, true (prvá časť programu), false, true (druhá časť programu) a true, false (tretia časť programu). Ako vidieť, premenné pa a pb ukazujú na to isté pole, preto sa z pohľadu operátora == navzájom „rovnajú“. Premenné pa a pc sa však „nerovnajú“ napriek tomu, že polia, ktoré reprezentujú, majú rovnaké hodnoty prvkov. Vyskúšanie aplikácie operátorov na iné hodnoty ponechávam na čitateľovi.

Aby bolo vymenovanie relačných operátorov úplné, nesmieme vynechať operátor instanceof, ktorý pomôže pri zisťovaní skutočného typu výrazu. To však platí len pre referenčné typy, výrazy primitívnych typov takto identifikovať nemožno. Operátor instanceof je binárny, ľavým operandom musí byť výraz referenčného typu, pravým operandom je literál predstavujúci vyšetrovaný typ. Ak je typ ľavého operandu zhodný s pravým operandom, výsledkom je hodnota true, inak je výsledkom false.

Typickým príkladom použitia môže byť obslužná rutina nejakej udalosti grafického používateľského rozhrania, ktorá zisťuje, ktorý prvok GUI má udalosť „na svedomí“:

if (sender instanceof Button)
{
    // ...
}

Predpokladáme, že premenná sender obsahuje odkaz na objekt predstavujúci prvok GUI, ktorý udalosť spôsobil. Trieda Button by mohla reprezentovať prvky typu „tlačidlo“, potom bude uvedený príkaz if testovať, či je zdrojom udalosti niektoré tlačidlo.

Bitové a logické operátory

Podobne ako C++ možno nájsť v Jave niekoľko operátorov, ktoré pracujú s bitovou reprezentáciou čísel. Jednotlivé bity celočíselných premenných či hodnôt môžeme považovať za logické premenné a aplikovať na ne základné funkcie boolovskej algebry: logický súčin (AND), logický súčet (OR), exkluzívny logický súčet (takisto nonekvivalencia – XOR) a negáciu (NOT). Pre tieto štyri logické funkcie sú v Jave určené štyri operátory: &, |, ^ a ~. V tabuľke 1 nájde čitateľ funkčné hodnoty logických funkcií pre jednotlivé kombinácie bitových hodnôt.

***** DTP *****
Niekde v tomto okolí by som prosil umiestniť tabuľku 1.
***** DTP *****

Operátory majú prívlastok bitové z toho dôvodu, že realizujú logické funkcie bit po bite, vždy medzi zodpovedajúcimi bitmi svojich operandov (výnimkou je, samozrejme, operátor negácie, ktorý je unárny a má len jediný operand).

Operátor bitového logického súčinu & slúži na výpočet logického súčinu dvoch celočíselných hodnôt. Ide teda o binárny operátor, ktorý sa asociuje podobne ako aditívne či multiplikatívne operátory zľava doprava. Príklad logického súčinu dvoch premenných typu int:

int a = 0x3CA8;
int b = 0xCAFE;
int c = a & b;
System.out.println("a & b = " + c);

Výstupom tohto programu bude číslo 2216, hexadecimálne 0x08A8, ktoré je skutočne výsledkom logického súčinu hodnôt 0x3CA8 a 0xCAFE, o čom sa môžeme ľahko presvedčiť prepísaním hodnôt premenných a a b a výsledku c do dvojkovej sústavy.

Argumentmi operátora & môžu byť okrem celočíselných hodnôt či premenných aj premenné a hodnoty typu boolean. Tie, ako vieme, sú široké len jeden bit. Logický súčin sa realizuje nad týmto jediným bitom a výsledky sú v zhode s tabuľkou 1, len s tým rozdielom, že namiesto číselných hodnôt 0 a 1 uvažujeme pri logických premenných literály false a true. O tom ostatne svedčí nasledujúci úsek programu:

System.out.println("true & false = " + (true & false));

ktorého výstupom bude, pochopiteľne, literál false.

Operátor bitového logického súčtu | realizuje výpočet logického súčtu jednotlivých bitov svojich dvoch operandov. Opäť ide o binárny operátor s asociáciou zľava doprava. Použitie ukážeme na modifikácii predchádzajúceho príkladu:

int a = 0x3CA8;
int b = 0xCAFE;
int c = a | b;
System.out.println("a | b = " + c);

Tentoraz je výstupom hodnota 65278, hexadecimálne 0xFEFE. O správnosti výsledku sa opätovne možno presvedčiť prepisom hodnôt do dvojkovej sústavy.

Aj operátor | dokáže spracovať logické premenné typu boolean. Výstupom nasledujúceho riadka:

System.out.println("true | false = " + (true | false));

je teda literál true.

Operátor bitového exkluzívneho logického súčtu ^ nás už iste ničím neprekvapí. Slúži na výpočet funkcie XOR, ktorá na rozdiel od funkcie OR (tzv. inkluzívneho logického súčtu) vylučuje súčasnú platnosť oboch svojich argumentov. (To je ostatne jediný bod, v ktorom sa XOR líši od OR.) Aj tento operátor je binárny a asociuje sa zľava doprava. Obligátny príklad:

int a = 0x3CA8;

int b = 0xCAFE;
int c = a ^ b;
System.out.println("a ^ b = " + c);

Program poskytne výsledok 63062, hexadecimálne 0xF656.

Ani operátor ^ nám neodoprie možnosť aplikovať ho na hodnoty typu boolean:

System.out.println("true ^ true = " + (true ^ true));

Ako uvidíme po spustení, exkluzívnym logickým súčtom dvoch hodnôt true je presne podľa predpokladov hodnota false.

Operátor bitovej negácie ~ našťastie trochu narúša doterajší stereotyp. Ako vyplýva z povahy negácie, tento operátor bude unárny a asociovať sa bude podobne ako iné unárne operátory sprava doľava. Aplikovať ho však môžeme výhradne na premenné celočíselného typu:

int a = 0x3CA8;
int b = ~a;
System.out.println("~a = " + b);

Výstupom bude bitová negácia hodnoty 0x3CA8, čo je dekadicky –15529 (typ int je znamienkový, spomínate si?) a hexadecimálne 0xFFFFC357 (pretože typ int má šírku 32 bitov).

Veľký pozor si treba dať pri pokuse o negáciu premenných typu boolean. V takom prípade totiž nemožno použiť operátor bitovej negácie ~. Našťastie Java je v tomto smere ohľaduplná a ako náhradu ponúka operátor logickej negácie !. Pre tento operátor inak platí všetko, čo sme uviedli o operátore ~. Ešte krátky príklad:

System.out.println("!true = " + !true);

Ako sa môžeme presvedčiť, negáciou hodnoty true je (prekvapujúco :) hodnota false.

V Jave podobne ako v C++ existujú okrem bitových operátorov logického súčinu & a logického súčtu | ešte iné dva logické operátory && a ||, realizujúce na pohľad rovnaké logické funkcie. Oba operátory sú binárne a asociujú sa zľava doprava, ich operandy však musia byť typu boolean. Okrem toho sa operátory && a || líšia od svojich jednoznakových náprotivkov v pomerne zásadnej veci: spomeňme si, že operandy operátora sa v Jave vyhodnocujú vždy zľava doprava. Ak sa však ľavý operand operátora && vyhodnotí ako false, výsledok už nemôže byť iný ako false, preto sa pravý operand ani nevyhodnocuje. Podobne operátor ||: ak má jeho ľavý operand hodnotu true, výsledok bude za každých okolností true a pravý operand sa nevyhodnotí.

Na demonštráciu uvedených vlastností operátorov && a || slúži nasledujúci príklad:

int i = 10;
boolean never = false;
boolean r1 = (i < 0) && (never = true);
boolean r2 = (i > 0) || (never = true);
System.out.println("r1 = " + r1 + ", r2 = " + r2);
System.out.println("never = " + never);

Výstup programu:

r1 = false, r2 = true

never = false

nám potvrdí, že pri vyhodnocovaní výrazov priraďujúcich hodnoty premenným r1 a r2 sú výsledky známe už po vyhodnotení príslušných podmienok a k priradeniu true do premennej never nikdy nedôjde.

Čitateľ ovládajúci C++ si azda v súvislosti s operátorom && všimne zásadný rozdiel medzi C++ a Javou. V C++ môžu byť operandy && ľubovoľného číselného typu. Zoberme si teda napríklad čísla 5 a 10. Výraz 5 && 10 je vyhodnotený ako pravdivý (jeho hodnota je 1), zatiaľ čo výraz 5 & 10 je vyhodnotený ako 0, pretože oba operandy majú spodné štyri bity „na preskáčku“ (0101 a 1010). V Jave operandy && môžu byť iba typu boolean a výsledok aplikácie operátora && bude rovnaký ako výsledok aplikácie &, rozdiel je len v prípadnom skrátenom vyhodnocovaní. Zatiaľ čo teda v C++ je potrebné podmienky reťaziť operátorom && (ako napr. a >= 100 && a < 200), v Jave môžeme použiť aj operátor &. Pozor treba dať iba na to, aby výsledok aplikácie & bol typu boolean, pretože podmienkové výrazy v príkazoch if, while a pod. musia byť výhradne typu boolean.

Praktická aplikácia bitových operátorov

Bitové operátory &, | a ^ možno s úspechom použiť pri manipulácii s jednotlivými bitmi celočíselných premenných. V praxi sa obyčajne vyskytne potreba vybrané bity určitej premennej nastaviť, vynulovať alebo preklopiť do opačného stavu. Ostatné bity by sme radi ponechali v pôvodnom stave. Riešenie tejto úlohy je pomerne jednoduché, stačí dobre ovládať vlastnosti logických funkcií.

Pre nastavenie vybraných bitov s úspechom využijeme funkciu logického súčtu OR. Ako vyplýva z tabuľky jej funkčných hodnôt (tab. 1), logický súčet s jednotkovým bitom je vždy jednotka, logický súčet s nulovým bitom pôvodný bit nemení. Ako druhý operand operátora | teda použijeme číslo, v ktorom sú jednotkové tie bity, ktoré chceme nastaviť, a nulové všetky ostatné. Príklad:

byte b = 0x29;
System.out.println("b | 0x07 = " + (b | 0x07));

Chceme nastaviť spodné tri bity, použijeme teda číslo 0x07. Výsledok bude podľa očakávania číslo 0x2F (resp. 47 dekadicky).

Na nulovanie vybraných bitov sa hodí funkcia logického súčinu AND. Logický súčin ľubovoľnej hodnoty s nulou je vždy nula, logický súčin s jednotkou pôvodný bit zachová. Tentoraz teda použijeme ako druhý operand operátora & číslo, v ktorom sú nulové tie bity, ktoré potrebujeme vynulovať; ostatné bity zadáme jednotkové. Príklad:

 
byte b = 0x29;
System.out.println("b & 0xF8 = " + (b | 0xF8));

Tentoraz chceme vynulovať spodné tri bity, vhodným operandom bude číslo 0xF8. Výsledkom je hodnota 0x28 alebo dekadicky 40.

Konečne negáciu vybraných bitov realizujeme pomocou funkcie exkluzívneho logického súčtu XOR. Tá má tú vlastnosť, že ak XORujeme ľubovoľný bit s jednotkou, výsledkom je presne opačná hodnota. Nula pôvodný bit nemení. Operand operátora ^ vytvoríme rovnakým spôsobom ako pri nastavovaní bitov. Príklad:

byte b = 0x29;

System.out.println("b ^ 0x07 = " + (b ^ 0x07));

Opätovne použijeme číslo 0x07, výsledkom negácie spodných troch bitov hodnoty 0x29 bude číslo 0x2E, dekadicky 46.

Číslo, ktoré používame ako druhý operand operátorov &, | a ^, sa nazýva maska. Je vhodné uložiť si masku do samostatnej premennej (prípadne konštantnej premennej – uvidíme neskôr, ako ju deklarujeme). Potom ju môžeme používať veľmi elegantným spôsobom:

final byte MASK = 0x07;
b = b | MASK;   // nastavenie
b = b & ~MASK;  // nulovanie
b = b ^ MASK;   // negácia

Všimnite si, ako dosiahneme príslušnú masku na nulovanie bitov – jednoducho masku uloženú v premennej MASK negujeme pomocou operátora ~. Výsledkom negácie 0x07 je, samozrejme, hodnota 0xF8.

Nakoniec treba podotknúť, že uvedené príklady pracovali s osembitovými hodnotami typu byte. Pri použití iných typov (short, int, long) treba rátať so širším rozsahom, ale princíp zostáva rovnaký.

Operátory bitového posunu

Pri operátoroch, ktoré berú do úvahy bitovú reprezentáciu čísel, ešte chvíľu zostaneme. V praxi občas nastane situácia, že potrebujeme zmeniť hodnotu nejakej premennej takým spôsobom, aby jej jednotlivé bity zmenili svoju polohu o jednu či viac pozícií doľava alebo doprava.

Operátory bitového posunu sú tri: operátor posunu vľavo <<, operátor znamienkového posunu vpravo >> a operátor neznamienkového posunu vpravo >>>. Všetky tri operátory sú binárne a asociujú sa zľava doprava. Ľavým operandom je posúvaná hodnota, pravým operandom je počet pozícií, o ktorý sa bity posunú. Typy oboch operandov musia byť celočíselné.

Pri posune vľavo bity, ktoré z čísla „vyliezajú“ na ľavom konci, miznú do nenávratna, sprava sa prisúvajú nuly. Pri posune vpravo so znamienkom (operátor >>) končia svoju existenciu bity vychádzajúce na pravom konci, zľava sa prisúva bit zhodný s najvyšším, t. j. znamienkovým bitom pôvodnej hodnoty (iný pohľad: najvyšší bit zostáva na svojom mieste a do posunu posiela svoju kópiu). Posun vpravo bez znamienka (operátor >>>) sa líši od znamienkového posunu iba tým, že zľava sa prisúvajú vždy nuly.

Ukážeme si aplikáciu všetkých troch operátorov na praktickom príklade:

int b = 0xCAFEBABE;
System.out.println("b <<  3 = " + (b <<  3));
System.out.println("b >>  3 = " + (b >>  3));
System.out.println("b >>> 3 = " + (b >>> 3));

Po spustení príkladu dostaneme tri hodnoty, ktoré po prevode do šestnástkovej sústavy budú po rade 0x57F5D5F0, 0xF95FD757 a 0x195FD757. Prepis týchto hodnôt v binárnom tvare nás presvedčí o tom, že sa bity pôvodnej hodnoty 0xCAFEBABE skutočne posunuli o tri pozície doľava či doprava. Ako tiež vidíme, operátor >> zachoval záporné znamienko pôvodného čísla, zatiaľ čo operátor >>> vrátil kladné číslo (s nulovým najvyšším bitom).

Pozorný čitateľ si isto uvedomil, že zmena pozície jednotlivých bitov má na svedomí zmenu príslušného exponentu pri prevode celého čísla do a z dvojkovej sústavy. Skutočne, posun vľavo o n bitov je totožný s násobením čísla hodnotou 2n. Naproti tomu znamienkový posun vpravo o n bitov zodpovedá celočíselnému deleniu hodnotou 2n. Neznamienkový posun vpravo je ekvivalentný deleniu mocninou dvojky len pre kladné čísla.

V súvislosti s operátormi bitového posunu treba spomenúť fakt, že posúvané čísla sú vnútorne konvertované na jeden z typov int alebo long (podľa rozsahu), takže výsledkom posunu premennej typu byte, obsahujúcej hodnotu 0xFF, vľavo o štyri bity nebude očakávaná hodnota 0xF0, ale hodnota 0x00000FF0 typu int (v prípade, že potrebujeme výsledok šírky typu byte, musíme ho orezať pomocou operátora &). S ohľadom na šírku typov int a long sa z pravého operandu, vyjadrujúceho „vzdialenosť“ posunu, uvažuje len spodných päť, resp. šesť bitov.

Podmienkový operátor ?:

Ďalší javovský operátor ?: bude dobre známy čitateľovi znalému C++. Na rozdiel od doteraz prebraných operátorov je operátor ?: ternárny, pracuje s tromi operandmi. Asociuje sa sprava doľava, výraz a?b:c?d:e sa preto vyhodnotí ako a?b:(c?d:e).

Sémantika operátora ?: je nasledujúca: vyhodnotí sa prvý operand, ktorý musí byť typu boolean. Týmto prvým operandom je obyčajne nejaká podmienka. Ak je hodnota prvého operandu true, vyhodnotí a vráti sa druhý operand, ak false, vyhodnotí a vráti sa tretí operand. Druhý a tretí operand musia byť rovnakého typu. Je dôležité vedieť, že v závislosti od splnenej či nesplnenej podmienky sa vyhodnotí buď druhý operand, alebo tretí operand, nikdy nie oba naraz.

Príklad použitia – chceme zistiť najväčšiu hodnotu z troch čísel a, b a c:

int a = 123, b = 17, c = –229;
int max = a>b ? (a>c ? a : c) : (b>c ? b : c);
System.out.println("max(a, b, c) = " + max);

V príklade sa najprv porovnajú hodnoty a a b. Ak a je väčšie ako b, b už nemôže byť maximom. Porovnáme preto a s c a väčšie z oboch vrátime ako maximum. V prípade, že a nie je väčšie ako b, musí byť maximom jedna z hodnôt b alebo c. Ktorá, to zistíme treťou aplikáciou operátora ?:. V našom prípade bude výsledkom hodnota 123, uložená v premennej a. Na zamyslenie dávam do pozornosti, prečo určenie maxima bude fungovať aj v prípade, že niektoré dve hodnoty (či priamo všetky tri) budú zhodné.

Pre ilustráciu vyhodnotenia buď druhého, alebo tretieho operandu ?: je tu ešte tento krátky príklad:

int i = 2;
System.out.println(i > 0 ? (i = 3) : (i = –5));
System.out.println(i < 0 ? (i = –2) : (i = 1));
System.out.println(i);

V druhom riadku je podmienka i > 0 splnená, vyhodnotí sa výraz i = 3, takže premenná i bude obsahovať hodnotu 3. Na obrazovku sa vypíše hodnota výrazu i = 3, čo je, samozrejme, 3. V treťom riadku podmienka splnená nebude, vyhodnotí sa výraz i = 1, ktorého hodnota 1 sa vypíše na obrazovku. Premenná i bude mať na konci programu hodnotu 1, o čom nás presvedčí štvrtý riadok. Ani v jednom prípade sa nevyhodnotil výraz priraďujúci premennej i zápornú hodnotu.

Priraďovacie operátory

Poslednými operátormi, o ktorých si povieme, sú operátory priradenia. Skutočne je namieste použitie množného čísla, pretože okrem klasického priraďovacieho operátora =, o ktorom sme dosiaľ akosi mlčky predpokladali, že jeho význam je zrejmý, a podľa toho sme ho používali v príkladoch, poskytuje Java podobne ako C++ jedenásť ďalších, zložených priraďovacích operátorov +=, –=, *=, /=, %=, &=, |=, ^=, <<=, >>= a >>>=.

Jednoduchý priraďovací operátor = je binárny. Jeho ľavým operandom musí byť výraz, ktorý sa vyhodnotí ako premenná (t. j. to, čo v C++ nazývame l-hodnota), pravý operand predstavuje priraďovanú hodnotu. Ak nie je možné pravý operand konvertovať na typ ľavého operandu, dôjde pri preklade, prípadne pri behu programu k chybe. Operátor = sa asociuje sprava doľava, preto výraz a = b = c sa grupuje ako a = (b = c). Hodnotou priraďovacieho výrazu je priraďovaná hodnota, takže do premennej a sa priradí tá istá hodnota ako do premennej b, menovite obsah premennej c. Toto viacnásobné priradenie je ostatne známe z C++. Pozor, hodnota priraďovacieho výrazu už nie je premennou, zápis (a = b) = c je preto chybný.

Zložené priraďovacie operátory majú bez výnimky tvar op=, kde op je vždy niektorý z doteraz prebraných binárnych operátorov. Sémantika zložených operátorov priradenia je nasledujúca: výraz E1 op= E2 je ekvivalentný výrazu E1 = E1 op E2. Výsledok E1 op E2 sa pred priradením späť do E1 konvertuje na typ E1. Zložené operátory sú takisto binárne a asociujú sa rovnako ako jednoduchý operátor =, ich operandy však musia byť primitívnych typov. Jedinou výnimkou je operátor +=, ktorého ľavý operand môže byť typu String, pravý operand v takom prípade môže mať ľubovoľný typ.

Na použitie operátora = azda netreba uvádzať príklad, skôr príde vhod nasledujúca ukážka:

int x = 2;

x += 3.14;
System.out.println("x = " + x);

Ako sa môžeme presvedčiť spustením tohto programu, premenná x bude mať po priradení pomocou operátora += hodnotu 5, pretože výsledok súčtu x + 3.14, čo je 5.14, sa prevedie naspäť na typ int.

Pri vyhodnocovaní zložených priraďovacích operátorov op= sa hodnota ľavého operandu pred vyhodnotením pravého operandu zapamätá, takže výsledok bude naozaj súčtom pôvodnej hodnoty ľavej strany s výsledkom pravej strany priradenia. O tom nás presvedčí tento krátky príklad:

int d = 11;
d *= (d = 3) + (d << 2);
System.out.println("d = " + d);

Po priradení bude v premenej d uložená hodnota 165. Prečo? Nuž, pôvodná hodnota 11 sa zapamätá. Následné vyhodnotenie pravej strany uloží do d hodnotu 3, ktorú sčíta s hodnotou d << 2, čo je 12. Výsledok, číslo 15, sa vynásobí s uloženou hodnotou 11, čím dostaneme konečných 165.

Dokončenie nabudúce

V ďalšom pokračovaní seriálu tému operátorov uzavrieme a začneme sa baviť o výkonných prvkoch jazyka Java, teda o príkazoch. Ich znalosť nám spolu s dosiaľ prebranými témami umožní konečne začať písať jednoduché programy. Dovidenia v dvadsiatom prvom storočí.

    AND OR XOR NOT
a b a & b a | b a ^ b ~a
0 0 0 0 0 1
0 1 0 1 1 1
1 0 0 1 1 0
1 1 1 1 0 0

Tab.č.1 - Logické funkcie

 


Nechajte si posielať prehľad najdôležitejších správ emailom

Mohlo by Vás zaujímať

Ako na to

Tipy a triky: Ako na snímku obrazovky na akomkoľvek počítači s Windows?

02.12.2016 00:13

Ak snímky obrazovky robíte často apotrebujete napríklad funkcie na posun stránok alebo snímanie zobrazenia pri vyššom rozlíšení displeja, zrejme používate nejakú špecializovanú aplikáciu. Väčšina použ ...

Ako na to 1

Tipy a triky: Ako aplikácii prednastaviť spúšťanie s administrátorskými právami?

30.11.2016 00:10

Väčšina aspoň trochu skúsenejších používateľov vie, že aj keď máte na operačnom systéme Windows vytvorený administrátorský účet, aplikácie pre bezpečnosť nefungujú vždy splnými administrátorskými práv ...

Ako na to 2

Tipy a triky: Ako vypnúť uzamykaciu obrazovku vo Windows 10?

29.11.2016 00:10

Rozčuľuje vás, že pred každým prihlásením doúčtu vášho počítača musíte prejsť uzamykacou obrazovkou? Windows 10 na tejto obrazovke ukazuje čas,dátum anejakú zaujímavú fotografiu zrôznych kútov sveta. ...

Žiadne komentáre

Vyhľadávanie

Kyocera - prve-zariadenia-formatu-a4-s-vykonom-a3

Najnovšie videá