Арифметические операции
Начнем с самого простого — с арифметических операций. Это известные всем сложение (знак +), вычитание (-), умножение (*) и деление (/).
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
Всем этим ты уже пользовался. К ним можно прибавить операцию %
— остаток от деления.
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 (как и в математике) реализованы операции сравнения. Они тебе тоже наверняка знакомы еще со школы:
- равно (
==
) - больше (
>
) - меньше (
<
) - больше либо равно (
>=
) - меньше либо равно (
<=
) - не равно (
!=
)
==
, а не одним знаком =
.
Единичный знак =
в Java является оператором присваивания, когда переменной присваивается число, строка, или значения другой переменной.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x=y);//ожидаем, что в консоль будет выведено false
}
}
Вывод в консоль:
999
Упс! Это явно не тот результат, на который мы рассчитывали. Это вообще другой тип данных: мы ожидали увидеть boolean
, а получили число. Все потому, что в скобках у нас операция присваивания, а не сравнения.
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
Вот теперь мы правильно сравнили 2 числа! :)
Еще одна особенность операции присваивания (=
) — ее можно осуществлять “по цепочке”:
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 , то есть у = 256
- x = y, то есть x = 256
Унарные операции
Они называются “унарными” от слова “uno” — “один”. Такое название они получили потому, что в отличие от предыдущих, проводятся над одним числом, а не над несколькими. К ним относятся:Унарный минус. Он меняет знак числа на противоположный.
public class Main { public static void main(String[] args) { int x = 999; //меняем знак первый раз x = -x; System.out.println(x); //меняем знак второй раз 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
x++
— постфиксная запись
++x
— префиксная запись
В чем же заключается принципиальная разница, если ставить плюсы-минусы перед числом или после?
Увидим на примере:
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. Но у нас другой результат — 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
На самом деле, постфиксная операция потому так и называется: она выполняется после основного выражения. То есть в нашем случае:
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;
Эту разницу стоит запомнить сразу, чтобы не совершить ошибок в реальной программе, в которой все поведение может из-за этого встать с ног на голову :)
Комбинированные операции
Кроме того, в 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 существуют также операции над булевыми переменными —true
и false
.
Эти операции выполняются с помощью логических операторов
!
— оператор “НЕ”. Меняет значение булевой переменной на противоположноеpublic class Main { public static void main(String[] args) { boolean x = true; System.out.println(!x); } }
Вывод в консоль:
false
&&
— оператор “И”. Возвращает значение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
, поскольку одно из условий является ложным, а именно 100 > 200. Оператору&&
для того, чтобы вернутьtrue
требуется, чтобы истинными были все условия (как во второй строке, например).||
— оператор “ИЛИ”. Возвращаетtrue
, когда хотя бы один из операндов истинный.Здесь наш предыдущий пример уже отработает по-другому:
public class Main { public static void main(String[] args) { System.out.println(100 > 10 || 100 > 200); } }
Вывод в консоль:
true
Выражение 100 > 200 по-прежнему ложно, но оператору “или” вполне достаточно, что первая часть (100 > 10) является истинной.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