На базовом уровне компьютеры оперируют только числами. Даже в прикладных программах на высокоуровневых языках внутри много чисел и операций над ними. К счастью, для старта достаточно знать обычную арифметику — с нее и начнем.
Для сложения двух чисел в математике мы пишем, например, 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
.
Операции можно соединять друг с другом, получая возможность вычислять все более сложные составные выражения.
Посмотрите внимательно на выражение 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
Вам ответят команда поддержки Хекслета или другие студенты.
Выделите текст, нажмите ctrl + enter и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.
Загляните в раздел «Обсуждение»:
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно.
Наши выпускники работают в компаниях:
С нуля до разработчика. Возвращаем деньги, если не удалось найти работу.
Зарегистрируйтесь или войдите в свой аккаунт