Арифметические операции — Java: Основы программирования

На базовом уровне компьютеры оперируют только числами. Даже в прикладных программах на высокоуровневых языках внутри много чисел и операций над ними. К счастью, для старта достаточно знать обычную арифметику — с нее и начнем.

Для сложения двух чисел в математике мы пишем, например, 3 + 4. В программировании — то же самое. Вот программа, складывающая два числа:

class App {
    public static void main(String[] args) {
        3 + 4;
    }
}

Если запустить эту программу на выполнение, то она тихо отработает и завершится. На экран ничего не будет выведено. Операция сложения, как и остальные операции, сама по себе ничего не делает кроме сложения. Чтобы воспользоваться результатом сложения, его нужно, например, вывести на экран.

System.out.println(3 + 4);

// После запуска на экране появится результат:
// => 7

Кроме сложения доступны следующие операции:

• * — умножение
• / — деление
• - — вычитание
• % — остаток от деления

Теперь давайте выведем на экран результат деления, а потом результат возведения в степень:

System.out.println(8 / 2); // => 4
System.out.println(3 * 3 * 3); // => 27

Операторы

Перед тем, как двигаться дальше, разберем базовую терминологию. Знак операции, такой как +, называют оператором. Оператор — просто символ, который выполняет операцию, например сложение.

System.out.println(8 + 2); // => 10

В этом примере + это оператор, а числа 8 и 2 — это операнды.

В случае сложения у нас есть два операнда: один слева, другой справа от знака +. Операции, которые требуют наличия двух операндов, называются бинарными. Если пропустить хотя бы один операнд, например, так 3 + ;, то программа завершится с синтаксической ошибкой.

Операции (не операторы) бывают не только бинарными, но и унарными (с одним операндом), и даже тернарными (с тремя операндами)! Причем операторы могут выглядеть одинаково, но обозначать разные операции.

System.out.println(-3); // => -3

Выше пример применения унарной операции к числу 3. Оператор минус перед тройкой говорит интерпретатору взять число 3 и найти противоположное, то есть -3. Это немного может сбить с толку, потому что -3 — это одновременно и число само по себе, и оператор с операндом, но у языков программирования такая структура.

Коммутативная операция

Мы все помним со школы: «от перемены мест слагаемых сумма не меняется». Это один из базовых и интуитивно понятных законов арифметики, он называется коммутативным законом.

Бинарная операция считается коммутативной, если, поменяв местами операнды, вы получаете тот же самый результат. Очевидно, что сложение — коммутативная операция: 3 + 2 = 2 + 3. А вот является ли коммутативной операция вычитания? Нет: 2 - 3 ≠ 3 - 2. В программировании этот закон работает точно так же, как в арифметике. Более того, большинство операций, с которыми мы будем сталкиваться в реальной жизни, не являются коммутативными. Отсюда вывод: всегда обращайте внимание на порядок того, с чем работаете.

Композиция операций

А что, если понадобится вычислить такое выражение: 3 + 5 - 2? Именно так мы и запишем:

System.out.println(3 + 5 - 2); // 3 + 5 - 2 => 8 - 2 => 6

Обратите внимание, что компьютер производит арифметические вычисления в правильном порядке: сначала деление и умножение, потом сложение и вычитание. Иногда этот порядок нужно изменить — об этом немного далее.

Или другой пример:

System.out.println(2 * 4 * 5 * 10); // 2 * 4 * 5 * 10 => 8 * 5 * 10 => 40 * 10 => 400

Как видно, операции можно соединять друг с другом, получая возможность вычислять все более сложные составные выражения. Чтобы представить себе то, как происходят вычисления внутри интерпретатора, давайте разберем пример: 2 * 4 * 5 * 10.

1. Сначала вычисляется 2 * 4 и получается выражение 8 * 5 * 10.
2. Затем 8 * 5. В итоге имеем 40 * 10.
3. В конце концов происходит последнее умножение, и получается результат 400.

Операции можно соединять друг с другом, получая возможность вычислять все более сложные составные выражения.

Приоритет операций

Посмотрите внимательно на выражение 2 + 2 * 2 и посчитайте в уме ответ. Правильный ответ: 6.

Если у вас получилось 8, то этот урок для вас. В школьной математике мы изучали понятие «приоритет операции». Приоритет определяет то, в какой последовательности должны выполняться операции. Например, умножение и деление имеют больший приоритет, чем сложение и вычитание: 2 + 3 * 2 вычислится в 8. Но нередко вычисления должны происходить в порядке, отличном от стандартного приоритета. В сложных ситуациях приоритет можно (и нужно) задавать круглыми скобками, точно так же, как в школе, например: (2 + 2) * 2. Скобки можно ставить вокруг любой операции. Они могут вкладываться друг в друга сколько угодно раз. Вот пара примеров:

System.out.println(3 * (4 - 2)); // => 6
System.out.println(7 * 3 + (4 / 2) - (8 + (2 - 1))); // => 14

Иногда выражение сложно воспринимать визуально. Тогда можно сделать его понятнее, расставив скобки, хотя они и не повлияют на приоритет.

Было:

System.out.println(8 / 2 + 5 - -4 / 2); // => 11

Стало:

System.out.println(((8 / 2) + 5) - (-4 / 2)); // => 11

Запомните: код пишется для людей, потому что код будут читать люди, а машины будут только исполнять его. Для машин нет «более» понятного или «менее» понятного кода, независимо от того, является ли код корректным или нет.

Числа с плавающей точкой

В математике существуют разные виды чисел, например, натуральные - это целые числа от одного и больше, или рациональные - это числа с точкой, например 0.5. С точки зрения устройства компьютеров, между этими видами чисел пропасть. Попробуйте ответить на простой вопрос, сколько будет 0.2 + 0.1? А теперь посмотрим, что на это скажет Java:

0.2 + 0.1; // 0.30000000000000004

Операция сложения двух рациональных чисел внезапно привела к неточному вычислению результата. Тот же самый результат выдадут и другие языки программирования. Такое поведение обуславливается ограничениями вычислительных мощностей. Объем памяти, в отличие от чисел, конечен (бесконечное количество чисел требует бесконечного количества памяти для своего хранения). И если с натуральными числами эта проблема решается простым ограничением по верхней границе (есть некоторое максимальное число, которое можно ввести), то с рациональными такой финт не пройдет.

System.out.println(Integer.MAX_VALUE);
// => 2147483647

Рациональные числа не выстроены в непрерывную цепочку, между 0.1 и 0.2 бесконечное множество чисел. Соответственно возникает серьезная проблема, а как хранить рациональные числа? Это интересный вопрос сам по себе. В интернете множество статей, посвященных организации памяти в таких случаях. Более того, существует стандарт, в котором описано, как это делать правильно, и подавляющее число языков на него опирается.

Для нас, как для разработчиков, важно понимать, что операции с плавающими числами неточны (эту точность можно регулировать), а значит при решении задач, связанных с подобными числами, необходимо прибегать к специальным трюкам, которые позволяют добиться необходимой точности.

https://replit.com/@hexlet/java-basics-arithmetics

Дополнительные материалы

1. Что нужно знать про арифметику с плавающей запятой

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.