logo

TechCodeview

Operátori v jazyku Java

Java poskytuje mnoho typov operátorov, ktoré možno použiť podľa potreby. Sú klasifikované na základe funkcií, ktoré poskytujú. V tomto článku sa dozvieme o operátoroch Java a naučíme sa všetky ich typy.

Čo sú to operátori Java?

Operátory v jazyku Java sú symboly používané na vykonávanie špecifických operácií v jazyku Java. Operátori robia úlohy ako sčítanie, násobenie atď., ktoré vyzerajú jednoducho, hoci implementácia týchto úloh je pomerne zložitá.



Typy operátorov v Jave

V jazyku Java existuje niekoľko typov operátorov, všetky sú uvedené nižšie:

  1. Aritmetické operátory
  2. Unární operátori
  3. Operátor pridelenia
  4. Vzťahoví operátori
  5. Logické operátory
  6. Ternárny operátor
  7. Bitové operátory
  8. Zmenoví operátori
  9. inštancia operátora

1. Aritmetické operátory

Používajú sa na vykonávanie jednoduchých aritmetických operácií na primitívnych typoch údajov.

metóda podreťazca java
  • * : Násobenie
  • / : divízie
  • %: modul
  • + : Doplnenie
  • – : Odčítanie

Príklad:



Java 
// 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ýkon 
a + b = 13 a - b = 7 a * b = 30 a / b = 3 a % b = 1>

2. Unárne operátory

Unárne operátory potrebujú iba jeden operand. Používajú sa na zvýšenie, zníženie alebo negáciu hodnoty.

  • – : Unárne mínus , ktorý sa používa na negovanie hodnôt.
  • + : Unárne plus označuje kladnú hodnotu (čísla sú však kladné aj bez nej). Vykoná automatickú konverziu na int, keď typ jeho operandu je byte, char alebo short. Toto sa nazýva unárne numerické povýšenie.
  • ++: Operátor prírastku , ktorý sa používa na zvýšenie hodnoty o 1. Existujú dva druhy operátorov prírastku.
    • Po prírastku: Hodnota sa najprv použije na výpočet výsledku a potom sa zvýši.
    • Predprírastok: Najprv sa zvýši hodnota a potom sa vypočíta výsledok.
  • – – : Operátor zníženia , ktorý sa používa na zníženie hodnoty o 1. Existujú dva druhy operátorov znižovania.
    • Po znížení: Hodnota sa najprv použije na výpočet výsledku a potom sa zníži.
    • Pre-Decrement: Hodnota sa najskôr zníži a potom sa vypočíta výsledok.
  • ! : Logický nie operátor , ktorý sa používa na invertovanie boolovskej hodnoty.

Príklad:

rozvetvené stromy
Java 
// 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ýkon 
Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Operátor pridelenia

'=' Operátor priradenia sa používa na priradenie hodnoty akejkoľvek premennej. Má asociatívnosť sprava doľava, t. j. hodnota uvedená na pravej strane operátora je priradená premennej naľavo, a preto musí byť hodnota na pravej strane deklarovaná pred jej použitím alebo by mala byť konštantná.



Všeobecný formát operátora priradenia je:

variable   =   value;>

V mnohých prípadoch možno operátor priradenia skombinovať s inými operátormi a vytvoriť tak kratšiu verziu príkazu s názvom a Zložené vyhlásenie . Napríklad namiesto a = a+5, môžeme napísať a += 5.

  • += , na sčítanie ľavého operandu s pravým operandom a jeho následné priradenie k premennej vľavo.
  • -= , na odčítanie pravého operandu od ľavého operandu a jeho následné priradenie k premennej vľavo.
  • *= , na vynásobenie ľavého operandu pravým operandom a jeho následné priradenie k premennej vľavo.
  • /= , na delenie ľavého operandu pravým operandom a jeho následné priradenie k premennej vľavo.
  • %= , na priradenie modulo ľavého operandu pravým operandom a jeho následné priradenie k premennej vľavo.

Príklad:

Java 
// Java Program to implement // Assignment Operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  = 0b1100: ' + (f  }>
Výkon 
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. Vzťahoví operátori    
Tieto operátory sa používajú na kontrolu vzťahov ako rovnosť, väčšia ako a menšia ako. Po porovnaní vracajú boolovské výsledky a vo veľkej miere sa používajú v cyklických príkazoch, ako aj v podmienených príkazoch if-else. Všeobecný formát je,
 Niektoré z relačných operátorov sú -
 
  •     ==, Rovná sa    vráti hodnotu true, ak sa ľavá strana rovná pravej strane.
  •     !=, Nerovná sa    vráti hodnotu true, ak sa ľavá strana nerovná pravej strane.
  •     <, menej ako:    vráti hodnotu true, ak je ľavá strana menšia ako pravá strana.
  •     <=, menšie alebo rovné    vráti hodnotu true, ak je ľavá strana menšia alebo rovná pravej strane.
  •     >, Väčšie ako:    vráti hodnotu true, ak je ľavá strana väčšia ako pravá strana.
  •     >=, Väčšie alebo rovné    vráti hodnotu true, ak je ľavá strana väčšia alebo rovná pravej strane.
    Príklad:    
