logo

TechCodeview

Operátoři v Javě

Java poskytuje mnoho typů operátorů, které lze použít podle potřeby. Jsou klasifikovány na základě funkcí, které poskytují. V tomto článku se seznámíme s operátory Java a seznámíme se se všemi jejich typy.

Co jsou to operátoři Java?

Operátory v Javě jsou symboly používané pro provádění specifických operací v Javě. Operátoři dělají úlohy jako sčítání, násobení atd., které vypadají jednoduše, ačkoli implementace těchto úloh je poměrně složitá.

Typy operátorů v Javě

V Javě existuje několik typů operátorů, všechny jsou uvedeny níže:



  1. Aritmetické operátory
  2. Unární operátoři
  3. Operátor přiřazení
  4. Relační operátoři
  5. Logické operátory
  6. Ternární operátor
  7. Bitové operátory
  8. Operátoři směn
  9. instance operátora

1. Aritmetické operátory

Používají se k provádění jednoduchých aritmetických operací na primitivních datových typech.

porovnání řetězců c#
  • *: Násobení
  • /: Divize
  • %: Modul
  • + : Přidání
  • – : Odčítání

Příklad:

Jáva 
// Java Program to implement // Arithmetic Operators import java.io.*; // Drive Class class GFG {  // Main Function  public static void main (String[] args) {    // Arithmetic operators  int a = 10;  int b = 3;    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));    } }>
Výstup 
a + b = 13 a - b = 7 a * b = 30 a / b = 3 a % b = 1>

2. Unární operátory

Unární operátory potřebují pouze jeden operand. Používají se ke zvýšení, snížení nebo negaci hodnoty.

  • – : Unární mínus , používá se pro negaci hodnot.
  • + : Unární plus označuje kladnou hodnotu (čísla jsou však kladná i bez ní). Provádí automatický převod na int, když je typ jeho operandu bajt, znak nebo krátký. Toto se nazývá unární numerická propagace.
  • ++: Inkrementální operátor , který se používá pro zvýšení hodnoty o 1. Existují dva druhy operátorů přírůstku.
    • Po zvýšení: Hodnota se nejprve použije pro výpočet výsledku a poté se zvýší.
    • Předběžný přírůstek: Nejprve se zvýší hodnota a poté se vypočítá výsledek.
  • – – : Operátor snížení , který se používá ke snížení hodnoty o 1. Existují dva druhy operátorů dekrementace.
    • Po snížení: Hodnota se nejprve použije pro výpočet výsledku a poté se sníží.
    • Pre-Decrement: Hodnota se nejprve sníží a poté se vypočítá výsledek.
  • ! : Logický ne operátor , který se používá pro invertování booleovské hodnoty.

Příklad:

Jáva 
// Java Program to implement // Unary Operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  // Interger declared  int a = 10;  int b = 10;  // Using unary operators  System.out.println('Postincrement : ' + (a++));  System.out.println('Preincrement : ' + (++a));  System.out.println('Postdecrement : ' + (b--));  System.out.println('Predecrement : ' + (--b));  } }>
Výstup 
Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Operátor přiřazení

'=' Operátor přiřazení se používá k přiřazení hodnoty libovolné proměnné. Má asociativitu zprava doleva, tj. hodnota uvedená na pravé straně operátoru je přiřazena proměnné na levé straně, a proto musí být hodnota na pravé straně deklarována před jejím použitím nebo by měla být konstantou.

Obecný formát operátoru přiřazení je:

variable   =   value;>

V mnoha případech lze operátor přiřazení kombinovat s jinými operátory a vytvořit tak kratší verzi příkazu s názvem a Složené prohlášení . Například místo a = a+5, můžeme napsat a += 5.

  • += , pro přidání levého operandu s pravým operandem a jeho následné přiřazení k proměnné vlevo.
  • -= , pro odečtení pravého operandu od levého operandu a jeho následné přiřazení k proměnné vlevo.
  • *= , pro vynásobení levého operandu pravým operandem a jeho následné přiřazení k proměnné vlevo.
  • /= , pro dělení levého operandu pravým operandem a jeho následné přiřazení k proměnné vlevo.
  • %= , pro přiřazení modulo levého operandu pravým operandem a jeho následné přiřazení k proměnné vlevo.

