Obsah

Větvení

podmínka K větvení programu slouží příkazy if a switch. Příkaz if umožňuje větvit program na základě nějaké podmínky. Začíná klíčovým slovem if, za nímž je v závorkách výraz typu boolean. Výraz typu boolean je výraz, jehož hodnota je true nebo false. Dále následuje příkaz. Při provádění se vyhodnotí výraz v závorkách a má-li hodnotu true (podmínka je splněna), provede se příkaz.

Pro zápis podmínky používáme tzv. relační operátory a operátory rovnosti. Relační operátory jsou menší než (<), větší než (>), menší nebo rovno (<=) a větší nebo rovno (>=). Operátory rovnosti jsou rovná se (==) a nerovná se (!=). rovná se nerovná se

Příkaz if může obsahovat větev else, která se provede, pokud podmínka za if není splněna. Pokud podmínka není splněna a větev else chybí, neprovede se nic (bude se pokračovat za příkazem if).

  if( x == 0 )
     System.out.println( "x je nula" );
  else
     System.out.println( "x není nula" ); 
Chceme-li zapsat za podmínku více příkazů, použijeme blok. Blok začíná otevírací složenou závorkou ({) a končí zavírací složenou závorkou (}). Blok je v Javě příkaz, takže jej můžeme použít všude tam, kde se může vyskytovat příkaz.
  if( a == b ) {
     a++;
     b--;
  } 
Blok omezuje platnost deklarace proměnné. Každá deklarace je platná jen do konce bloku, v němž je uvedena. Říkáme, že je v tomto bloku lokální.
  if( a == b ) {
     int c = a;
     // ...
  }  // tato závorka ukončuje platnost deklarace proměnné c
  // zde již nemůžeme c použít 
V závorkách za if můžeme použít proměnnou typu boolean.
  // v proměnné měsíc máme pořadové číslo měsíce
  boolean jeMaj = (mesic == 5);
  if( jeMaj ) {
     System.out.println( "je lásky čas" );
  } 

logický člen NOT

Pro zápis opačné podmínky používáme operátor logické negace (!). logická negace

  boolean konec = false;
  if( !konec ) {
     System.out.println( "ještě nekončíme" );
  } 
Potřebujeme-li rozvětvit program např. podle hodnoty celočíselné proměnné, můžeme použít zřetězení příkazů if.
  if( x == 1 ) {
     System.out.println( "jedna" );
  } else if( x == 2 ) {
     System.out.println( "dva" );
  } else if( x == 3 ) {
     System.out.println( "tři" );
  } 
Takto zřetězené příkazy if můžeme někdy nahradit příkazem switch. Jeho zápis začíná klíčovým slovem switch. Za ním je v závorkách výraz typu int nebo String (nebo typu, který lze zkonvertovat na int) a dále blok, v němž je libovolný počet návěští case. Za každým case je uvedena konstanta (nebo konstantní výraz, což je výraz, jehož hodnota je známa při překladu), dvojtečka a posloupnost příkazů.
  switch( x ) {
     case 1:
        System.out.println( "jedna" );
        break;
     case 2:
        System.out.println( "dva" );
        break;
     case 3:
        System.out.println( "tři" );
  } 
příkaz switch Při provádění se vyhodnotí výraz za klíčovým slovem switch a jeho hodnota se začne srovnávat s hodnotami za case (v pořadí, v němž jsou uvedeny). Jakmile dojde ke shodě, začnou se provádět příkazy. Provádění příkazů končí příkazem break. Pokud příkaz break chybí, provedou se všechny příkazy až do konce příkazu switch. Příkaz switch může obsahovat větev default, která se provede, pokud nedošlo ke shodě u žádného návěští case.
  String den;
  switch( x ) {
     case 6:
        den = "sobota";
        break;
     case 7:
        den = "neděle";
        break;
     default:
        den = "pracovní den";
  }
  System.out.println( den ); 
Má-li x hodnotu 6, vytiskne se sobota, má-li hodnotu 7, vytiskne se neděle, jinak se vytiskne pracovní den.