Java 
// 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ýkon  
a>b: pravda a = b: pravda a<= b: false a == c: false a != c: true>
 
    5. Logické operátory    
Tieto operátory sa používajú na vykonávanie operácií logického AND a logického ALEBO, t. j. funkcie podobnej ako hradlo AND a hradlo OR v digitálnej elektronike. Jedna vec, ktorú treba mať na pamäti, je, že druhá podmienka sa nevyhodnocuje, ak je prvá nesprávna, t. j. má skratový účinok. Vo veľkej miere sa používa na testovanie niekoľkých podmienok pri rozhodovaní. Java má tiež logické NIE, ktoré vráti hodnotu true, keď je podmienka nepravdivá a naopak
reagovať inline štýlom

 
Podmienené operátory sú:
 
  •     &&, logické AND:    vráti hodnotu true, keď sú splnené obe podmienky.
  •     ||, logické ALEBO:    vráti hodnotu true, ak je splnená aspoň jedna podmienka.
  •     !, logické NIE:    vráti true, keď je podmienka nepravdivá a naopak
    Príklad:    
Java 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
   
  Výkon  
x && y: false x || y: true !x: false>
 
    6. Ternárny operátor    
Ternárny operátor je skrátenou verziou príkazu if-else. Má tri operandy a odtiaľ názov Ternary.
 
Všeobecný formát je:
 
condition   ?   if true   :   if false>
Vyššie uvedené vyhlásenie znamená, že ak sa podmienka vyhodnotí ako pravdivá, potom vykonajte príkazy po „?“, inak vykonajte príkazy po „:“.
rekha vek

 
    Príklad:    
Java 
// 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) ? b : c);  System.out.println('Maximálne tri čísla = ' + výsledok);  } }>
   
  Výkon  
Max of three numbers = 30>
 
    7. Bitové operátory    
Tieto operátory sa používajú na vykonávanie manipulácie s jednotlivými bitmi čísla. Môžu byť použité s ktorýmkoľvek z celočíselných typov. Používajú sa pri vykonávaní operácií aktualizácie a dotazovania binárnych indexovaných stromov.
 
  •     &, bitový operátor AND:    vracia bit po bite AND vstupných hodnôt.
  •     |, bitový operátor OR:    vracia bit po bite ALEBO vstupných hodnôt.
  •     ^, bitový operátor XOR:    vracia bit po bite XOR vstupných hodnôt.
  •     ~, Operátor bitového doplnku:    Toto je unárny operátor, ktorý vracia reprezentáciu jednej vstupnej hodnoty, t.j. so všetkými invertovanými bitmi.
Java 
// 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ýkon  
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1:6 a>>> 1:6>>> 
    8. Operátori zmien    
