atesting.ru Блог Операторы в Java | Учебник по Java

Операторы в Java | Учебник по Java

В предыдущем посте вы узнали о переменных и типах данных. Теперь давайте узнаем, что мы можем с ними делать.

Операторы в Java — это специальные символы, которые выполняют определенные операции и затем возвращают результат.

Типы операторов в Java:

1. Арифметические операторы
2. Операторы присваивания
3. Операторы автоматического увеличения и операторы автоматического уменьшения
4. Логические операторы
5. Операторы сравнения (реляционные)
6. Побитовые операторы
7. Тернарный оператор

Арифметические операторы:

Арифметические операторы: +, -, *, /,%

+ — сложение
— вычитание
* — умножение
/- деление
% — оператор модуля — возвращает остаток от целочисленного деления

Операторы в Java | Руководство по Java

123456789101112131415161718 пакет classOperators; публичный класс ArthimeticOperators {публичный статический void main (String [] args) {int num1 = 100; int num2 = 50; System.out.println (& # 34; Сложение двух чисел — & # 34; + (num1 + num2)); System.out.println (& # 34; Вычитание двух чисел — & # 34; + (num1 — num2)); System.out.println (& # 34; Умножение двух чисел — & # 34; + (num1 * num2)); System.out.println (& # 34; деление двух чисел — & # 34; + (num1/num2)); System.out.println (& # 34; Модуль двух чисел равен & # 34; + (num1% num2)); }}

Операторы присваивания:

Операторы присваивания в java: =, + =, — =, * =,/=,% =

123456789101112131415161718192021222324252627282930313233343536 пакет classOperators; публичный класс AssignmentOperators {публичный статический недействительный основной (String [] аргументы) {int num1 = 100; int num2 = 50; //Присваиваем значение переменной num2 переменной num1 num1 = num2; System.out.println (& # 34; Вывод num1 = num2 равен & # 34; + num1); //num1 = num1 + num2 num1 + = num2; System.out.println (& # 34; Вывод num1 = num1 + num2 равен & # 34; + num1); //num1 = num1-num2 num1 — = num2; System.out.println (& # 34; Вывод num1 = num1-num2 равен & # 34; + num1); //num1 = num1 * num2 num1 * = num2; System.out.println (& # 34; Вывод num1 = num1 * num2 равен & # 34; + num1); //num1 = num1/num2 num1/= num2; System.out.println (& # 34; Вывод num1 = num1/num2 равен & # 34; + num1); //num1 = num1% num2 num1% = num2; System.out.println (& # 34; Вывод num1 = num1% num2 равен & # 34; + num1); }}

Операторы автоматического увеличения и автоматического уменьшения:

Автоинкремент в Java ++
Авто-декремент в Java —

123456789101112131415161718 пакет classOperators; открытый класс AutoIncrementDecrementOperators {общедоступный статический void main (String [] args) {int num1 = 100; int num2 = 50; //num1 = num1 + 1 num1 ++; //num2 = num2 — 1 num2—; System.out.println (& # 34; Вывод num1 + 1 равен & # 34; + num1); System.out.println (& # 34; Вывод num2 — 1 равен & # 34; + num2); }}

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

Логические операторы в Java — это & ​​amp; & amp ;, || ,!

Предположим, у нас есть две логические переменные booleanVal1, booleanVal2

booleanVal1 & amp; & amp; booleanVal2:

Если booleanVal1 и booleanVal2 истинны, тогда вывод будет истинным, иначе вывод будет ложным

booleanVal1 || booleanVal2:

Если booleanVal1 и booleanVal2 имеют значение false, то вывод будет ложным, иначе вывод будет правда. Это означает, что одно из значений истинно, тогда оно возвращает истину.

! BooleanVal1:

Если значение booleanVal1 истинно, оно возвращает false.

123456789101112131415161718 пакет classOperators; публичный класс LogicalOperators {публичный статический void main (String [] args) {логическое booleanVal1 = true; boolean booleanVal2 = false; //& amp; & amp; — AND System.out.println (& # 34; Вывод AND равен & # 34; + (booleanVal1 & amp; & amp; booleanVal2)); //|| — ИЛИ System.out.println (& # 34; Результат ИЛИ равен & # 34; + (booleanVal1 || booleanVal2)); //! — НЕ System.out.println (& # 34; Вывод НЕ равен & # 34; + (! BooleanVal1)); }}

Операторы сравнения (реляционные):

Операторы отношения в Java — это ==,! =, & gt ;, & lt ;, & gt; =, & lt; =

== равно — возвращает истину, если левая и правая стороны равны
! = не равно — он возвращает истину, если левая часть не равна правой части оператора
& gt; больше чем — возвращает истину, если левая сторона больше правой
& gt; = больше или равна — возвращает истину, если левая сторона больше или равна правой стороне
& lt; меньше чем — возвращает истину, если левая сторона меньше правой.
& lt; = меньше или равна — возвращает истину, если левая сторона меньше или равна правой стороне

12345678910111213141516171819202122232425 пакет classOperators; открытый класс RelationalOperators {общедоступный статический void main (String [] args) {int num1 = 100; int num2 = 50; //если num1 равно num2, то возвращается истина System.out.println (& # 34; num1 == num2 = & # 34; + (num1 == num2)); //если num1 не равно num2, то возвращается истина System.out.println (& # 34; num1! = num2 = & # 34; + (num1! = num2)); //если num1 больше, чем num2, то возвращается истина System.out.println (& # 34; num1 & gt; num2 = & # 34; + (num1 & gt; num2)); //если num1 меньше num2, то возвращается true System.out.println (& # 34; num1 & lt; num2 = & # 34; + (num1 & lt; num2)); //если num1 больше или равно num2, то возвращается true System.out.println (& # 34; num1 & gt; = num2 = & # 34; + (num1 & gt; = num2)); //если num1 меньше или равно num2, то возвращается true System.out.println (& # 34; num1 & lt; = num2 = & # 34; + (num1 & lt; = num2)); }}

Побитовые операторы:

Побитовые операторы в Java: & amp ;, |, ^, ~, & lt; & lt ;, & gt; & gt;

Поразрядный & amp; Оператор выполняет побитовую операцию И.

Побитовый оператор ^ выполняет операцию побитового исключающего ИЛИ.

Побитовое | Оператор выполняет побитовую операцию ИЛИ.

Унарный оператор поразрядного дополнения «~» инвертирует битовый шаблон; его можно применить к любому из целочисленных типов, сделав каждый «0» «1», а каждый «1» — «0». Например, байт содержит 8 бит; применение этого оператора к значению с битовой комбинацией «00000000» изменит его шаблон на «11111111».

Знаковый оператор сдвига влево «& lt; & lt;» сдвигает битовый шаблон влево, а знаковый оператор сдвига вправо «& gt; & gt;» немного сдвигает узор вправо. Битовая комбинация задается левым операндом, а количество позиций для сдвига — правым операндом. Оператор сдвига вправо без знака «& gt; & gt; & gt;» сдвигает ноль в крайнее левое положение, а крайнее левое положение после «& gt; & gt;» зависит от расширения знака.

«crayon class =»пакет classOperators; открытый класс BitwiseOperators {public static void main (String [] args) {//64 32 16 8 4 2 1 int num1 = 11; //0 0 0 1 0 1 1 int num2 = 21; //0 0 1 0 1 0 1/* Побитовый оператор выполняет побитовую обработку. num1 & amp; num2 сравнивает соответствующие биты num1 и num2 и генерирует 1, если оба бита равны, иначе он возвращает 0. В нашем случае он вернет: 2, что равно 00000010, потому что в двоичной форме num1 и num2 совпадают только вторые последние биты. *///1, если оба бита равны else 0 //0 0 0 0 0 0 1 == вывод будет 1 System.out.println (num1 & amp; num2);/* num1 | num2 сравнивает соответствующие биты num1 и num2 и генерирует 1, если какой-либо бит равен 1, иначе он возвращает 0. В нашем случае он вернет 31, что равно 00011111 *///1, если любой бит равен 1 else 0 //0 0 1 1 1 1 1 == вывод будет 31 System.out.println (num1 | num2);/* num1 ^ num2 сравнивает соответствующие биты num1 и num2 и генерирует 1, если они не равны, иначе он возвращает 0. В нашем примере он вернет 29, что эквивалентно 00011101 *///1, если оба не равны else 0 //0 0 1 1 1 1 0 == вывод будет 30 System.out.println (num1 ^ num2);/* ~ num1 — это оператор дополнения, который просто изменяет бит с 0 на 1 и 1 на 0. В нашем примере он вернет -12, что эквивалентно 8-битному знаку 11110100 *///0 на 1 и 1 на 0//1 1 1 0 1 0 0 == вывод будет 1 System.out.println (~ num1);/* В качестве дополнения до 2 любого числа мы можем вычислить, инвертируя все единицы в 0 и наоборот, чем мы добавляем к нему 1 .. Здесь N = ~ N дает результаты — (N + 1) всегда. Потому что система хранит данные в виде дополнения до 2, что означает, что она хранит ~ N вот так. ~ N = — (~ (~ N) +1) = — (N + 1). *//* num1 & lt; & lt; 2 — это оператор сдвига влево, который перемещает биты влево, отбрасывает крайний левый бит и присваивает крайнему правому биту значение 0. В нашем случае на выходе получается 44, что эквивалентно 00101100 *///0 1 0 1 0 1 0 == вывод будет 1 System.out.println (num1 & lt; & lt; 2);/* Примечание. В приведенном ниже примере мы предоставляем 2 справа от этого оператора сдвига, поэтому биты перемещаются на два места влево. Мы можем изменить это число, и биты будут перемещены на количество битов, указанное в правой части оператора. То же самое относится и к оператору правой стороны. *//* Num1 & gt; & gt; 2 — это оператор сдвига вправо, который перемещает биты вправо, отбрасывает крайний правый бит и присваивает самому левому биту значение 0. В нашем случае на выходе получается 2, что эквивалентно 00000010 *///0 0 0 1 0 1 0 == вывод будет 1 System.out.println (num1 & gt; & gt; 2); }}

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768

Тернарные операторы:

Тернарный оператор оценивает логическое выражение и присваивает значение на основе результат.

Синтаксис:

Переменная num1 = (выражение)? значение, если выражение истинно: значение, если выражение ложно

123456789101112131415161718 package classOperators; открытый класс TernaryOperators {общедоступный статический void main (String [] args) {int num1 = 100; int num2 = 50; int val1 = (число1 & gt; число2)? число1: число2; System.out.println (значение1); int val2 = (число1 & lt; число2)? число1: число2; System.out.println (val2); }}

TAG: qa