Java операция арифметические операции

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

Начнем со сложения и допустим необходимо вычислить сумму двух переменных:

то есть складывать можно как переменные, так и числа или их комбинации:

Вычитание выполняется аналогично, например:

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, который позволяет обойти подобные ситуации.

Источник

Читайте также:  Python sorted by alphabet
Оцените статью