Main Menu
  • Home
  • Programování Java
  • Programové vybavení
  • Hardware
  • Download
Nejčtenější články
  • Java - objekty, konstruktory, this
  • Křízený a přímý kabel
  • Java - operátory, výrazy, řídící struktury
  • Java - rozhraní, polymorfismus, výjimky
  • Java - metody a pole

Java - operátory, výrazy, řídící struktury

Výrazy

Výraz se skládá z operandů a operátorů. Operandem může být konstanta, proměnná, volání metody nebo opět výraz. Operátory udávají, co se má provést s jednotlivými hodnotami operandů.

Aritmetické operátory

Všechny aritmetické operátory lze použít pro práci s celočíselnými i racionálními hodnotami. V následující tabulce je uveden seznam binárních aritmetických operátorů a jejich použití.

Oper. Použití Popis
+ op1 + op2 součet operandů op1 a op2
- op1 - op2 rozdíl operandů op1 a op2
* op1 * op2 součin operandů op1 a op2
/ op1 / op2 podíl operandů op1 a op2
% op1 % op2 zbytek po dělení op1 operandem op2

Dále jsou k dispozici tyto unární aritmetické operátory:

Oper. Použití Popis
+ +op indikace kladné hodnoty
- -op aritmetická negace operandu
++ op++ inkrementace op o 1 po jeho vyhodnocení
++ ++op inkrementace op o 1 před jeho vyhodnocením
-- op-- dekrementace op o 1 po jeho vyhodnocení
-- --op dekrementace op o 1 před jeho vyhodnocením

Relační operátory

Relační operátory porovnávají dva výrazy ekvivalentních typů a rozhodnou o platnosti vztahu mezi nimi. Výsledkem relačního operátoru je vždy hodnota false nebo true.

Oper. Použití Výsledek je true jestliže
> op1 > op2 op1 je větší než op2
>= op1 >= op2 op1 je větší než nebo roven op2
< op1 < op2 op1 je menší než op2
<= op1 <= op2 op1 je menší než nebo roven op2
== op1 == op2 op1 a op2 jsou si rovné
!= op1 != op2 op1 a op2 si nejsou rovné

Mezi relační operátory dále patří operátor instanceof, který porovnává, zda objekt je instancí dané třídy nebo rozhraní. Jeho syntaxe je:

referenceNaObjekt instanceof JménoTřídyNeboRozhraní

String retezec = "ahoj";
if (retezec instanceof String) // test na třídu
System.out.println("Je to java.lang.String!");

if (retezec instanceof Object) // test na třídu
System.out.println("Je to java.lang.Object!");

if (!(retezec instanceof Runnable)) // test na rozhraní
System.out.println("Neimplementuje java.lang.Runnable!");

Vytiskne se:
Je to java.lang.String!
Je to java.lang.Object!
Neimplementuje java.lang.Runnable!

Logické operátory

Pro kombinaci relačních operátorů je nutné použít logické operátory. Například výraz op1 < op2 < op3 je třeba zapsat jako logickou kombinaci dvou relačních operátorů (op1 < op2) && (op2 < op3). Java obsahuje tyto logické operátory:

Oper. Použití Výsledek je true jestliže:
&& op1 && op2 op1 a op2 nabývají hodnotu true
|| op1 || op2 alespoň jeden z op je true
! !op op nabývá hodnotu false (negace)

Bitové operátory

Bitové operátory umožňují manipulaci s jednotlivými bity celočíselných datových typů.

Oper. Použití Operace
>> op1 >> op2 bitový posuv op1 doprava o op2 bitů
<< op1 << op2 bitový posuv op1 doleva o op2 bitů
>>> op1 >>>op2 jako >>, ale neznaménkově
& op1 & op2 bitový AND
| op1 | op2 bitový OR
^ op1 ^ op2 bitový XOR
~ ~op bitový doplněk

Operátor přiřazení