Příklad:

Jáva 
// Java Program to implement // Assignment Operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  = 0b1100: ' + (f  }>
Výstup 
f += 3: 10 f -= 2: 8 f *= 4: 32 f /= 3: 10 f %= 2: 0 f &= 0b1010: 0 f |= 0b1100: 12 f ^= 0b1010: 6 f <>= 1:12 f>>>= 1:6>>> 
    4. Relační operátoři    
Tyto operátory se používají ke kontrole vztahů jako rovnost, větší než a menší než. Po porovnání vracejí booleovské výsledky a jsou široce používány v cyklických příkazech a také v podmíněných příkazech if-else. Obecný formát je,
 Některé z relačních operátorů jsou -
 
  •     ==, Rovná se    vrátí hodnotu true, pokud se levá strana rovná pravé straně.
  •     !=, Nerovná se    vrátí hodnotu true, pokud se levá strana nerovná pravé straně.
  •     <, méně než:    vrátí hodnotu true, pokud je levá strana menší než pravá strana.
  •     <=, menší nebo rovno    vrátí hodnotu true, pokud je levá strana menší nebo rovna pravé straně.
  •     >, větší než:    vrátí hodnotu true, pokud je levá strana větší než pravá strana.
  •     >=, Větší než nebo rovno    vrátí hodnotu true, pokud je levá strana větší nebo rovna pravé straně.
    Příklad:    
Jáva 
// Java Program to implement // Relational Operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  // Comparison operators  int a = 10;  int b = 3;  int c = 5;  System.out.println('a>b: ' + (a> b));  System.out.println('a + (a< b));  System.out.println('a>= b: ' + (a>= b));  System.out.println('a<= b: ' + (a <= b));  System.out.println('a == c: ' + (a == c));  System.out.println('a != c: ' + (a != c));  } }>
   
  Výstup  
a>b: pravda a = b: pravda a<= b: false a == c: false a != c: true>
 
    5. Logické operátory    
Tyto operátory se používají k provádění operací logického AND a logického OR, tj. funkce podobné hradlu AND a hradlu OR v digitální elektronice. Jedna věc, kterou je třeba mít na paměti, je, že druhá podmínka se nevyhodnocuje, pokud je první nepravdivá, tj. má zkratový účinek. Používá se široce k testování několika podmínek pro rozhodování. Java má také logické NOT, které vrací true, když je podmínka nepravdivá a naopak
 
Podmíněné operátory jsou:
 
  •     &&, logické AND:    vrátí hodnotu true, pokud jsou splněny obě podmínky.
  •     ||, logické NEBO:    vrátí hodnotu true, pokud je splněna alespoň jedna podmínka.
  •     !, logické NE:    vrací true, když je podmínka nepravdivá a naopak
    Příklad:    
Jáva 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
   
  Výstup  
x && y: false x || y: true !x: false>
 
    6. Ternární operátor    
Ternární operátor je zkrácenou verzí příkazu if-else. Má tři operandy a odtud název Ternary.
 
Obecný formát je:
 
condition   ?   if true   :   if false>
Výše uvedený příkaz znamená, že pokud se podmínka vyhodnotí jako pravdivá, pak proveďte příkazy za '?', jinak proveďte příkazy za ':'.
 
    Příklad:    
Jáva 
// Java program to illustrate // max of three numbers using // ternary operator. public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 30, result;  // result holds max of three  // numbers  result  = ((a>b) ? (a> c)? a : c : (b> c) ? před naším letopočtem);  System.out.println('Maximálně tři čísla = ' + výsledek);  } }>
   
  Výstup  
Max of three numbers = 30>
 
    7. Bitové operátory    
Tyto operátory se používají k provádění manipulace s jednotlivými bity čísla. Lze je použít s libovolným celočíselným typem. Používají se při provádění aktualizací a dotazovacích operací binárních indexovaných stromů.
 
  •     &, bitový operátor AND:    vrací bit po bitu AND vstupních hodnot.
  •     |, bitový operátor OR:    vrací bit po bitu NEBO vstupních hodnot.
  •     ^, bitový operátor XOR:    vrací bit po bitu XOR vstupních hodnot.
  •     ~, Operátor bitového doplňku:    Jedná se o unární operátor, který vrací reprezentaci jedné vstupní hodnoty, tj. se všemi invertovanými bity.