Tieto operátory sa používajú na posunutie bitov čísla doľava alebo doprava, čím sa číslo vynásobí alebo vydelí dvoma. Môžu sa použiť, keď musíme číslo vynásobiť alebo vydeliť dvoma. Všeobecný formát -
     <<, Operátor zmeny vľavo:    posunie bity čísla doľava a výsledkom je vyplnenie prázdnych miest 0. Podobný efekt ako vynásobenie čísla nejakou mocninou dvoch.
  •     >>, Operátor posunu vpravo:    posunie bity čísla doprava a v dôsledku toho vyplní 0 prázdne miesta vľavo. Bit úplne vľavo závisí od znamienka počiatočného čísla. Podobný efekt ako pri delení čísla nejakou mocninou dvoch.
  •     >>>, nepodpísaný operátor posunu vpravo:    posunie bity čísla doprava a v dôsledku toho vyplní 0 prázdne miesta vľavo. Bit úplne vľavo je nastavený na 0.
    • Java 
    // 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ýkon  
    a<<1 : 20 a>>1 : 5>>
     
        9. inštancia operátora    
    Inštancia operátora sa používa na kontrolu typu. Môže sa použiť na testovanie, či je objekt inštanciou triedy, podtriedy alebo rozhrania. Všeobecný formát -
     
    object   instance of   class/subclass/interface>
    Java 
    // 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ýkon  
    obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
     
    Prednosť a asociativita operátorov Java
    Pravidlá priority a asociatívne pravidlá sa používajú pri práci s hybridnými rovnicami zahŕňajúcimi viac ako jeden typ operátora. V takýchto prípadoch tieto pravidlá určujú, ktorá časť rovnice sa má zvážiť ako prvá, pretože pre tú istú rovnicu môže existovať veľa rôznych hodnotení. Nižšie uvedená tabuľka zobrazuje prioritu operátorov v klesajúcom poradí podľa veľkosti, pričom horná časť predstavuje najvyššiu prioritu a spodná časť zobrazuje najnižšiu prioritu.
     
     Prednosť a asociativita operátorov v Jave
     
    Zaujímavé otázky o operátoroch Java
        1. Priorita a asociativita:    
    Často dochádza k zmätku, pokiaľ ide o hybridné rovnice, ktoré sú rovnicami s viacerými operátormi. Problém je, ktorú časť riešiť ako prvú. V týchto situáciách je potrebné dodržiavať zlaté pravidlo. Ak majú operátori inú prioritu, vyriešte najprv vyššiu prioritu. Ak majú rovnakú prednosť, riešte podľa asociatívnosti, teda buď sprava doľava, alebo zľava doprava. Vysvetlenie nižšie uvedeného programu je dobre napísané v komentároch v rámci samotného programu.
    Java 
    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.  // (* = / = %)>(+ = -) // vytlačí a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // ak má rovnakú prednosť, potom sa dodržiavajú asociatívne // pravidlá.  // 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ýkon  
    a+b/d = 20 a+b*d-e/f = 219>
     
        2. Staňte sa kompilátorom:    
    Kompilátor v našich systémoch používa nástroj lex, aby pri generovaní tokenov dosiahol najväčšiu zhodu. To vytvára trochu problém, ak sa prehliada. Zvážte napríklad vyhlásenie    a=b++c    ; príliš veľa čitateľov sa môže zdať, že vytvára chybu kompilátora. Ale toto tvrdenie je úplne správne, pretože token vytvorený lexom je a, =, b, ++, +, c. Preto má toto tvrdenie podobný účinok, že najprv priradíme b+c k a a potom zvýšime b. Podobne a=b++++c; by vygenerovalo chybu, pretože vygenerované tokeny sú a, =, b, ++, ++, +, c. čo je v skutočnosti chyba, pretože za druhým unárnym operandom nie je žiadny operand.
    disketa

    Java 
    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ýkon  
    Value of a(b+c), b(b+1), c = 10, 11, 0>
     
        3. Použitie + cez ():    
    Pri použití operátora + vo vnútri      system.out.println()      nezabudnite vykonať sčítanie pomocou zátvoriek. Ak niečo napíšeme pred vykonaním sčítania, potom sa uskutoční sčítanie reťazcov, to znamená, že asociativita sčítania je zľava doprava, a preto sa do reťazca najprv pridajú celé čísla, čím sa vytvorí reťazec, a reťazcové objekty sa zreťazia pri použití +. Preto môže spôsobiť nežiaduce výsledky.
    Java 
    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ýkon  
    Concatenation (x+y)= 58 Addition (x+y) = 13>
     
    Výhody operátorov v Jave
    Výhody používania operátorov v jazyku Java sú uvedené nižšie:
     
    1.     Expresívnosť    : Operátory v jazyku Java poskytujú stručný a čitateľný spôsob vykonávania zložitých výpočtov a logických operácií.
    2.     Úspora času:    Operátori v jazyku Java šetria čas znížením množstva kódu potrebného na vykonávanie určitých úloh.
    3.     Vylepšený výkon    : Používanie operátorov môže zlepšiť výkon, pretože sú často implementované na hardvérovej úrovni, vďaka čomu sú rýchlejšie ako ekvivalentný kód Java.
    Nevýhody operátorov v Jave
    Nevýhody operátorov v jazyku Java sú uvedené nižšie:
     
    1.     Priorita operátora:    Operátory v jazyku Java majú definovanú prioritu, čo môže viesť k neočakávaným výsledkom, ak sa nepoužívajú správne.
    2.     Typ nátlaku    : Java pri používaní operátorov vykonáva implicitné konverzie typov, ktoré môžu viesť k neočakávaným výsledkom alebo chybám, ak sa nepoužívajú správne.
    Často kladené otázky o operátoroch Java
    1. Čo sú operátori v Jave s príkladom?
    Operátory sú špeciálne symboly, ktoré sa používajú na vykonávanie určitých operácií. Napríklad „+“ sa používa na sčítanie, kde 5+4 vráti hodnotu 9.