Операции над примитивными типами в Java. Изучаем Java
В логическом выражении могут использоваться следующие логические операторы : ==, !=,<=,>=,>,<, &&,||,! .
Рассмотрим на примере:
Int a = 4; int b = 5; boolean result; result = a == b // a равно b - false result = a != b // a не равно b - true result = a < b; // a меньше b - true result = a > b; // a больше b - false result = a <= 4 // a меньше или равно 4 - true result = b >= 6 // b больше или равно 6 - false result = a > b || a < b // (a больше b) логическое или (a меньше b) - true result = 3 < a && a < 6 // (3 меньше a) логическое и (a меньше 6) - true result = !result // логическое нет - false
Отличие == и equals
Оператор ==
работает иначе на объектных типах данных, нежели на примитивных. Когда мы используем объекты и хотим проверить их равенство, то оператор == укажет нам лишь на то, являются ли объекты одними и теми же или нет. Если же необходимо проверить логическое равенство объектов, то следует использовать метод equals
. Пример:
String str1 = new String("Привет"); String str2 = new String("Привет"); String sameStr = str1; boolean b1 = str1 == str2; // b1 - false, потому что str1 и str2 это 2 разных объекта boolean b2 = str1.equals(str2); // b2 - true, потому что str1 и str2 логически эквивалентны boolean b3 = str1 == sameStr ; // b3 -true, потому что str1 и sameStr в действительности один и тот же объект
Условный оператор if
Ели логическое выражение в скобках правдиво, то выполняется, блок кода в фигурных скобках {} после if. Если логическое выражение принимает значение false, то ничего не происходит.
If (a == b) { //Если a равно b - выводим сообщение System.out.println("a и b равны!"); }
Условный оператор if-else
Конструкция if-else отличается от предыдущей тем, что если логическое выражение в круглых скобках принимает значение false, то выполняется блок кода, находящийся в фигурных скобках после ключевого слова else
If (a == b) { //Если a равно b - выводим сообщение System.out.println("a и b равны!"); } else{ //Если a не равно b - выводим сообщение System.out.println("a и b не равны!"); }
Возможные сокращения if-else
1. Если блоки кода if, else содержат лишь одну строку , то можно обойтись без использования фигурных скобок. Предыдущий пример можем записать так:
If (a == b) System.out.println("a и b равны!"); else System.out.println("a и b не равны!");
2. Существует еще один способ сокращения оператора if-else при помощи оператора? : . Запишем предыдущий пример следующим образом:
System.out.println(a==b ? "a и b равны!" : "a и b не равны!");
Общая форма записи условия выглядит следующим образом:
Логическое_выражение? Выражение1: Выражение2
Если Логическое_выражение принимает значение true, то выполняется Выражение1, а иначе — Выражение2. Внимание : при использовании этой конструкции два последних выражения должны иметь один и тот же тип.
Условный оператор switch — case удобен в тех случаях, когда количество вариантов очень много и писать для каждого if-else очень долго. Конструкция имеет следующий вид:
Switch (выражение) { case значение1: //блок кода 1; break; case значение2: //блок кода 2; break; ... case значениеN: //блок кода N; break; default: блок N+1; }
switch работает с такими примитивными типами данных как: byte , short , char , и int . Также с типами Enum, классом String и несколькими специальными классами-оболочками примитивных типов: Character, Byte, Short, Integer.
Выражение в круглых скобках после switch сравнивается со значениями, указанными после слова case, и, в случае совпадения, управление передается соответствующему блоку кода. Если выражение не совпадает ни с одним вариантом case , то управление передается блоку default , который не является обязательным . После выполнения соответствующего блока, оператор break вызывает завершение выполнения оператора switch . Если break отсутствует, то управление передается следующему блоку за только что выполненным.
В следующем примере, для целочисленного значения, представляющего день недели, определяется его название в виде строки. Для значения 3, переменная dayString примет значение «Среда».
Int day = 3; String dayString; switch (day) { case 1: dayString = "Понедельник"; break; case 2: dayString = "Вторник"; break; case 3: dayString = "Среда"; break; case 4: dayString = "Четверг"; break; case 5: dayString = "Пятница"; break; case 6: dayString = "Суббота"; break; case 7: dayString = "Воскресенье"; break; default: dayString = "Ошибка"; break; } System.out.print(dayString);
Упражнения на тему Условные операторы в Java:
- Даны 4 числа типа int. Сравнить их и вывести наименьшее на консоль.
- Вывести на консоль количество максимальных чисел среди этих четырех.
- Даны 5 чисел (тип int). Вывести вначале наименьшее, а затем наибольшее из данных чисел.
- Даны имена 2х человек (тип String). Если имена равны, то вывести сообщение о том, что люди являются тезками.
- Дано число месяца (тип int). Необходимо определить время года (зима, весна, лето, осень) и вывести на консоль.
Логические операторы работают только с операндами типа boolean . Все логические операторы с двумя операндами объединяют два логических значения, образуя результирующее логическое значения. Не путайте с .
Таблица логических операторов в Java
Логические операторы & , | , ^ действуют применительно к значениям типа boolean точно так же, как и по отношению к битам целочисленных значений. Логический оператор ! инвертирует (меняет на противоположный) булево состояние: !true == false и !false == true .
Таблица. Результаты выполнения логических операторов
A | B | A | B | A & B | A ^ B | !A |
---|---|---|---|---|---|
false | false | false | false | false | true |
true | false | true | false | true | false |
false | true | true | false | true | true |
true | true | true | true | false | false |
Сокращённые логические операторы
Кроме стандартных операторов AND (&) и OR (|) существуют сокращённые операторы && и || .
Если взглянуть на таблицу, то видно, что результат выполнения оператора OR равен true true , независимо от значения операнда B. Аналогично, результат выполнения оператора AND равен false , когда значение операнда A равно false , независимо от значения операнда B. Получается, что нам не нужно вычислять значение второго операнда, если результат можно определить уже по первому операнду. Это становится удобным в тех случаях, когда значение правого операнда зависит от значения левого.
Рассмотрим следующий пример. Допустим, мы ввели правило - кормить или не кормить кота в зависимости от числа пойманных мышек в неделю. Причём число мышек зависит от веса кота. Чем больше кот, тем больше он должен поймать мышей.
Кот, прочитавший условие задачи, обиделся на меня. Он заявил, что я отстал от жизни, а на дворе 21 век - мышей можно ловить с помощью мышеловок. Пришлось объяснять ему, что это всего лишь задачка, а не пример из личной жизни.
Int mouse; // число мышек int weight; // вес кота в граммах mouse = 5; weight = 4500; if (mouse != 0 & weight / mouse < 1000) { mInfoTextView.setText("Можно кормить кота"); }
Если запустить программу, то пример будет работать без проблем - пять мышей в неделю вполне достаточно, чтобы побаловать кота вкусным завтраком. Если он поймает четырёх мышей, то начнутся проблемы с питанием кота, но не с программой - она будет работать, просто не будет выводить сообщение о разрешении покормить дармоеда.
Теперь возьмём крайний случай. Кот обленился и не поймал ни одной мышки. Значение переменной mouse будет равно 0, а в выражении есть оператор деления. А делить на 0 нельзя и наша программа закроется с ошибкой. Казалось бы, мы предусмотрели вариант с 0, но Java вычисляет оба выражения mouse != 0 и weight / mouse < 1000 , несмотря на то, что уже в первом выражении возвращается false .
Перепишем условие следующим образом (добавим всего лишь один символ):
If (mouse != 0 && weight / mouse < 1000) { mInfoTextView.setText("Можно кормить кота"); }
Теперь программа работает без краха. Как только Java увидела, что первое выражение возвращает false , то второе выражение с делением просто игнорируется.
Сокращённые варианты операторов AND и OR принято использовать в тех ситуациях, когда требуются операторы булевой логики, а их односимвольные родственники используются для побитовых операций.
Тернарный оператор
В языке Java есть также специальный тернарный условный оператор, которым можно заменить определённые типы операторов if-then-else - это оператор ?:
Тернарный оператор использует три операнда. Выражение записывается в следующей форме:
ЛогическоеУсловие? выражение1: выражение2
Если логическоеУсловие равно true , то вычисляется выражение1 и его результат становится результатом выполнения всего оператора. Если же логическоеУсловие равно false , то вычисляется выражение2 , и его значение становится результатом работы оператора. Оба операнда выражение1 и выражение2 должны возвращать значение одинакового (или совместимого) типа.
Рассмотрим пример, в котором переменной absval присваивается абсолютное значение переменной val .
Int absval, val; val = 5; absval = val < 0 ? -val: val; // выводим число mInfoTextView.setText("" + absval); val = -5; absval = val < 0 ? -val: val; mInfoTextView.setText("" + absval);
Переменной absval будет присвоено значение переменной val , если значение больше или равно нулю (вторая часть выражения). Если значение переменной val отрицательное , то переменной absval присваивается значение переменной, взятое со знаком минус, в результате минус на минус даст плюс, то есть положительно значение. Перепишем код с использованием if-else :
If(val < 0) absval = -val; else absval = val;
Другой пример с тернарным оператором можете посмотреть .
Последнее обновление: 30.10.2018
Большинство операций в Java аналогичны тем, которые применяются в других си-подобных языках. Есть унарные операции (выполняются над одним операндом), бинарные - над двумя операндами, а также тернарные - выполняются над тремя операндами. Операндом является переменная или значение (например, число), участвующее в операции. Рассмотрим все виды операций.
В арифметических операциях участвуют числами. В Java есть бинарные арифметические операции (производятся над двумя операндами) и унарные (выполняются над одним операндом). К бинарным операциям относят следующие:
операция сложения двух чисел:
Int a = 10; int b = 7; int c = a + b; // 17 int d = 4 + b; // 11
операция вычитания двух чисел:
Int a = 10; int b = 7; int c = a - b; // 3 int d = 4 - a; // -6
операция умножения двух чисел
Int a = 10; int b = 7; int c = a * b; // 70 int d = b * 5; // 35
операция деления двух чисел:
Int a = 20; int b = 5; int c = a / b; // 4 double d = 22.5 / 4.5; // 5.0
При делении стоит учитывать, так как если в операции участвуют два целых числа, то результат деления будет округляться до целого числа, даже если результат присваивается переменной float или double:
Double k = 10 / 4; // 2 System.out.println(k);
Чтобы результат представлял числос плавающей точкой, один из операндов также должен представлять число с плавающей точкой:
Double k = 10.0 / 4; // 2.5 System.out.println(k);
получение остатка от деления двух чисел:
Int a = 33; int b = 5; int c = a % b; // 3 int d = 22 % 4; // 2 (22 - 4*5 = 2)
Также есть две унарные арифметические операции, которые производятся над одним числом: ++ (инкремент) и -- (декремент). Каждая из операций имеет две разновидности: префиксная и постфиксная:
++ (префиксный инкремент)
Предполагает увеличение переменной на единицу, например, z=++y (вначале значение переменной y увеличивается на 1, а затем ее значение присваивается переменной z)
Int a = 8; int b = ++a; System.out.println(a); // 9 System.out.println(b); // 9
++ (постфиксный инкремент)
Также представляет увеличение переменной на единицу, например, z=y++ (вначале значение переменной y присваивается переменной z, а потом значение переменной y увеличивается на 1)
Int a = 8; int b = a++; System.out.println(a); // 9 System.out.println(b); // 8
-- (префиксный декремент)
уменьшение переменной на единицу, например, z=--y (вначале значение переменной y уменьшается на 1, а потом ее значение присваивается переменной z)
Int a = 8; int b = --a; System.out.println(a); // 7 System.out.println(b); // 7
-- (постфиксный декремент)
z=y-- (сначала значение переменной y присваивается переменной z, а затем значение переменной y уменьшается на 1)
Int a = 8; int b = a--; System.out.println(a); // 7 System.out.println(b); // 8
Приоритет арифметических операций
Одни операции имеют больший приоритет чем другие и поэтому выполняются вначале. Операции в порядке уменьшения приоритета:
++ (инкремент), -- (декремент)
* (умножение), / (деление), % (остаток от деления)
+ (сложение), - (вычитание)
Приоритет операций следует учитывать при выполнении набора арифметических выражений:
Int a = 8; int b = 7; int c = a + 5 * ++b; System.out.println(c); // 48
Вначале будет выполняться операция инкремента ++b , которая имеет больший приоритет - она увеличит значение переменной b и возвратит его в качестве результата. Затем выполняется умножение 5 * ++b , и только в последнюю очередь выполняется сложение a + 5 * ++b
Скобки позволяют переопределить порядок вычислений:
Int a = 8; int b = 7; int c = (a + 5) * ++b; System.out.println(c); // 104
Несмотря на то, что операция сложения имеет меньший приоритет, но вначале будет выполняться именно сложение, а не умножение, так как операция сложения заключена в скобки.
Ассоциативность операций
Кроме приоритета операции отличаются таким понятием как ассоциативность . Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:
Левоассоциативные операторы, которые выполняются слева направо
Правоассоциативные операторы, которые выполняются справа налево
Так, некоторые операции, например, операции умножения и деления, имеют один и тот же приоритет. Какой же тогда будет результат в выражении:
Int x = 10 / 5 * 2;
Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.
Поскольку все арифметические операторы (кроме префиксного инкремента и декремента) являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.
Операции с числами с плавающей точкой
Следует отметить, что числа с плавающей точкой не подходят для финансовых и других вычислений, где ошибки при округлении могут быть критичными. Например:
Double d = 2.0 - 1.1; System.out.println(d);
В данном случае переменная d будет равна не 0.9, как можно было бы изначально предположить, а 0.8999999999999999. Подобные ошибки точности возникают из-за того, что на низком уровне для представления чисел с плавающей точкой применяется двоичная система, однако для числа 0.1 не существует двоичного представления, также как и для других дробных значений. Поэтому если в таких случаях обычно применяется класс BigDecimal, который позволяет обойти подобные сиуации.
Java предоставляет богатый набор операторов для управления переменными. Все операторы Java можно разделить на следующие группы:
- арифметические операторы;
- операторы сравнения;
- побитовые операторы;
- логические операторы;
- операторы присваивания;
- прочие операторы.
Арифметические операторы
Арифметические операторы - используются в математических выражениях таким же образом, как они используются в алгебре. Предположим, целая переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены арифметические операторы в Java:
Пример
Следующий простой пример показывает программно арифметические операторы. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:
Public class Test { public static void main(String args) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b)); System.out.println("a - b = " + (a - b)); System.out.println("a * b = " + (a * b)); System.out.println("b / a = " + (b / a)); System.out.println("b % a = " + (b % a)); System.out.println("c % a = " + (c % a)); System.out.println("a++ = " + (a++)); System.out.println("b-- = " + (a--)); // Проверьте разницу в d++ и ++d System.out.println("d++ = " + (d++)); System.out.println("++d = " + (++d)); } }
A + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5 a++ = 10 b-- = 11 d++ = 25 ++d = 27
Операторы сравнения
Есть следующие операторы сравнения, поддерживаемые на языке Java. Предположим, переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены реляционные операторы или операторы сравнения в Java:
Оператор | Описание | Пример |
== | Проверяет, равны или нет значения двух операндов, если да, то условие становится истинным | (A == B) - не верны |
!= | Проверяет, равны или нет значения двух операндов, если значения не равны, то условие становится истинным | (A != B) - значение истинна |
> | Проверяет, является ли значение левого операнда больше, чем значение правого операнда, если да, то условие становится истинным | (A > B) - не верны |
Проверяет, является ли значение левого операнда меньше, чем значение правого операнда, если да, то условие становится истинным | (A | |
>= | Проверяет, является ли значение левого операнда больше или равно значению правого операнда, если да, то условие становится истинным | (A >= B) - значение не верны |
Проверяет, если значение левого операнда меньше или равно значению правого операнда, если да, то условие становится истинным | (A |
Пример
Следующий простой пример показывает, программно операторы сравнения в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:
Public class Test { public static void main(String args) { int a = 10; int b = 20; 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 = a = " + (b >= a)); System.out.println("b
A == b = false a != b = true a > b = false a = a = true b
Побитовые операторы
Java определяет несколько побитовых операторов, которые могут быть применены для целочисленных типов: int, long, short, char и byte. В Java побитовый оператор работает над битами и выполняет операцию бит за битом. Предположим, если a = 60; и b = 13; то в двоичном формате они будут следующие:
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Предположим целочисленные переменная A равна 60, а переменная B равна 13. В следующей таблице перечислены побитовые операторы в Java:
Оператор | Описание | Пример |
& (побитовое и) | Бинарный оператор AND копирует бит в результат, если он существует в обоих операндах. | (A & B) даст 12, который является 0000 1100 |
| (побитовое или) | Бинарный оператор OR копирует бит, если он существует в любом из операндов. | (A | B) даст 61 который равен 0011 1101 |
^ (побитовое логическое или) | Бинарный оператор XOR копирует бит, если он установлен в одном операнде, но не в обоих. | (A ^ B) даст 49, которая является 0011 0001 |
~ (побитовое дополнение) | Бинарный оператор дополнения и имеет эффект «отражения» бит. | (~ A) даст -61, которая является формой дополнением 1100 0011 в двоичной записи |
Бинарный оператор сдвига влево. Значение левых операндов перемещается влево на количество бит, заданных правым операндом. | A | |
>> (сдвиг вправо) | Бинарный оператор сдвига вправо. Значение правых операндов перемещается вправо на количество бит, заданных левых операндом. | A >> 2 даст 15, который является 1111 |
>>> (нулевой сдвиг вправо) | Нулевой оператор сдвига вправо. Значение левых операндов перемещается вправо на количество бит, заданных правым операндом, а сдвинутые значения заполняются нулями. | A >>> 2 даст 15, который является 0000 1111 |
Пример
Следующий простой пример показывает, программно побитовые операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:
Public class Test { public static void main(String args) { int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */ int c = 0; c = a & b; /* 12 = 0000 1100 */ System.out.println("a & b = " + c); c = a | b; /* 61 = 0011 1101 */ System.out.println("a | b = " + c); c = a ^ b; /* 49 = 0011 0001 */ System.out.println("a ^ b = " + c); c = ~a; /*-61 = 1100 0011 */ System.out.println("~a = " + c); c = a > 2; /* 215 = 1111 */ System.out.println("a >> 2 = " + c); c = a >>> 2; /* 215 = 0000 1111 */ System.out.println("a >>> 2 = " + c); } }
Будет получен следующий результат:
A & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a > 15 a >>> 15
Логические операторы
Предположим, логическая переменная A имеет значение true, а переменная B хранит false. В следующей таблице перечислены логические операторы в Java:
Пример
Public class Test { public static void main(String args) { boolean a = true; boolean b = false; System.out.println("a && b = " + (a&&b)); System.out.println("a || b = " + (a||b)); System.out.println("!(a && b) = " + !(a && b)); } }
Это произведет следующий результат:
A && b = false a || b = true !(a && b) = true
Операторы присваивания
Существуют следующие операторы присваивания, поддерживаемые языком Java:
Оператор | Описание | Пример |
= | Простой оператор присваивания, присваивает значения из правой стороны операндов к левому операнду | C = A + B, присвоит значение A + B в C |
+= | Оператор присваивания «Добавления», он присваивает левому операнду значения правого | C += A, эквивалентно C = C + A |
-= | Оператор присваивания «Вычитания», он вычитает из правого операнда левый операнд | C -= A, эквивалентно C = C - A |
*= | Оператор присваивания «Умножение», он умножает правый операнд на левый операнд | C * = A эквивалентно C = C * A |
/= | Оператор присваивания «Деление», он делит левый операнд на правый операнд | C /= A эквивалентно C = C / A |
%= | Оператор присваивания «Модуль», он принимает модуль, с помощью двух операндов и присваивает его результат левому операнду | C %= A, эквивалентно C = C % A |
Оператор присваивания «Сдвиг влево» | C | |
>>= | Оператор присваивания «Сдвиг вправо» | C >>= 2, это как C = C >> 2 |
&= | Оператор присваивания побитового «И» («AND») | C &= 2, это как C = C & 2 |
^= | Оператор присваивания побитового исключающего «ИЛИ» («XOR») | C ^= 2, это как C = C ^ 2 |
|= | Оператор присваивания побитового «ИЛИ» («OR») | C |= 2, это как C = C | 2 |
Пример
Следующий простой пример показывает, программно логические операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:
Public class Test { public static void main(String args) { int a = 10; int b = 20; int c = 0; c = a + b; System.out.println("c = a + b = " + c); c += a ; System.out.println("c += a = " + c); c -= a ; System.out.println("c -= a = " + c); c *= a ; System.out.println("c *= a = " + c); a = 10; c = 15; c /= a ; System.out.println("c /= a = " + c); a = 10; c = 15; c %= a ; System.out.println("c %= a = " + c); c >= 2 ; System.out.println("c >>= 2 = " + c); c >>= 2 ; System.out.println("c >>= a = " + c); c &= a ; System.out.println("c &= 2 = " + c); c ^= a ; System.out.println("c ^= a = " + c); c |= a ; System.out.println("c |= a = " + c); } }
Будет получен следующий результат:
C = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c >= 2 = 5 c >>= 2 = 1 c &= a = 0 c ^= a = 10 c |= a = 10
Прочие операторы
Есть несколько других операторов, поддерживаемых языком Java.
Тернарный оператор или условный оператор (?:)
Тернарный оператор - оператор, который состоит из трех операндов и используется для оценки выражений типа boolean. Тернарный оператор в Java также известен как условный оператор. Этот. Цель тернарного оператора или условного оператора заключается в том, чтобы решить, какое значение должно быть присвоено переменной. Оператор записывается в виде:
Переменная x = (выражение) ? значение if true: значение if false
Пример
Ниже приведен пример:
Public class Test { public static void main(String args){ int a , b; a = 10; b = (a == 1) ? 20: 30; System.out.println("Значение b: " + b); b = (a == 10) ? 20: 30; System.out.println("Значение b: " + b); } }
Будет получен следующий результат:
Значение b: 30 Значение b: 20
Оператор instanceof
Оператор instanceof - проверяет, является ли объект определенного типа (типа класса или типа интерфейса) и используется только для переменных ссылочного объекта. Оператор instanceof записывается в виде:
(Переменная ссылочного объекта) instanceof (класс/тип интерфейса)
Примеры
Если переменная ссылочного объекта в левой части оператора проходит проверку для класса/типа интерфейса на правой стороне, результатом будет значение true. Ниже приведен пример и описание оператора instanceof:
Public class Test { public static void main(String args){ String name = "Олег"; // Следующее вернётся верно, поскольку тип String boolean result = name instanceof String; System.out.println(result); } }
Будет получен следующий результат:
Этот оператор по-прежнему будет возвращать значение true, если сравниваемый объект является совместимым с типом на право назначения. Ниже приводится еще один пример:
Class Vehicle {} public class Car extends Vehicle { public static void main(String args){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println(result); } }
Будет получен следующий результат:
Приоритет операторов в Java
Приоритет операторов определяет группирование терминов в выражении. Это влияет как вычисляется выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например оператор умножения имеет более высокий приоритет, чем оператор сложения:
Например, x = 7 + 3 * 2. Здесь x присваивается значение 13, не 20, потому что оператор «*» имеет более высокий приоритет, чем «+», так что сначала перемножается «3 * 2», а затем добавляется «7».
В таблице операторы с наивысшим приоритетом размещаются в верхней части, и уровень приоритета снижается к нижней части таблицы. В выражении высокий приоритет операторов в Java будет оцениваться слева направо.
Категория | Оператор | Ассоциативность |
Постфикс | () . (точка) | Слева направо |
Унарный | ++ - - ! ~ | Справа налево |
Мультипликативный | * / % | Слева направо |
Аддитивный | + - | Слева направо |
Сдвиг | >> >>> | Слева направо |
Реляционный | > >= | Слева направо |
Равенство | == != | Слева направо |
Побитовое «И» («AND») | & | Слева направо |
Побитовое исключающее «ИЛИ» («XOR») | ^ | Слева направо |
Побитовое «ИЛИ» («OR») | | | Слева направо |
Логическое «И» («AND») | && | Слева направо |
Логическое «ИЛИ» («OR») | || | Слева направо |
Условный | ?: | Справа налево |
Присваивание | = += -= *= /= %= >>= | Справа налево |
Запятая | , | Слева направо |
В следующем уроке поговорим об управлении циклом в программировании на Java. В этом уроке будут описаны различные типы циклов, как циклы могут быть использованы в разработке программ, и для каких целей они используются.
Большинство операций над примитивными типами выполняется не с помощью методов, а с помощью специальных символов, называемых знаком операции .
Операция присваивания
Присвоение переменной значения константы, другой переменной или выражения (переменных и/или констант, разделенных знаками операций), называется операцией присваивания и обозначается знаком "= ", например: x = 3 ; y = x; z = x; В Java допустимо многократное использование операции присваивания в одном выражении, например: x1 = x2 = x3 = 0 ; Эта операция выполняется справа налево, т.е. сначала переменной x3 присваивается значение 0 , затем переменной x2 присваивается значение переменной x3 (0), и, наконец, переменной x1 присваивается значение переменной x2 (0). Знаки операций, аргументами которых являются числа, разделяются на две категории: унарные (unary) знаки операций с одним аргументом и бинарные (binary) с двумя аргументами.Унарные операции
В Java определены следующие унарные операции:- унарный минус " - " – меняет знак числа или выражения на противоположный;
- унарный плюс " + " – не выполняет никаких действий над числом или выражением;
- побитовое дополнение " ~ " (только для целых) – инвертирует все биты поля числа (меняет 0 на 1 и 1 на 0);
- инкремент " ++ " (только для целых) – увеличивает значение переменной на 1;
- декремент " -- " (только для целых) – уменьшает значение переменной на 1.
Арифметические бинарные операции
В Java определены следующие арифметические бинарные операции :- сложение " + ";
- вычитание " - ";
- умножение " * ";
- деление " / ";
- вычисление остатка от деления целых чисел " % " (возвращает остаток от деления первого числа на второе, причем результат будет иметь тот же знак, что и делимое), например, результат операции 5%3 будет равен 2 , а результат операции (-7)%(-4) будет равен -3 . В Java операция может использоваться и для вещественных переменных (типа float или double).
Побитовые операции
- Побитовые операции рассматривают исходные числовые значения как поля битов и выполняют над ними следующие действия:
- установка бита в i -ой позиции поля результата в 1 , если оба бита в i -ых позициях операндов равны 1 , или в 0 в противном случае – побитовое И (" & ");
- установка бита в i -ой позиции поля результата в 1 , если хотя бы один бит в i -ых позициях операндов равен 1 , или в 0 в противном случае – побитовое ИЛИ (" | ");
- установка бита в i -ой позиции поля результата в 1 , если биты в i -ых позициях операндов не равны друг другу, или в 0 в противном случае – побитовое исключающее ИЛИ (" ^ ");
- сдвиг влево битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг влево с учетом знака " << ";
- сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом не меняется) – побитовый сдвиг вправо с учетом знака " >> ";
- сдвиг вправо битов поля первого операнда на количество битов, определяемое вторым операндом (бит знака числа при этом также сдвигается) – побитовый сдвиг вправо без учета знака " >>> ".
Побитовое И
int x = 112 ; int y = 94 ; int z; z = x & y; // z=80: 00000000 00000000 00000000 01010000Побитовое ИЛИ
int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 int z; z = x | y; // z = 126: 00000000 00000000 00000000 01111110Побитовое исключающее ИЛИ
int x = 112 ; // x: 00000000 00000000 00000000 01110000 int y = 94 ; // y: 00000000 00000000 00000000 01011110 int z; z = x ^ y; // z = 46: 00000000 00000000 00000000 00101110Сдвиг влево с учетом знака
int x = 31 , z; // x: 00000000 00000000 00000000 00011111 z = x << 2 ; // z = 124: 00000000 00000000 00000000 01111100Сдвиг вправо с учетом знака
int x = - 17 , z; z = x >> 2 ; // z = -5: 11111111 11111111 11111111 11111011Сдвиг вправо без учета знака
int x = - 17 , z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2 ; // z = 1073741819 // z: 00111111 11111111 11111111 11111011
Комбинированные операции
В Java для бинарных арифметических операций можно использовать комбинированные (составные) знаки операций: идентификатор операция = выражение Это эквивалентно следующей операции: идентификатор = идентификатор операция выражение Примеры:- Выражение x += b означает x = x + b .
- Выражение x -= b означает x = x - b .
- Выражение x *= b означает x = x * b .
- Выражение x /= b означает x = x / b .
- Выражение x %= b означает x = x % b .
- Выражение x &= b означает x = x & b .
- Выражение x |= b означает x = x | b .
- Выражение x ^= b означает x = x ^ b .
- Выражение x <<= b означает x = x << b .
- Выражение x >>= b означает x = x >> b .
- Выражение x >>>= b означает x = x >>> b .
Операции сравнения
В Java определены следующие операции сравнения:- " == " (равно), " != " (не равно),
- " > " (больше), " >= " (больше или равно),
- " < " (меньше) " <= " (меньше или равно)
Булевские операции
Булевские операции выполняются над булевскими переменными и их результатом также является значение типа boolean . В Java определены следующие булевские операции:- отрицание "!" – замена false на true , или наоборот;
- операция И "&" – результат равен true , только, если оба операнда равны true , иначе результат – false ;
- операция ИЛИ " | " – результат равен true , только, если хотя бы один из операндов равен true , иначе результат – false .
- операция исключающее ИЛИ " ^ " – результат равен true , только, если операнды не равны друг другу, иначе результат – false .
Условная операция
Условная операция записывается в форме выражение-1?выражение-2:выражение-3 . При этом сначала вычисляется выражение выражение-1 , которое должно дать булевское значение, а затем, если выражение-1 имеет значение true , вычисляется и возвращается выражение-2 как результат выполнения операции, либо (если выражение-1 имеет значение false), вычисляется и, как результат выполнения операции, возвращается выражение-3 . Пример условной операции: x= n> 1 ? 0 : 1 ; Переменной x будет присвоено значение 0 , если n>1 (выражение n>1 имеет значение true) или 1 , если n≤1 (выражение n>1 имеет значение false).Старшинство операций
Операции в выражениях выполняются слева направо, однако, в соответствии со своим приоритетом. Так операции умножения в выражении y = x + z* 5 ; будет выполнена раньше, чем операция сложения, поскольку приоритет операции умножения выше, чем приоритет операции сложения. Приоритеты операций (в порядке уменьшения приоритета) в Java приведены в табл. 1.Круглые скобки повышают старшинство операций, которые находятся внутри них. Так, если в приведенное выше выражение вставить скобки: y = (x + z) * 5 ; то сначала будет выполнена операция сложения, а затем операция умножения. Иногда скобки используют просто для того, чтобы сделать выражение более читаемым, например: (x > 1 ) && (x <= 5 ) ;