В предыдущем контенте я научился определять и инициализировать переменные. Цель определения переменных - манипулировать данными. Язык Java предоставляет нам символы кода, специально используемые для работы этих данных, которые вместе называются «операторы».
Согласно использованию операторов, мы можем разделить их на следующие категории:
Арифметические операторы
Оператор назначения
Самообслуживание и операторы самообезации
Логические операторы
Реляционные операторы
бит оператор
Не волнуйтесь, это просто символы, которые помогают нам обработать данные операции. Следующие используют примеры кода, чтобы проиллюстрировать использование этих операторов один за другим.
1. Арифметические операторы
Арифметические операторы являются арифметическими операциями для добавления, вычитания, умножения, деления и получения оставшихся численных переменных:
Добавить: +
уменьшать:-
брать:*
удалять:/
Принять баланс: %
Открытый класс операторы {public static void main (string [] args) {int num1 = 100; int num2 = 20; // Добавить System.out.println ("num1 + num2:" + (num1 + num2)); // вычитать System.out.println ("num1 - num2:" + (num1 - num2)); // Умножение System.out.println ("num1 * num2:" + (num1 * num2)); // Discount System.out.println ("num1 / num2:" + (num1 / num2)); // Получить оставшуюся System.out.println ("num1 % num2:" + (num1 % num2)); }}Результат вывода:
num1 + num2: 120num1 - num2: 80num1 * num2: 2000num1 / num2: 5num1 % num2: 0
2. Оператор назначения
Как и большинство языков программирования, Java использует оператора '=' для выполнения операций назначения. Эта операция присваивает результат расчета справа (называемый RValue) переменной слева. Операторы назначения в Java включают:
= (num2 = num1)
+= (num2 += num1 эквивалентный num2 = num2 +num1)
-= (num2 -= num1 эквивалентный num2 = num2 -num1)
*= (num2 *= num1 эквивалентный num2 = num2 *num1)
/= (num2 /= num1 эквивалентный num2 = num2 /num1)
%= (num2 %= num1 эквивалентный num2 = num2 %num1)
Открытый класс операторы {public static void main (string [] args) {int num1 = 10; int num2 = 20; num2 = num1; System.out.println ("= output:"+num2); num2 += num1; System.out.println ("+= output:"+num2); num2 -= num1; System.out.println ("-= output:"+num2); num2 *= num1; System.out.println ("*= output:"+num2); num2 /= num1; System.out.println ("/= output:"+num2); num2 %= num1; System.out.println ("%= output:"+num2); }}Результаты вывод:
= Вывод: 10+= Выход: 20- = Выход: 10*= Вывод: 100/= Вывод: 10%= Выход: 0
3.
Операторы самообъекта и самообъекта работают только на одной переменной, а значение переменной изменяется.
num ++ (эквивалентный num = num+ 1) увеличивается само по себе, главным образом для численных переменных, добавляя 1 к значению своей собственной переменной.
num -(эквивалентный num = num -1) самоседатель, в основном нацеливая числовые переменные, вычитая значение переменной тела на 1.
Открытый класс операторы {public static void main (string [] args) {int num1 = 100; int num2 = 200; num1 ++; num2--; System.out.println ("num1 ++ is:"+num1); System.out.println ("num2-- есть:"+num2); }}Результаты вывод:
num1 ++ IS: 101Num2-- IS: 199
4. Логические операторы
Логические операторы, как следует из названия, используются для логических суждений. Результатом операции является значение логического типа, то есть истинного или ложного. Логическая униформа операторов
| Логические операторы | Логические отношения |
|---|---|
| && | и |
| ` | |
| ! | Нет |
B1 && B2: если B1 и B2 верны, B1 && B2 вернет true, в противном случае неверно
b1 || B2: Если B1 и B2 являются ложными, FALSE будет возвращено, в противном случае верно будет возвращено.
! B1: вернет значение, противоположное B1, если B1 является ложным, вернуть true; Если B1 правда, верните ложь
Общедоступные операторы класса {public static void main (string [] args) {boolean b1 = true; логический B2 = false; System.out.println ("b1 && b2:" + (b1 && b2)); System.out.println ("b1 || b2:" + (b1 || b2)); System.out.println ("! (B1 && B2):" +! (B1 && B2)); }}Результат вывода:
b1 && b2: falseb1 || b2: true! (b1 && b2): true
Логический короткий замыкание:
В Java логические операторы поддерживают операции короткого замыкания, и как только значение всего выражения может быть четко выражено, нам не нужно рассчитать остальную часть выражения. Например, мы должны судить, что объект не является пустым и что возвращаемое значение его метода не является пустым, поэтому мы можем принять решение подобным образом:
if (object! = null && object.somefunction ()! = null) {// что -нибудь.}Если объект пуст, объект экспрессии первой части! = NULL вернет false, тогда независимо от результата Expression Object.someFunction ()! = NULL после оператора &&, конечное значение является ложным. Компилятор автоматически оптимизирует эту часть операции и не выполнит object.somefunction ()! = NULL.
5. Реляционные операторы
Используется для сравнения размера двух переменных данных, вернуть значение логического, то есть истинного или ложного
Реляционные операторы включают в себя:
| Реляционные операторы | связь |
|---|---|
| > | Больше |
| < | Меньше, чем |
| == | равный |
| ! = | Не равен |
| > = | Больше или равен |
| <= | Меньше или равен |
'==' и '! =' подходят для всех типов значений и объектов (т.е. переменные примитивного типа и переменные ссылочного типа).
'>', '<', '> =' и '<=' не применяются к значениям логических типов, потому что они имеют только истинную или ложную, и больше, чем не имеют практического значения.
Открытый класс операторы {public static void main (string [] args) {int num1 = 10; int num2 = 50; if (num1 == num2) {System.out.println ("num1 и num2 равны"); } else {System.out.println ("num1 и num2 не равны"); } if (num1! = num2) {System.out.println ("num1 и num2 не равны"); } else {System.out.println ("num1 и num2 не равны"); } else {System.out.println ("num1 и num2 не равны"); } recal ");} if (num1> num2) {System.out.println (" num1 больше, чем num2 ");} else {system.out.println (" num1 не больше num2 ");} if (num1> = num2) {system.out.println (" num1 больше, чем или равна num2 "); меньше num2 ");} if (num1 <num2) {system.out.println (" num1 меньше num2 ");} if (num1 <num2) {System.out.println (" num1 меньше, чем num2 ");} else {system.out.println (" num1 не меньше, чем num2 "); System.out.println ("num1 меньше или равна num2");Результат вывода:
num1 и num2 не равны1, а num2 не равны, не больше, чем num2num1 меньше, чем num2num1 меньше, чем num2num1 меньше или равна num2
6. Бит -оператор
Объектом операции, нацеленным на оператор битов, является бинарные «биты», который можно применить к целочисленным типам (int), длинным, коротким, типам символа (Char) и типу байта (байт) и другими типами. Во время работы соответствующий бит бита (0 или 1) будет выполняться в булевой алгебраической работе или операциях перемещения.
| бит оператор | Вычислительная логика |
|---|---|
| И | И операция: для определенного бита, если оба операнда составляют 1, результат бита - 1, в противном случае это 0. |
| ` | ` |
| ^ | Операция XOR: для определенного бита, если два операнда не совпадают, результат бита - 1, в противном случае это 0. |
| ~ | Неоперация: оператор по биче |
| << | Двоичный оператор левого сдвига: левый операнд переводится на левый бит-левой |
| >> | Двоичный оператор правой смены: левый операнд находится в правом направлении правого операнда. |
| >>> | Двоичный оператор с нулевым комплектом в правой сдвиге: значение левого операнда сдвигается вправо в соответствии с количеством битов, указанных правым операндом, и полученный пустой бит заполнен нулю |
Описание вычислительной логики несколько неясно, и мы можем использовать примеры, чтобы более четко понять, как операторы битов выполняют расчеты. Предположим, что если x равен 60; Y равен 13; их бинарные представления и результаты операций битов следующие:
x = 0011 1100y = 0000 1101------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Обратите внимание на разницу между >> и >>>:
Оператор правого сдвига >>, если значение операции положительно, 0 вставлено в высокое положение; Если значение отрицательное, 1 вставлено в высокое положение;
Двигайтесь вправо, чтобы заполнить ноль оператора >>>, вставьте 0 в высокую позицию независимо от положительного или отрицательного.
> Если вы не понимаете операцию бита, сначала пропустите ее. Когда он на самом деле используется, вы можете изучить его снова.
7. Приоритет оператора
Приоритет оператора определяет группировку терминов в выражении. Это влияет на то, как оценивается выражение. Определенный оператор имеет более высокий приоритет, чем другие операторы.
Например: оператор умножения имеет более высокий приоритет, чем оператор добавления, и выражение 1 + 5 * 6. Согласно приоритету оператора, компилятор сначала рассчитывает 5 * 6, затем вычислит 30 + 1 и, наконец, получит результат 31.
Приоритет различных операторов - от больших до маленьких:
., (), [] Monocular +(справа налево комбинированное), монокулярный - (справа налево комбинирован), ++, -, ~,!*, /,% +(Слева направо вместе комбинированных), - (слева направо) >>, <<, >> <, <=,>,> ==,!
Не беспокойтесь о таком сложном списке приоритетов. В большинстве случаев само выражение легко увидеть приоритет. Например, операция назначения должна иметь самый низкий приоритет. В тех случаях, когда приоритет не ясен, мы можем изменить приоритет так, как мы хотим, чтобы его не нужно помнить о приоритете оператора.
8. Другие операторы
Трехсторонний оператор:
Условный оператор в Java является тройным оператором, и его форма заключается в следующем:
Booleanexpression? Значение
Если логическое значение выражения является истинным, значением выражения является значение значения, в противном случае значение значения, в котором.
Например, если мы хотим рассчитать абсолютное значение x, мы можем реализовать его через следующий код:
if (x> = 0) {y = x;} else {y = -x;}Через тройного оператора вам нужен только один оператор y = x> = 0? x: -x; Чтобы завершить его, что более кратко.
Оператор конверсии типа:
Мы используем преобразование типа во многих случаях. В соответствующее время Java автоматически преобразует тип данных в другой в соответствии с типом данных. Например, если мы назначаем целочисленное значение переменной Float, компилятор преобразует int в Float и назначит его переменной.
Однако во многих случаях Java не может определить, нужно ли нам выполнить конверсию типа. В настоящее время нам нужны операторы конверсии типа, которые позволяют нам явно выполнять преобразование типа, например:
int a = 10; long b = (длинный) a; long c = (long) 100;
Мы можем ввести конвертировать как переменные, так и константы.
При выполнении типа преобразования чисел с плавающей точкой мы должны обратить внимание на проблему усечения. Если мы хотим введите преобразование 10.9: (int) 10.9, его значение не округлено 11, а 10