Арифметические операции
Начнем со сложения и допустим необходимо вычислить сумму двух переменных:
то есть складывать можно как переменные, так и числа или их комбинации:
Вычитание выполняется аналогично, например:
float a = 5.8f, b = 7.6f; double c = a-b; int d = (int )(a-b); System.out.println(c); System.out.println(d);
В последнем случае мы сначала вычитаем две вещественные переменные, получаем математический результат -1.8, затем, это число приводится к целочисленному (отбрасывается дробная часть) и -1 уже присваивается целочисленной переменной d.
Но смотрите что получается при выводе переменной c в консоль. Она не равна в точности -1.8. Там лишь приближенное значение. Да, в Java вещественные числа считаются приближенно, а не точно (впрочем, как и в большинстве языков программирования). И это следует иметь в виду.
При умножении все делается аналогично. Допустим, мы хотим умножить переменную a на 3. Это делается, например, так:
в результате переменная b будет примерно равна 25.8. А если сделать так:
то целочисленная переменная c будет равна 25.
Теперь давайте напишем простую программу вычисления периметра прямоугольника со сторонами a и b. Формула периметра имеет вид:
Зададим две вещественные переменные a и b:
позволим пользователю ввести их значения:
Scanner in = new Scanner(System.in); System.out.print("a = "); a = in.nextDouble(); System.out.print("b = "); b = in.nextDouble();
и выведем результат на экран:
Запустим и посмотрим как это работает. Обратите внимание, здесь мы при вычислении периметра использовали круглые скобки, которые говорят о том, что сначала должно выполняется сложение, а только потом – умножение. То есть, круглые скобки меняют приоритет арифметических операций и все, что в них записано вычисляется в первую очередь так, как и принято в математике.
Теперь операция деления. Например, можно записать:
Здесь вещественная переменная c будет равна 3.5. Однако, эта операция имеет один важный нюанс. Смотрите, если переписать программу во так:
то переменная c будет равна уже не 3.5, а 3. Почему так получилось? Дело в том, что здесь в делении участвуют две целочисленные переменные, поэтому когда выполняется их деление, то результат 7/2=3,5 сначала временно сохраняется в целочисленной ячейке памяти, то есть, туда помещается значение 3 и только потом это значение присваивается вещественной переменной c. Вот так это все работает. Но если хотя бы одна из двух переменных a или b будет вещественной, то результат деления сохраняется уже в вещественной ячейке памяти, и затем, присваивается переменной c. Поэтому в первом случае было 3,5, а во втором 3. Запомните этот момент! Здесь многие начинающие программисты совершают ошибку.
Как же разделить две целочисленные переменные, чтобы получить верный математический результат 3,5? Для этого достаточно одну из них привести к вещественному типу, например, так:
в обоих случаях результат будет 3,5. Если же выполняется деление конкретных чисел, то можно записать их следующим образом:
float d = 7/2; // результат 3 float d2 = 7.0f/2; //результат 3,5
Здесь во втором случае число 7.0 воспринимается как вещественное, поэтому и результат 3,5. Вот так работает деление в Java.
Следующая арифметическая операция вычисления остатка от деления двух целочисленных величин записывается так:
В результате переменная ost будет равна 1, так как 3 входит в 10 ровно 3 раза и остается еще 1. Это и есть остаток от деления. Данная операция выполняется только с целочисленными переменными или целыми числами, то есть, вещественные значения записывать сюда нельзя.
Последние две операции, которые очень часто используются в Java – это операции ++ и —. Первая операция (операция инкремента) увеличивает значение переменной на 1, например, так:
Результат эквивалентен записи вида:
Но первый вариант проще в записи и быстрее выполняется, так как компилятор его преобразует в более «быстрый» байт-код.
Вторая операция декремента, наоборот, уменьшает значение переменной на 1:
В результате arg будет равен 4. Обратите внимание, что обе эти операции можно записать и в таком виде:
В данном случае результаты их работы будут идентичны. Но различия здесь все же есть. Продемонстрируем их на таком примере.
int a, b, c = 10, d = 10; a = c++; b = ++d; System.out.println("a = "+a+", b = "+b+", c = "+c+", d = "+d);
В результате a=10, b=11, и c=d=11. Почему здесь a=10? Смотрите, когда используется постпрефиксная запись оператора инкремента, то сначала выполняется операция присваивания и только потом увеличение c на 1. В префиксной же записи, сначала d увеличивается на 1, а потом полученное значение присваивается переменной b. Отсюда и различия в значениях переменных a и b.
Также обратите внимание, что приоритет у операций ++ и — выше, чем у операций умножения и деления, то есть, инкремент и декремент выполняются раньше * и /.
В заключение занятия посмотрите еще на вот такие операции:
a += 5; // увеличение a на 5 b -= 3; // уменьшение b на 3 c *= 2; // увеличение c в 2 раза d /= 4; // уменьшение d в 4 раза
Разумеется, числа здесь можно ставить самые разные или же использовать переменные.
Вот так реализуются арифметические операции в Java. По итогам этого занятия вы должны знать как работает оператор присваивания и как выполняются арифметические операции.
Видео по теме
#1 Установка пакетов и первый запуск программы
#2 Структура программы, переменные, константы, оператор присваивания
#3 Консольный ввод/вывод, импорт пакетов
#4 Арифметические операции
#5 Условные операторы if и switch
#6 Операторы циклов while, for, do while
#7 Массивы, обработка элементов массива
#8 (часть 1) Строки в Java, методы класса String
#8 (часть 2) Строки — классы StringBuffer и StringBuider
#9 Битовые операции И, ИЛИ, НЕ, XOR
#10 Методы, их перегрузка и рекурсия
© 2023 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Java операция арифметические операции
Большинство операций в 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
int a = 8; int b = a++; System.out.println(a); // 9 System.out.println(b); // 8
int a = 8; int b = --a; System.out.println(a); // 7 System.out.println(b); // 7
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
Несмотря на то, что операция сложения имеет меньший приоритет, но вначале будет выполняться именно сложение, а не умножение, так как операция сложения заключена в скобки.
Ассоциативность операций
Кроме приоритета операции отличаются таким понятием как ассоциативность . Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:
- Левоассоциативные операторы, которые выполняются слева направо
- Правоассоциативные операторы, которые выполняются справа налево
Так, некоторые операции, например, операции умножения и деления, имеют один и тот же приоритет. Какой же тогда будет результат в выражении:
Стоит нам трактовать это выражение как (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, который позволяет обойти подобные ситуации.