V některých případech lze místo příkazu if použít podmíněný operátor. Podmíněný operátor zapisujeme pomocí znaků ? a :. podmíněný operátor Má tři operandy. Prvním operandem je výraz typu boolean. Má-li tento výraz hodnotu true, vyhodnotí se druhý operand a jeho hodnota se použije jako návratová hodnota operátoru. Jinak se vyhodnotí třetí operand a jeho hodnota bude návratovou hodnotou operátoru. Např. příkaz

  if( x == 0 ) {
     y = 0;
  } else {
     y = 1;
  } 
lze pomocí podmíněného operátoru napsat takto:
  y = x == 0 ? 0 : 1; 
Podmíněný operátor se často vyskytuje na pravé straně přiřazovacího příkazu. Vždy se vyhodnotí pouze dva jeho operandy: první a podle jeho hodnoty buď druhý nebo třetí.
  int x = 1;
  y = x > 0 ? x++ : x--;
  System.out.printf( "%d %d%n", x, y ); 
Podmínka podmíněného operátoru je splněna, tudíž se vyhodnotí druhý operand. Při jeho vyhodnocení dojde ke zvětšení hodnoty x. Výstupem tedy bude 2 1.

Úloha 1

Doplňte podmínku.

Úloha 2

Doplňte příkaz if.

Úloha 3

Doplňte podmínku.

Úloha 4

Doplňte chybějící kód.

Úloha 5

Přepište příkaz if pomocí podmíněného operátoru.

Úloha 6

Určete hodnoty x a y po provedení těchto dvou příkazů, jestliže na vstupu zadáme hodnotu 1.

Úloha 7

Nalezněte maximum ze tří čísel.

Úloha 8

Napište ve správném pořadí.

Úloha 9

Sestavte program pro řešení kvadratické rovnice v oboru reálných čísel.

Otázky a odpovědi

Student: Mistře, proč používáte za příkazem if složené závorky i v případě, že v bloku je pouze jeden příkaz? Nejsou zbytečné?
Java guru: Dobrý postřeh. Závorky tam skutečně být nemusí. Místo
  if( x > 0 ) {
     x++;
  } 
je možné psát
  if( x > 0 ) x++; 
Přesto se závorky většinou píší, protože zlepšují čitelnost programu.
Student: Mistře, můžu psát podmínku s logickou proměnnou ve tvaru
  if( b == true ) { 
a opačnou podmínku ve tvaru
  if( b == false ) { 
nebo takový zápis není správný?
Java guru: Syntakticky jsou tyto podmínky správně, jsou však náchylné k chybám. Když v takovém zápise vynecháš jedno rovná se
  if( b = true ) { 
bude podmínka syntakticky správně, protože operátor přiřazení vrací logickou hodnotu. Překladač tedy neohlásí žádnou chybu a program přeloží. Patrně však nebude fungovat tak, jak jsi zamýšlel. Proto raději používej zápisy
  if( b ) { 
a
  if( !b ) { 
Student: Mistře, co se stane, pokud se v příkazu switch nenajde odpovídající větev case a sekce default není uvedena? Dojde k chybě?
Java guru: Nedojde. Neprovede se žádný příkaz a bude se pokračovat za příkazem switch.
Student: Napsal jsem tento kód:
  int x = sc.nextInt(), fx;
  switch( x % 2 ) {
     case -1:
        fx = -11;
        break;
     case 0:
        fx = 11;
        break;
     case 1:
        fx = 19;
  }
  System.out.println( fx ); 
Překladač jej však odmítá přeložit, protože „proměnná fx je možná neinicializovaná“. Přitom je zřejmé, že fx je inicializována, protože výraz x % 2 má jednu z hodnot -1, 0, 1. Můžeš mi to vysvětlit, mistře?
Java guru: Zajisté. Překladač nezná hodnotu výrazu za klíčovým slovem switch. Kontroluje pouze to, zda vždy přiřazuješ do fx nějakou hodnotu. Protože příkaz switch neobsahuje větev default, není z pohledu překladače toto přiřazení vždy zaručeno. Náprava je snadná:
  int x = sc.nextInt(), fx;
  switch( x % 2 ) {
     case -1:
        fx = -11;
        break;
     case 0:
        fx = 11;
        break;
     //case 1:
     default:
        fx = 19;
  }
  System.out.println( fx );