Java tutoriál - Operátory (5. díl)

V pátém dílu překladu oficiálního Java tutoriálu se zaměříme na operátory.

V tomto díle se zaměříme na operátory programovacího jazyka Java. Začneme nejvíce používanými operátory a budeme pokračovat těmi exotičtějšími. Každé téma obsahuje příklady zdrojových kódů, které můžete zkompilovat a spustit.

Operátory

Nyní již víte, jak deklarovat a inicializovat proměnnou. Co by vás možná mohlo zajímat, je, jak s proměnnou něco dělat. Operátory programovacího jazyka Java jsou dobrým místem, kde začít. Operátory jsou speciální symboly, které umožňují provádět určité operace nad jedním, dvěma nebo třemi operandy a poté vrátit výsledek.

Předtím, než si vysvětlíme, jak vypadají operátory programovacího jazyka Java, mohlo vy pro vás být užitečné dopředu vědět, který operátor má větší přednost. Operátory jsou v následující tabulce řazeny podle jejich priority. Čím výše je operátor v tabulce, tím větší má prioritu. Operátory s vyšší prioritou jsou vykonávány dříve než operátory s prioritou nižší. Operátory na stejné lince mají stejnou prioritu. Když jsou v jednom výrazu za sebou dva operátory stejné priority, uplatňuje se pravidlo dané přesnosti. Všechny binární operátory (operují nad dvěma operandy), vyjma přiřazovacích operátorů, jsou vykonávány zleva doprava, u přiřazovacích operátorů je to naopak.

Obecně se dá říct, že některé operátory se používají o mnoho více než jiné; například operátor přiřazení „=“ je o mnoho více používán než operátor pravého posuvu bez znaménka „>>>“. Podle tohoto pravidla probereme nejdříve obecně nejpoužívanější operátory a díl zakončíme těmi speciálnějšími. Každá sekce je zakončena příkladem, který vám pomůže téma lépe pochopit.

Přiřazovací, početní a unární operátory

Jednoduchý přiřazovací operátor

Jeden z nejčastějších operátorů, se kterými se setkáte, je jednoduchý přiřazovací operátor „=“. Tento operátor jste mohli vidět ve třídě Bicycle; přiřazuje hodnotu pravého operandu levému:

 int cadence = 0;
 int speed = 0;
 int gear = 1;

Tento operátor může také být použit s objekty k přiřazení objektové reference, o které se budeme bavit v příštích dílech.

Početní operátory

Programovací jazyk Java poskytuje operátory, které zvládají sčítání, odčítání, násobení a dělení. Je zde veliká šance, že v nich poznáte jejich matematické protějšky. Jediný symbol, který pro vás může působit nově, je „%“, který vydělí jeden operand druhým a vrátí zbytek jako výsledek.

• + – operátor sčítání (taktéž spojuje řetězce znaků)
• − – operátor odčítání
• * – oeprátor násobení
• / – operátor dělení
• % – operátor zbytku po dělení

Následující program testuje početní operátory.

class ArithmeticDemo {

     public static void main (String[] args){

          int vysledek = 1 + 2; // výsledek je nyní 3
          System.out.println(vysledek);

          vysledek = vysledek - 1; // výsledek je nyní 2
          System.out.println(vysledek);

          vysledek = vysledek * 2; // výsledek je nyní 4
          System.out.println(vysledek);

          vysledek = vysledek / 2; // výsledek je nyní 2
          System.out.println(vysledek);

          vysledek = vysledek + 8; // výsledek je nyní 10
          vysledek = vysledek % 7; // výsledek je nyní 3
          System.out.println(vysledek);

     }
}

Můžete také kombinovat početní operátory s jednoduchým přiřazovacím operátorem za vzniku složených přiřazení. Například jak x += 1;, tak x = x + 1; zvýší hodnotu x o 1.

Operátor + může být použit pro spojování řetězců, jak je také ukázáno v následujícím programu:

class ConcatDemo {
     public static void main(String[] args){
          String prvníRetezec = "Toto je";
          String druhyRetezec = " spojovaný řetězec.";
          String tretiRetezec = prvniRetezec + druhyRetezec;
          System.out.println(tretiRetezec);
     }
}

