Числени оператори в Java

здрасти Днес ще разгледаме една много важна тема, а именно числовите оператори в Java . В програмирането числата са навсякъде. Ако се задълбочите и си спомните гимназията, може да си спомните, че компютърът представя цялата информация в цифров формат: комбинации от нули и единици, известни също като двоичен code. Има много числови оператори в програмирането, така че ще използваме примери, за да изследваме най-важните от тях :) Нека започнем с най-простите: аритметични оператори . Това са добре познатите оператори събиране ( +), изваждане ( -), умножение ( *) и деление ( /).

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);
   }
}

Изход от конзолата: 1032 966 32967 30 Вече сте използвали всичко това. Към тази група можете да добавите %оператор за остатък or модул ( ).

public class Main {

   public static void main(String[] args) {

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

Конзолен изход: 1 В този пример ние разделяме 33 на 2. Това дава 16 с допълнителна "опашка" (едно), която не се дели на 2. Тази "опашка" е резултат от операцията "остатък от деленето". Java също така прилага оператори за сравнение/релация (точно Howто в математиката). Сигурно са ви познати и от учorще:

• равно на ( ==)
• по-голямо от ( >)
• по-малко от ( <)
• по-голямо or равно на ( >=)
• по-малко or равно на ( <=)
• не е равно ( !=)

Тук трябва да обърнете внимание на един важен момент, който кара много начинаещи да правят грешки. Операторът "равно" е написан ==, а не =. В Java единичен =е операторът за присвояване , който се използва, когато на променлива е присвоено число, низ or стойността на друга променлива.

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
   }
}

Изход от конзолата: 999 Ами сега! Очевидно това не е резултатът, който очаквахме. Това е съвсем различен тип данни: очаквахме да видим булево , но получихме число. Всичко това, защото използвахме оператор за присвояване в скобите instead of сравнение . x=y Стойността на y(999) беше присвоена на променливата xи след това показахме стойността на x. Ето правилния начин да го направите:

public class Main {

   public static void main(String[] args) {

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

Изход от конзолата: false Сега сравнихме двете числа правилно! :) Ето още една характеристика на оператора за присвояване ( =): той може да бъде "свързан" заедно:

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);
   }
}

Конзолен изход: 256 Запомнете, че присвояването е отдясно наляво . Този израз ( x = y = z) ще бъде изпълнен на стъпки:

• y = z, това е,y = 256
• x = y, това е,x = 256

Унарни оператори.

Те се наричат ​​" унарни " от думата " uno ", което означава " един ". Те получиха това име, защото за разлика от предишните оператори действат на един номер, а не на няколко. Те включват:

• Унарен минус. Обръща знака на номера.

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);
   }
}

Конзолен изход: -999 999 Използвахме унарния оператор минус два пъти. В резултат номерът ни първо беше отрицателен, а след това отново стана положителен!

• Увеличаване (++) и намаляване (--)

Операторът ++увеличава числото с единица и --операторът намалява числото със същата стойност.

public class Main {

   public static void main(String[] args) {

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

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

Конзолен изход: 1000 999 Тази нотация може да ви е позната, ако сте чували за езика C++. Неговите създатели са използвали това интересно име, за да предадат идеята, че "C++ е разширение на езика C" Популярна подобрена version на Notepad се нарича Notepad++ Ето един важен момент. Има два типа оператори за увеличаване и намаляване: постфикс и префикс . x++- постфикс ++x- префикс Каква е основната разлика между поставянето на плюсовете/минусите преди or след числото? Ще видим в следния пример:

public class Main {

   public static void main(String[] args) {

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

Изход от конзолата: 999 Нещо не е наред! Искахме да увеличим xс 1 и да присвоим новата стойност на променливата y. С други думи, y трябва да е 1000. Но instead of това получаваме нещо друго: 999. Изглежда, че x не е увеличено и че операторът за нарастване не работи? Но проработи. За да се убедите, опитайте да покажете xнакрая :)

public class Main {

   public static void main(String[] args) {

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

Конзолен изход: 999 1000 Всъщност точно затова тази операция се нарича postfix: изпълнява се след основния израз. Това означава, в нашия случай: int y = x++; y = xпърво се изпълнява (и променливата yще бъде инициализирана до стойността на x), и едва след това ще x++бъде изпълнена. Какво ще стане, ако това не е поведението, което искаме? След това трябва да използваме префиксна нотация:

public class Main {

   public static void main(String[] args) {

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

В този случай ++xпърво се обработва и едва след това е y = x; изпълнен. Трябва незабавно да запишете тази разлика в паметта, за да избегнете грешки в реална програма, където използването на постфикс instead of префикс може да обърне всичко с главата надолу :)

Съставни оператори

Освен това в Java има така наречените съставни оператори. Те комбинират два оператора:

• Възлагане
• Аритметични оператори

Те включват:

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

Да разгледаме един пример:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

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

Конзолен изход: 1032 x += y означава x = x + y. Двата символа се използват последователно за краткост. Комбинациите -=, *=, /=и %=работят по подобен начин.

Логически оператори

В допълнение към числовите оператори, Java има и операции, които включват булеви стойности ( истина и невярно ). Тези операции се извършват с помощта на логически оператори

• !- логично НЕ . Обръща стойността на булева стойност

public class Main {

   public static void main(String[] args) {

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

Конзолен изход: невярно

• &&- логическо И . Връща true само ако и двата операнда са true.

public class Main {

   public static void main(String[] args) {

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

Конзолен изход: false true Резултатът от първата операция е false, защото един от операндите е false, а именно 100 > 200. За да върне true, &&операторът изисква и двата операнда да са true (Howто е случаят във втория ред).

• ||- логическо ИЛИ . Връща true, когато поне един от операндите е true.

Когато използваме този оператор, предишният ни пример дава различен резултат:

public class Main {

   public static void main(String[] args) {

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

Конзолен изход: true Изразът 100 > 200все още е false, но за оператора OR е напълно достатъчно първата част ( 100 > 10) да е true.