Pro operátor přiřazení se používá znak "=". Tento operátor lze použít i pro inicializaci proměnných při deklaraci lokální proměnné.

int slon = 2;
int chobot = 1;
String text1 = "Tri sloni maji tri choboty";
String text2;

chobot = slon = 3;
text2 = text1;

Při přiřazení hodnoty do referenční proměnné se objekt nebo pole nekopíruje(Pro kopírování objektů a polí, lze použít metodu clone()) , ale přiřadí se pouze reference. Vlastní objekt nebo pole zůstává v paměti pouze v jednom exempláři. Referenční proměnné lze přiřadit neplatnou referenci null. Pro přiřazení lze použít některých zkrácených tvarů:

Oper. Použití Ekvivalent
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
<<= op1 <<= op2 op1 = op1 << op2
>>= op1 >>= op2 op1 = op1 >> op2
>>>= op1 >>>= op2 op1 = op1 >>> op2

{mospagebreak}

Operátor konverze (přetypování)

Konverze datových typů lze se rozdělit zhruba na tyto okruhy:

  • Identické konverze - konverze na shodný typ. Referenční typy jsou považovány za shodné, mají-li stejné úplné jméno třídy (resp. rozhraní) a jsou nahrány týmž class loaderem nebo se jedná o pole se shodnými typy položek.
  • Rozšiřující konverze - provádějí se implicitně a není nutné uvádět operátor přetypování.
  • Zužující konverze - při nich může dojít ke ztrátě informace a musí se provádět operátorem přetypování - jeho syntaxe je: ( typ ) operand
  • Konverze základních datových typů na řetězec a opačně (viz. kapitola o řetězcích).
  • Zakázané konverze - konverze, které obvykle nemají smysl (například konverze reference na double) a přetypování na void.
  •  

    U příkazu přiřazení překladač automaticky provádí zužující konverze na typy byte, short a char, pokud je na pravé straně výsledek výrazu typu int a zároveň je výsledek v oboru hodnot těchto typů.

    Rozšiřující konverze

    Při provádění rozšiřující datové konverze nedochází ke ztrátě informace(Výjimku tvoří konverze int, long ---> float a long ---> double, kdy celé číslo nemusí mít obraz v prostoru čísel s pohyblivou řádovou čárkou. Výsledek konverze je pak nejbližší možné číslo podle normy IEEE 754. ). Jedná se o konverze, kde výsledný datový typ má větší obor hodnot než typ původní. Při těchto konverzích nedojde k chybě za běhu programu. Zde je přehled rozšiřujících konverzí pro základní datové typy:

  • byte ---> short, int, long, float, double,
  • char, short ---> int, long, float, double,
  • int ---> long, float, double,
  • long ---> float, double,
  • float ---> double
  •  

    Byte b = 10;
    short s;
    s = (short) b;
    System.out.println("b = " + b + ", s= " + s); // b= 10, s= 10

    Mezi rozšiřující konverze pro referenční datové typy patří:

  • třída S ---> třída T, kde S je potomek třídy T,
  • třída S ---> rozhraní K, kde S implementuje rozhraní K,
  • rozhraní J ---> rozhraní K, kde J je potomkem rozhraní K,
  • libovolné rozhraní nebo pole ---> třída Object (viz 11.5.),
  • libovolné pole ---> rozhraní Cloneable (viz 11.5.),
  • pole a[] ---> pole b[], kde a a b jsou pole referenčních datových typů a konverze a ---> b je rozšiřující.
  •  

    Výsledkem rozšiřující konverze referenčních typů je pouze reference. Neprovádí se žádná speciální akce s objektem nebo polem. Kontrola správnosti konverze se provádí již při překladu a nemůže vyvolat výjimku ClassCastException.

    Double cislo = "Ahoj!"; // zde překladač ohlásí chybu
    Object x = "Ahoj!"; // rozšiřující konverze -- OK, neboť String je potomkem Object

    Zužující konverze

    Při provádění zužující konverze může dojít ke ztrátě hodnoty a přesnosti. Zde je jejich přehled pro základní datové typy:

  • short ---> byte,
  • short ---> byte, char,
  • char ---> byte, short,
  • int ---> byte, short, char
  • long ---> byte, short, char, int
  • float ---> byte, short, char, int, long,
  • double ---> byte, short, char, int, long, float.
  •  

    Zužující konverze mezi celočíselnými datovými typy se provede oříznutím váhově vyšších bitů. Při konverzi z typu float nebo double na celočíselný datový typ se provede nejdříve konverze na typ long (popřípadě na int - při konverzi na int, short, char nebo byte), a pak na cílový datový typ.

    short s = 300;
    byte b;
    b = (byte) s;
    System.out.println("s = " + s + ", b= " + b); // s= 300, b= 44
    System.out.println("255: " + (byte) 255); // Vypíše číslo: -1
    System.out.println("255: " + (byte) 255); // Vypíše číslo: -1

    Mezi zužující konverze pro referenční datové typy patří:

  • třída S ---> třída T, kde S je rodičem třídy T,
  • třída S ---> rozhraní K, kde S není koncová (final) a neimplementuje rozhraní K,
  • rozhraní J ---> rozhraní K, kde J je potomkem K,
  • třída Object ---> libovolné rozhraní,
  • třída Object ---> libovolné pole,
  • rozhraní J ---> rozhraní T, kde T není koncové,
  • rozhraní J ---> třída T, kde T je koncová a implementuje J,
  • rozhraní J ---> rozhraní K, kde J neimplementuje K a neexistuje metoda, kterou by obsahovala obě rozhraní a která by zároveň měla různý návratový typ,
  • pole a[] ---> pole b[], kde a a b jsou pole referenčních datových typů a konverze a ---> b je zužující.
  •  

    Při těchto konverzích může být vyvolána výjimka ClassCastException.

    Ternární operátor

    Ternární operátor je jakousi obdobou příkazu if. Jeho syntaxe je:

    výraz1 ? výraz2 : výraz3
    Pokud výraz1 nabývá hodnoty true, vyhodnotí se výraz2, v opačném případě se vyhodnotí výraz3.
    b != 0 ? c = a / b : c = 0; // pokud b je nenulové, provede se dělení jinak se do c přiřadí 0

    Operátor new

    Operátor new slouží k vytvoření objektu – syntaxe:
    Objekt promenná=new Ojekt;
    Přehled priorit jednotlivých operátorů
    Pokud zapsaný výraz obsahuje více operátorů, je vyhodnocování dáno jejich prioritou. Dříve se vyhodnocují operátory s vyšší prioritou (ty s nižším číslem). Operátory se stejnou prioritou se vyhodnocují zleva doprava. Pro změnu pořadí vyhodnocování lze použít kulaté závorky.

    P Typ operátorů Operátory
    1 postfixové [] . (parametry) op++ op-
    2 unární operátory ++op -op +op -op ~ !
    3 vytváření a přetyp. new (typ) výraz
    4 multiplikativní * / %
    5 aditivní + -
    6 posuvy << >> >>>
    7 relace < > <= >= instanceof
    8 ekvivalence == !=
    9 bitové AND &
    10 bitové XOR ^
    11 bitové OR |
    12 logické AND &&
    13 logické OR ||
    14 ternární ? :
    15 přiřazení = += -= *= /= %= ^= &=
    |= <<= >>= >>>=

    {mospagebreak}

    Příkazy

    Prázdný příkaz

    je nejjednodušším příkazem v Javě. Neprovádí nic a jeho syntaxe je:
    ;

    Výrazový příkaz

    Výrazový příkaz je nejčastěji používaným příkazem. Do této kategorie patří přiřazovací příkaz, dekrementace a inkrementace pomocí operátorů "++" a "--", volání metody a vytvoření objektu pomocí operátoru new.

    a = b + c * 2; // přiřazovací příkaz
    b += 5; // přiřazovací příkaz
    a++; // inkrementace
    System.gc(); // volání metody

    Složený příkaz (blok)

    Blok je sekvence příkazů a deklarací lokálních proměnných uzavřených do složených závorek "{" a "}". Blok může být i prázdný, pak se chová stejně jako prázdný příkaz. Příkazy v bloku jsou vykonávány od prvního příkazu k poslednímu, pokud není ukončen předčasně.
    Deklarace lokálních proměnných
    Deklarace lokálních proměnných je považována za příkaz, a proto je možné uvést tuto deklaraci kdekoliv v bloku. Deklarovat lze jednu nebo více lokálních proměnných. Platnost těchto proměnných začíná jejich deklarací a končí koncem bloku. Deklarace proměnné vypadá takto (ident značí identifikátor, modifikátor final konstantu):

    [ final ] typ ident [ = inicializátor ] [, ident ...];
    Pokud není při deklaraci uveden inicializátor, musí být proměnná naplněna před prvním použitím.
    char a, b = '$', c = b; // deklarace znakových proměnných
    final int i = 1; // deklarace celočíselné konstanty
    String retezec; // deklarace proměnné třídy String

    U deklarace proměnné typu pole je třeba uvést prázdné hranaté závorky za typem nebo identifikátorem (rozměr dimenze se v deklaraci neudává).
    int[] pole1; // deklarace pole celočíselných prvků (pole je
    // neinicializováno, tzn. je přiřazeno null )
    int pole2[]; // druhá možnost deklarace pole

    Inicializace a vícerozměrná pole nejsou popsána v tomto referátu.

    Návěští

    Návěští není samostatný příkaz. Používá se jako prefix k ostatním příkazům. Návěští je jakýkoliv identifikátor zakončený dvojtečkou. Za návěštím může následovat pouze příkaz cyklu nebo blok:
    jménoNávěští : příkazCykluNeboBlok Na návěští se lze odvolat příkazy break a continue. Java nepodporuje příkaz goto, i když má pro něj vyhrazené klíčové slovo.

    If

    Příkaz if se používá pro podmínění dalšího příkazu (neúplně podmíněný příkaz) nebo pro rozdělení programu dvou větví (úplně podmíněný příkaz). Jeho syntaxe je následující:

    {mospagebreak} if ( výraz ) příkaz
    if ( výraz ) příkaz else příkaz

    Výsledek výrazu výraz musí být vždy typu boolean, jinak dojde k chybě při překladu. Příkaz else patří vždy k posledně uvedenému příkazu if - pro změnu je třeba použít bloku:

    if (a != 0) {
    if (a != 1)
    b = b/a;
    } else b = 0;

    Switch

    Příkaz switch se používá pro vícenásobné větvení programu. Jeho zápis je poněkud komplikovanější.
    switch ( výraz ) {
    case konstantníVýraz1 : [ příkazy ]
    [ case konstantníVýraz2 : [ příkazy ] ]

    .
    .
    [ case konstantníVýrazN : [ příkazy ] ]
    [ default : [ příkazy ] ]
    }

    Výraz výraz může nabývat hodnot jen typů: char, byte, short, int. Řízení programu je ovlivněno takto:

  • Pokud výraz odpovídá některému konstantnímu výrazu, pokračuje program příkazy v příslušné větvi case.
  • Pokud žádný konstantní výraz neodpovídá výrazu výraz, pokračuje program implicitní větví default (není-li použita, pokračuje se za příkazem switch).
  • Není-li provádění větve (case nebo default) přerušeno například příkazy break nebo return, provedou se všechny příkazy do konce bloku switch.
    Následující program určuje, zda den v týdnu je pracovní nebo ne.

     

    switch(den) {
    case 1: // Pro případ, že den je roven 1 - 5
    case 2: // se vypíše "Pracovní den."
    case 3:
    case 4:
    case 5: System.out.println("Pracovní den.");
    break;
    case 6: // Pro hodnoty 6 - 7 se vypíše "Víkend."
    case 7: System.out.println("Víkend.");
    break;
    default: // Jinak: "Špatně zadaný den."
    System.out.println("Špatně zadaný den.");
    }

    While

    Příkaz while je cyklus s podmínkou na začátku. Jeho syntaxe je:
    while ( výraz ) příkaz Výsledná hodnota výrazu musí být typu boolean. Pokud výraz nabývá hodnoty true, příkaz se provádí, jinak program pokračuje dále za blokem while.
    Program vypíše čísla od 0 do 9. Jedná se o náhradu cyklu for cyklem while.

    int n=0;

    while(n<10) {
    System.out.println(n);
    n++;
    }

    Do

    Příkaz do je cyklus s podmínkou na konci. Jeho zápis je následovný:
    do příkaz while ( výraz );
    Nejprve se provede příkaz, a pokud výraz nabývá hodnoty true, začne se příkaz provádět znovu. Cyklus skončí, když výraz nabude hodnoty false.

    double pi, i = 1;
    do {
    pi += 4/i - 4/(i+2);
    i+=4;
    } while (Math.abs(Math.PI - pi) > 1E-7);
    System.out.println("Vypocteno Pi = " + pi);

    For

    Příkaz for je komfortnější příkaz cyklu. Jedná se o rozšíření cyklu while (viz příklad 9.6.). Jeho syntaxe je:
    for ( inic; výraz; iter) příkaz
    Části inic a iter mohou obsahovat příkazy; je-li jich více oddělují se čárkou( V Javě čárka není operátor narozdíl od C/C++.) . Cyklus se provádí dokud výraz nabývá hodnoty true. Vyhodnocování výrazu se provádí vždy na konci cyklu, iter se provede i při posledním průchodu! Části inic, výraz i iter jsou v příkazu for nepovinné.

    int suma=0;

    for(int n=1; n<3; n++, suma+=n)
    System.out.println("n="+n+", suma="+suma);

    System.out.println("suma="+suma);
    Program vypíše:
    n=1, suma=0
    n=2, suma=2
    suma=5
    (výsledná suma je 5, neboť se přičte i n=3)

    Break

    Příkaz break má dvě podoby a to:
    break;
    nebo
    break návěští; Příkazem break lze ukončit právě prováděný cyklus, blok nebo příkaz switch. Pokud uvedeme návěští ukončí se blok, k němuž se návěští vztahuje.
    Vyhledání hodnoty (10) v poli může vypadat takto:


    int i;
    int[] pole = {0,2,8,25,10,4};

    ForBlok: {
    for(i=0; i
    if(pole[i] == 10) break ForBlok;
    System.out.println("Nenalezeno!");
    }

    Continue

    Příkaz continue má dvě podoby jako break. Lze jej ale uvést jen uvnitř cyklů while, do a for. Jeho zápis je:
    continue;
    nebo
    continue návěští;
    Pokud je uveden příkaz continue bez návěští, přeskočí se zbytek cyklu a cyklus pokračuje dalším krokem. Vždy je vybrán nejvnitřnější příkaz cyklu, v jehož těle se vyskytl.
    Příkaz continue s návěštím převede řízení na příkaz cyklu, který je součástí tohoto návěstí. Jestliže za návěštím nenásleduje příkaz cyklu, dojde k chybě při překladu.

    navesti: for(n=0; n<100; n++)
    for(m=0; m<200; m++) {
    if(n == 50 && m ==100) continue navesti;
    }

    Return

    Příkaz return provede návrat z metody a vrací řízení programu zpět za příkaz, který metodu vyvolal. Je-li návratový typ metody prázdný (void), má příkaz return tvar:
    return ;
    jinak je zápis příkazu return následující:
    return výraz;

    Ve druhém případě příkaz navíc vrací hodnotu výrazu výraz, který musí být shodného typu (viz. konverze) jako je návratový typ metody.

     
    Copyright © 2025 Výukový portál Háka Software. Designed by olwebdesign.com