Na konci tohoto programu obsahuje proměnná thirdString řetězec „Toto je spojovaný řetězec.“, který je taktéž vytištěn na standardní výstup.

Unární operátory

Unární operátory potřebují pouze jeden operand; poskytují různé operace jako zvyšování/snižování hodnoty proměnné o jedna, negaci výrazu nebo převracení hodnoty typu boolean.

Následující program testuje unární operátory:

class UnaryDemo {

     public static void main(String[] args){
          int vysledek = +1; // výsledek je nyní 1
          System.out.println(vysledek);
          vysledek--;  // výsledek je nyní 0
          System.out.println(vysledek);
          vysledek++; // výsledek je nyní 1
          System.out.println(vysledek);
          vysledek = -vysledek; // výsledek je nyní -1
          System.out.println(vysledek);
          boolean uspech = false;
          System.out.println(uspech); // false
          System.out.println(!uspech); // true
     }
}

Operátory inkrementace/dekrementace mohou být aplikovány před (prefix) a po (postfix) operandu. Jak kód result++;, tak ++result; vyústí ve zvýšení hodnoty proměnné result o jedna. Jediným rozdílem je, že prefixovaná forma (++result) vrátí inkrementované číslo, zatímco postfixová forma (result++) vrátí původní číslo. Jestliže tento operátor použijete pouze při jednoduché inkrementaci/dekrementaci, nezáleží na tom, kterou verzi použijete. Ale pokud budete tento operátor chtít použít v rámci složitého výrazu, špatná volba může vyústit ve špatný výsledek.

Následující program ilustruje rozdíl mezi prefixovou a postfixovou formou:

class PrePostDemo {
     public static void main(String[] args){
          int i = 3;
	  i++;
	  System.out.println(i);	// "4"
	  ++i;
	  System.out.println(i);	// "5"
	  System.out.println(++i);	// "6"
	  System.out.println(i++);	// "6"
	  System.out.println(i);	// "7"
     }
}

Porovnávací a podmínkové operátory

Porovnávací operátory

Operátory rovnosti a porovnávací operátory umožňují operace, jako jsou: větší než, menší než, je roven nebo není roven. Většina těchto operátorů vám bude připadat známá. Myslete na to, že musíte použít „==“, ne „=“, pokud chcete testovat, zda jsou si dvě primitivní hodnoty rovny.

Následující program testuje operátory porovnání:

class ComparisonDemo {

     public static void main(String[] args){
          int hodnota1 = 1;
          int hodnota2 = 2;
          if(hodnota1 == hodnota2) System.out.println("hodnota1 == hodnota2");
          if(hodnota1 != hodnota2) System.out.println("hodnota1 != hodnota2");
          if(hodnota1 > hodnota2) System.out.println("hodnota1 > hodnota2");
          if(hodnota1 < hodnota2) System.out.println("hodnota1 < hodnota2");
          if(hodnota1 <= hodnota2) System.out.println("hodnota1 <= hodnota2");
     }
}

Výstup:

hodnota1 != hodnota2
hodnota1 < hodnota2
hodnota1 <= hodnota2

Podmínkové operátory

Operátory && a || poskytují operace logické AND (a zároveň) a logického OR (nebo) nad dvěma výrazy typu boolean. Tyto operátory používají zkrácené vyhodnocování, což znamená, že druhá operace se vykoná, pouze pokud je potřeba.

Následující program testuje tyto operátory:

class ConditionalDemo1 {

     public static void main(String[] args){
          int hodnota1 = 1;
          int hodnota2 = 2;
          if((hodnota1 == 1) && (hodnota2 == 2)) System.out.println("hodnota1 je 1 AND hodnota2 je 2");
          if((hodnota1 == 1) || (hodnota2 == 1)) System.out.println("hodnota1 je 1 OR hodnota2 je 1");

     }
}

Jiným podmínkovým operátorem je ?:, který může být chápan jako zkratka za příkaz if-then-else, o kterém se budeme bavit v příštím díle. Tento operátor je taktéž znám jako ternární operátor, protože pracuje nad třemi operandy.

V následujícím příkladu může být tento operátor přečten jako „Jestliže nejakaPodminka je true, přiřaď hodnotu proměnné hodnota1 do vysledek. Pokud ne, přiřaď hodnotu proměnné hodnota2 do vysledek.“

