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ů.
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 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!
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 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 |
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}
Konverze datových typů lze se rozdělit zhruba na tyto okruhy:
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ů.
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 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ří:
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
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:
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ří:
Při těchto konverzích může být vyvolána výjimka ClassCastException.
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 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}
je nejjednodušším příkazem v Javě. Neprovádí nic a jeho syntaxe je:
;
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
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í 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.
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;
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:
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.");
}
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++;
}
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);
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)
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!");
}
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;
}
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.