Numerikus operátorok a Java nyelven

Szia! Ma egy nagyon fontos témával foglalkozunk, nevezetesen a Java numerikus operátoraival . A programozásban a számok mindenhol jelen vannak. Ha mélyre ásunk, és emlékszel a középiskolára, eszünkbe juthat, hogy a számítógép minden információt numerikus formátumban reprezentál: nullák és egyesek kombinációit, más néven bináris kódot. Rengeteg numerikus operátor van a programozásban, ezért példákon keresztül feltárjuk a legfontosabbakat :) Kezdjük a legegyszerűbbel: aritmetikai operátorok . Ezek a jól ismert összeadás ( +), kivonás ( -), szorzás ( *) és osztás ( /) operátorok.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Konzol kimenet: 1032 966 32967 30 Mindezt már használtad. Ehhez a csoporthoz hozzáadhat a maradékhoz vagy a modulo ( %) operátorhoz.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Konzol kimenete: 1 Ebben a példában a 33-at elosztjuk 2-vel. Ez 16-ot ad, egy extra "farokkal" (egy), amely nem osztható 2-vel. Ez a "farok" a "maradék az osztásból" művelet eredménye. A Java összehasonlító/relációs operátorokat is megvalósít (akárcsak a matematikában). Valószínűleg neked is ismerősek az iskolából:

• egyenlő ( ==)
• nagyobb, mint ( >)
• kevesebb, mint ( <)
• nagyobb vagy egyenlő, mint ( >=)
• kisebb vagy egyenlő, mint ( <=)
• nem egyenlő ( !=)

Itt érdemes figyelni egy fontos pontra, amely sok kezdő hibát okoz. Az "egyenlő" operátor ==, nem pedig =. A Java nyelvben a single =a hozzárendelési operátor, amelyet akkor használunk, ha egy változóhoz számot, karakterláncot vagy egy másik változó értékét rendelünk .

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Konzol kimenet: 999 Hoppá! Nyilvánvalóan nem ez az eredmény, amit vártunk. Ez egy teljesen más adattípus: egy logikai értékre számítottunk , de kaptunk egy számot. Mindez azért, mert összehasonlítás helyett hozzárendelési operátort használtunk a zárójelben . A (999) értékét a változóhoz rendeltük , majd megjelenítettük a . Íme a helyes módja ennek: x=yyxx

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Konzol kimenet: false Most jól összehasonlítottuk a két számot! :) Itt van a hozzárendelés operátor ( ) másik jellemzője =: össze lehet "láncolni":

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Konzol kimenet: 256 Ne feledje, hogy a hozzárendelés jobbról balra történik . Ez a kifejezés ( x = y = z) lépésekben hajtódik végre:

• y = z, vagyisy = 256
• x = y, vagyisx = 256

Unáris operátorok.

Az uno szóból " egyetlen "-nek nevezik őket , ami " egyet " jelent. Azért kapták ezt a nevet, mert a korábbi operátorokkal ellentétben egyetlen számra hatnak, nem többre. Ezek tartalmazzák:

• Egyedi mínusz. Megfordítja a szám jelét.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Konzol kimenet: -999 999 Kétszer használtuk az unáris mínusz operátort. Ennek hatására először negatív lett a számunk, majd ismét pozitív lett!

• Növekedés (++) és csökkentés (--)

Az ++operátor egy számot eggyel növel, az --operátor pedig ugyanennyivel csökkenti a számot.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Konzol kimenet: 1000 999 Ez a jelölés ismerős lehet Önnek, ha hallott már a C++ nyelvről. Alkotói ezzel az érdekes elnevezéssel azt a gondolatot közvetítették, hogy „A C++ a C nyelv kiterjesztése” A Notepad népszerű, továbbfejlesztett változata a Notepad++. Itt van egy fontos pont. Kétféle növelési és csökkentési operátor létezik: postfix és prefix . x++- postfix ++x- előtag Mi az alapvető különbség a plusz/mínusz jelek szám elé vagy mögé helyezése között? A következő példában látni fogjuk:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Konzol kimenet: 999 Valami nem stimmel! 1-gyel akartuk növelni xés az új értéket az y változóhoz rendelni. Más szavakkal, y-nak 1000-nek kell lennie. De ehelyett valami mást kapunk: 999. Úgy tűnik, hogy az x-et nem növelték, és a növekmény operátor nem működött? De működött. Hogy meggyőzze magát, próbálja meg xa végén megjeleníteni :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Konzol kimenet: 999 1000 Valójában pontosan ezért hívják ezt a műveletet postfixnek: a fő kifejezés után hajtják végre. Ez a mi esetünkben azt jelenti, hogy int y = x++; y = xelőször végrehajtásra kerül (és a változó yinicializálása az értékre történik x), és csak ezután kerül x++végrehajtásra. Mi van, ha nem ezt a viselkedést akarjuk? Ezután előtag jelölést kell használnunk :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

Ebben az esetben ++xelőször feldolgozásra kerül, és csak utána kerül feldolgozásra y = x; végrehajtott. Ezt a különbséget azonnal rögzítse a memóriában, hogy elkerülje a hibákat egy valódi programban, ahol a postfix használata az előtag helyett mindent a feje tetejére állít :)

Összetett operátorok

Ezenkívül a Java-ban vannak úgynevezett összetett operátorok. Két operátort kombinálnak:

• Feladat
• Aritmetikai operátorok

Ezek tartalmazzák:

• +=
• -=
• *=
• /=
• %=

Nézzünk egy példát:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Konzol kimenet: 1032 x += y azt jelenti x = x + y. A két szimbólumot a rövidség kedvéért egymás után használjuk. A -=, *=és /=kombinációk %=hasonló módon működnek.

Logikai operátorok

A numerikus operátorokon kívül a Java logikai értékeket ( igaz és hamis ) is magában foglaló műveleteket is tartalmaz. Ezeket a műveleteket logikai operátorok segítségével hajtják végre

• !- logikus NEM . Megfordítja a logikai értékét

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Konzol kimenet: false

• &&- logikai ÉS . Csak akkor ad vissza igazat, ha mindkét operandus igaz.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Konzol kimenet: false true Az első művelet eredménye false, mert az egyik operandus false, mégpedig 100 > 200. Az igaz visszaadásához az &&operátor megköveteli, hogy mindkét operandus igaz legyen (ahogyan a második sorban is).

• ||- logikai VAGY . Igaz értékkel tér vissza, ha legalább az egyik operandus igaz.

Ha ezt az operátort használjuk, az előző példánk más eredményt ad:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Konzol kimenet: true A kifejezés 100 > 200továbbra is hamis, de az OR operátorhoz teljesen elegendő, ha az első rész ( 100 > 10) igaz.