Následující program tento operátor testuje:

class ConditionalDemo2 {

     public static void main(String[] args){
          int hodnota1 = 1;
          int hodnota2 = 2;
          int vysledek;
          boolean nejakaPodminka = true;
          vysledek = nejakaPodminka ? hodnota1 : hodnota2;

          System.out.println(vysledek);

     }
}

Protože nejakaPromenna je true, program vypíše na obrazovku „1“. Používejte operátor ?: místo příkazu if-then-else, pokud chcete svůj kód udělat lépe čitelný; například, pokud jsou výrazy jednoduché a bez přiřazování.

Operátor porovnání typů instanceof

Operátor instanceof zjišťuje, zda je operátor požadovaného typu. Můžete jej použít k testování, zda je objekt instancí dané třídy, instancí potomka nebo instancí třídy, které implementuje dané rozhraní.

Následující program definuje rodičovskou třídu (nazvanou Rodic), jednoduché rozhraní (pojmenované MojeRozhrani) a další třídu (pojmenovanou Potomek), ktera dědí ze třídy Rodic a implementuje naše rozhraní.

class InstanceofDemo {
  public static void main(String[] args) {

    Rodic obj1 = new Rodic();
    Rodic obj2 = new Potomek();

    System.out.println("obj1 instanceof Rodic: " + (obj1 instanceof Rodic));
    System.out.println("obj1 instanceof Potomek: " + (obj1 instanceof Potomek));
    System.out.println("obj1 instanceof MojeRozhrani: " + (obj1 instanceof MojeRozhrani));
    System.out.println("obj2 instanceof Rodic: " + (obj2 instanceof Rodic));
    System.out.println("obj2 instanceof Potomek: " + (obj2 instanceof Potomek));
    System.out.println("obj2 instanceof MojeRozhrani: " + (obj2 instanceof MojeRozhrani));
  }
}

class Rodic{}
class Potomek extends Rodic implements MojeRozhrani{}
interface MojeRozhrani{}

Výstup:

obj1 instanceof Rodic: true
obj1 instanceof Potomek: false
obj1 instanceof MojeRozrhani: false
obj2 instanceof Rodic: true
obj2 instanceof Potomek: true
obj2 instanceof MojeRozrhani: true

Když používáte operátor instanceof, mějte na paměti, že null není instance ničeho.

Operátory bitové a bitového posunu

Programovací jazyk Java poskytuje bitové operátory a operátory bitového posunu nad celočíselnými typy. Operátory, které teď budeme popisovat, jsou obecně nejméně používané, proto je taktéž budeme popisovat pouze stručně, většinou vám bude stačit vědět, že tyto operátory existují.

Unární bitový operátor doplňku „~“ převrátí bitový vzor; může být použit na jakýkoli celočíselný typ, kde z každé nuly udělá jedničku a z každé jedničky nulu. Například, typ byte obsahuje 8 bitů; použitím tohoto operátoru na hodnotu, jejiž bitový vzor je „00000000“, dostaneme „11111111“.

Operátor bitového posunu vlevo se znaménkem, „<<“ posune bitový vzor doleva a operátor bitového posunu vpravo se znaménkem „>>“ posune bitový vzor doprava. Bitový vzor je dán levým operandem a počet pozic, o kolik se má vzor posunout, je dán pravým operandem.

Operátor bitového posunu vpravo bez znaménka „>>>“ posune nulu na první pozici vlevo a dál využívá operátor posunu vpravo se znaménkem.

Bitový operátor & poskytuje bitovou operaci AND.

Bitový operátor ^ poskytuje bitovou operaci exklusivního OR.

Bitový opertáor | poskytuje bitovou operaci inklusivního OR.

Následující program používá bitový operátor AND pro vytištění „2“ na standardní výstup.

class BitDemo {
     public static void main(String[] args) {
          int bitovaMaska = 0x000F;
	  int hodnota = 0x2222;
	  System.out.println(hodnota & bitovaMaska);  // vytiskne "2"
     }
}

V příštím díle

V příštím díle se zaměříme na výrazy, příkazy a na bloky. Zaměříme se také na příkazy pro změnu toku programu.