Jáva 
// Java Program to implement // bitwise operators import java.io.*; // Driver class class GFG {  // main function  public static void main(String[] args)    // Bitwise operators  int d = 0b1010;  int e = 0b1100;  System.out.println('d & e: ' + (d & e));  System.out.println('d  }>
   
  Výstup  
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1:6 a>>> 1:6>>> 
    8. Operátoři směn    
Tyto operátory se používají k posunutí bitů čísla doleva nebo doprava, čímž se číslo vynásobí nebo vydělí dvěma. Lze je použít, když musíme číslo vynásobit nebo vydělit dvěma. Obecný formát -
     <<, Operátor směny vlevo:    posune bity čísla doleva a ve výsledku vyplní 0 do prázdných míst vlevo. Podobný efekt jako vynásobení čísla nějakou mocninou dvou.
  •     >>, Podepsaný operátor řazení vpravo:    posune bity čísla doprava a v důsledku toho vyplní 0 na mezery vlevo. Bit nejvíce vlevo závisí na znaménku počátečního čísla. Podobný efekt jako při dělení čísla nějakou mocninou dvou.
  •     >>>, nepodepsaný operátor posunu vpravo:    posune bity čísla doprava a v důsledku toho vyplní 0 na mezery vlevo. Bit zcela vlevo je nastaven na 0.
    • Jáva 
    // Java Program to implement // shift operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  int a = 10;    // using left shift  System.out.println('a<<1 : ' + (a << 1));    // using right shift  System.out.println('a>>1 : ' + (a>> 1));  } }>
           
      Výstup  
    a<<1 : 20 a>>1 : 5>>
     
        9. instance operátora    
    Instance operátoru se používá pro kontrolu typu. Lze jej použít k testování, zda je objekt instancí třídy, podtřídy nebo rozhraní. Obecný formát -
     
    object   instance of   class/subclass/interface>
    Jáva 
    // Java program to illustrate // instance of operator class operators {  public static void main(String[] args)  {  Person obj1 = new Person();  Person obj2 = new Boy();  // As obj is of type person, it is not an  // instance of Boy or interface  System.out.println('obj1 instanceof Person: '  + (obj1 instanceof Person));  System.out.println('obj1 instanceof Boy: '  + (obj1 instanceof Boy));  System.out.println('obj1 instanceof MyInterface: '  + (obj1 instanceof MyInterface));  // Since obj2 is of type boy,  // whose parent class is person  // and it implements the interface Myinterface  // it is instance of all of these classes  System.out.println('obj2 instanceof Person: '  + (obj2 instanceof Person));  System.out.println('obj2 instanceof Boy: '  + (obj2 instanceof Boy));  System.out.println('obj2 instanceof MyInterface: '  + (obj2 instanceof MyInterface));  } } class Person { } class Boy extends Person implements MyInterface { } interface MyInterface { }>
           
      Výstup  
    obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
     
    Přednost a asociativita operátorů Java
    Pravidla priority a asociativní pravidla se používají při práci s hybridními rovnicemi zahrnujícími více než jeden typ operátorů. V takových případech tato pravidla určují, kterou část rovnice zvážit jako první, protože pro stejnou rovnici může existovat mnoho různých ocenění. Níže uvedená tabulka zobrazuje prioritu operátorů v sestupném pořadí podle velikosti, přičemž horní část představuje nejvyšší prioritu a spodní část zobrazuje nejnižší prioritu.
     
     Přednost a asociativita operátorů v Javě
     
    Zajímavé otázky o operátorech Java
        1. Priorita a asociativita:    
    Pokud jde o hybridní rovnice, což jsou rovnice s více operátory, často dochází ke zmatkům. Problém je, kterou část vyřešit jako první. V těchto situacích je třeba dodržovat zlaté pravidlo. Pokud mají operátory jinou prioritu, vyřešte nejprve vyšší prioritu. Pokud mají stejnou přednost, řešte podle asociativnosti, tedy buď zprava doleva nebo zleva doprava. Vysvětlení níže uvedeného programu je dobře napsáno v komentářích v rámci samotného programu.
    Jáva 
    public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;  // precedence rules for arithmetic operators.  // (* = / = %)>(+ = -) // vytiskne a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // pokud mají stejnou prioritu, pak jsou dodržována asociativní // pravidla.  // e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f) System.out.println('a+b*d-e/f = ' + (a + b * d - e/f));  } }>
           
      Výstup  
    a+b/d = 20 a+b*d-e/f = 219>
     
        2. Staňte se kompilátorem:    
    Kompilátor v našich systémech používá nástroj lex, aby při generování tokenů dosáhl nejvyšší shody. To v případě přehlédnutí vytváří trochu problém. Zvažte například prohlášení    a=b++c    ; příliš mnoho čtenářů se může zdát, že vytváří chybu kompilátoru. Ale toto tvrzení je naprosto správné, protože token vytvořený lex je a, =, b, ++, +, c. Proto má tento příkaz podobný účinek, že nejprve přiřadíte b+c k a a poté b zvýšíte. Podobně a=b++++c; by vygenerovalo chybu, protože vygenerované tokeny jsou a, =, b, ++, ++, +, c. což je ve skutečnosti chyba, protože za druhým unárním operandem není žádný operand.
    Jáva 
    public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 0;  // a=b+++c is compiled as  // b++ +c  // a=b+c then b=b+1  a = b++ + c;  System.out.println('Value of a(b+c), '  + ' b(b+1), c = ' + a + ', ' + b  + ', ' + c);  // a=b+++++c is compiled as  // b++ ++ +c  // which gives error.  // a=b+++++c;  // System.out.println(b+++++c);  } }>
           
      Výstup  
    Value of a(b+c), b(b+1), c = 10, 11, 0>
     
        3. Použití + over ():    
    Při použití operátoru + uvnitř      system.out.println()      nezapomeňte provést sčítání pomocí závorek. Pokud něco napíšeme, než provedeme sčítání, pak dojde k sčítání řetězců, to znamená, že asociativita sčítání je zleva doprava, a proto se k řetězci nejprve přidají celá čísla a vytvoří se řetězec a při použití + se řetězcové objekty zřetězí. Proto může vytvářet nežádoucí výsledky.
    Jáva 
    public class operators {  public static void main(String[] args)  {  int x = 5, y = 8;  // concatenates x and y as  // first x is added to 'concatenation (x+y) = '  // producing 'concatenation (x+y) = 5'  // and then 8 is further concatenated.  System.out.println('Concatenation (x+y)= ' + x + y);  // addition of x and y  System.out.println('Addition (x+y) = ' + (x + y));  } }>
           
      Výstup  
    Concatenation (x+y)= 58 Addition (x+y) = 13>
     
    Výhody operátorů v Javě
    Výhody používání operátorů v Javě jsou uvedeny níže:
     
    1.     Expresivita    : Operátory v Javě poskytují stručný a čitelný způsob provádění složitých výpočtů a logických operací.
    2.     Úspora času:    Operátoři v Javě šetří čas tím, že snižují množství kódu potřebného k provádění určitých úkolů.
    3.     Zlepšený výkon    : Použití operátorů může zlepšit výkon, protože jsou často implementovány na hardwarové úrovni, takže jsou rychlejší než ekvivalentní kód Java.
    Nevýhody operátorů v Javě
    Nevýhody operátorů v Javě jsou uvedeny níže:
     
    1.     Priorita operátora:    Operátory v Javě mají definovanou prioritu, což může vést k neočekávaným výsledkům, pokud nejsou správně používány.
    2.     Typ donucení    : Java při použití operátorů provádí implicitní převody typů, což může vést k neočekávaným výsledkům nebo chybám, pokud se nepoužívá správně.
    Nejčastější dotazy v Java Operators
    1. Co jsou operátory v Javě s příkladem?
    Operátory jsou speciální symboly, které se používají pro provádění určitých operací. Například „+“ se používá pro sčítání, kde 5+4 vrátí hodnotu 9.