RU
EN
ES
ZH
FR
DE
PT
AR
HI
Арифметические операции — Java
Что это и зачем?
Представь, что ты кассир в магазине сладостей. У тебя есть коробка с 10 шоколадками, и пришёл покупатель, который хочет купить 3. Сколько останется? А если завтра привезут ещё 5 коробок по 10 шоколадок — сколько всего будет? Чтобы это посчитать, не обязательно пересчитывать каждую конфету пальцем. Достаточно выполнить арифметические операции — сложение, вычитание, умножение и деление.
В Java эти операции выглядят почти так же, как в математике, только вместо знака умножения «×» мы пишем *, а вместо знака деления «÷» — /. Компьютер — это тот же кассир, только очень быстрый и никогда не ошибающийся (если ты не ошибёшься в команде).
Зачем это нужно в программировании? Представь, что ты пишешь игру, где герой собирает монеты. Каждую секунду нужно прибавлять к его счёту количество собранных монет. Или ты делаешь калькулятор для уроков математики. Или программу, которая считает, сколько дней осталось до Нового года. Везде нужны арифметические операции.
В Java есть 5 основных арифметических операций:
+— сложение (как в математике)-— вычитание*— умножение/— деление (только в Java есть хитрость с целыми числами)%— остаток от деления (это новое! Он показывает, сколько осталось, если поделить нацело)
Давай сразу договоримся: в Java, как и в Python, есть типы данных. Для чисел чаще всего используют int (целые числа, например 5, -3, 100) и double (дробные числа, например 3.14, -0.5). Если ты смешаешь их в одной операции — Java сама разберётся, но иногда это приводит к неожиданным результатам (мы это обсудим в ошибках).
В отличие от Python, где можно просто написать print(2 + 3) и всё заработает, в Java нужно сначала создать класс и метод main. Не пугайся — это просто «контейнер» для твоей программы. Все примеры ниже будут внутри такого контейнера.
Примеры кода с объяснением
Пример 1: Сложение и вычитание (как в жизни)
Представь, что у тебя было 15 рублей, ты нашёл ещё 7, а потом потратил 10 на мороженое. Сколько осталось?
public class Main {
public static void main(String[] args) {
// Объявляем переменные — это как коробочки с наклейками
int bylo = 15; // Было 15 рублей
int nashel = 7; // Нашёл 7 рублей
int potratil = 10; // Потратил 10 рублей
// Считаем: было + нашёл - потратил
int ostalos = bylo + nashel - potratil;
// Выводим результат на экран
// В Java для вывода используем System.out.println()
System.out.println("У тебя осталось: " + ostalos + " рублей");
// На экране появится: У тебя осталось: 12 рублей
}
}Как это работает: Java выполняет действия слева направо, как в математике. Сначала 15 + 7 = 22, потом 22 - 10 = 12. Результат сохраняется в переменную ostalos. Знак + в System.out.println используется для склеивания текста и чисел — это называется конкатенация. В Python для этого используют запятые или f-строки, а в Java — знак плюс.
Пример 2: Умножение (считаем площадь комнаты)
Ты решил узнать, сколько квадратных метров в твоей комнате. Длина — 6 метров, ширина — 4 метра.
public class Main {
public static void main(String[] args) {
int dlina = 6;
int shirina = 4;
// Умножение: площадь = длина * ширина
int ploshad = dlina * shirina;
System.out.println("Площадь комнаты: " + ploshad + " кв. м");
// Вывод: Площадь комнаты: 24 кв. м
// А теперь посчитаем периметр: (длина + ширина) * 2
int perimetr = (dlina + shirina) * 2;
System.out.println("Периметр комнаты: " + perimetr + " м");
// Вывод: Периметр комнаты: 20 м
}
}Обрати внимание на скобки! В Java, как и в математике, сначала выполняются действия в скобках. Если бы мы написали dlina + shirina * 2, то сначала умножилось бы 4 на 2 (получилось 8), а потом прибавилось 6 — итог 14, а не 20. Скобки меняют порядок!
В Python скобки работают точно так же — это общее правило для всех языков программирования.
Пример 3: Деление и остаток (делим пиццу)
У тебя есть 23 кусочка пиццы, и 5 друзей. Сколько кусочков достанется каждому, если делить поровну? Сколько останется тебе?
public class Main {
public static void main(String[] args) {
int kuskov = 23;
int druzei = 5;
// Целочисленное деление: 23 / 5 = 4 (остаток 3)
// Java отбрасывает дробную часть, если оба числа целые!
int kazhdomu = kuskov / druzei;
System.out.println("Каждому другу: " + kazhdomu + " кусочков");
// Вывод: Каждому другу: 4 кусочка
// Остаток от деления: 23 % 5 = 3
int ostatok = kuskov % druzei;
System.out.println("Останется тебе: " + ostatok + " кусочка");
// Вывод: Останется тебе: 3 кусочка
// Проверка: 4 * 5 + 3 = 23 — всё верно!
}
}Важный момент: В Java, если ты делишь целое число на целое, результат тоже будет целым — дробная часть просто отбрасывается (не округляется, а отбрасывается!). 23 / 5 = 4, а не 4.6. Если нужно получить дробный результат, хотя бы одно число должно быть дробным (например, 23.0 / 5 или 23 / 5.0). В Python 3 деление целых чисел даёт дробный результат по умолчанию, а для целочисленного деления используют //. В Java такого оператора нет — нужно явно указывать тип.
Оператор % (остаток от деления) — очень полезная штука. Он часто используется, чтобы проверить, делится ли число на другое без остатка (например, чётное ли число: число % 2 == 0).
Пример 4: Работа с дробными числами (double)
Теперь представим, что ты хочешь поделить пиццу точнее — вдруг кто-то хочет полкусочка? Используем дробные числа.
public class Main {
public static void main(String[] args) {
double kuskov = 23.0; // Обрати внимание на точку!
double druzei = 5.0;
// Теперь деление даст дробный результат
double kazhdomu = kuskov / druzei;
System.out.println("Каждому другу: " + kazhdomu + " кусочка");
// Вывод: Каждому другу: 4.6 кусочка
// Можно смешивать int и double — Java сама приведёт к double
int a = 10;
double b = 3.0;
double resultat = a / b; // 10 / 3.0 = 3.333...
System.out.println("10 / 3 = " + resultat);
// Вывод: 10 / 3 = 3.3333333333333335
}
}Почему в конце 3.3333333333333335, а не просто 3.333? Потому что компьютеры не могут хранить бесконечные дроби точно — это особенность двоичной системы счисления. В Python будет то же самое. Для обычных задач такая точность подходит, но для финансовых расчётов используют специальные типы данных.
Обрати внимание: дробные числа записываются через точку, а не через запятую! 3.14 — правильно, 3,14 — ошибка.
Пример 5: Сложное выражение (средняя оценка)
Ты получил оценки за четверть: 5, 4, 3, 5, 4. Нужно посчитать среднее арифметическое.
public class Main {
public static void main(String[] args) {
int ocenka1 = 5;
int ocenka2 = 4;
int ocenka3 = 3;
int ocenka4 = 5;
int ocenka5 = 4;
// Считаем сумму всех оценок
int summa = ocenka1 + ocenka2 + ocenka3 + ocenka4 + ocenka5;
// summa = 21
// Чтобы получить среднее, делим сумму на количество оценок
// Но если оба числа int, мы потеряем дробную часть!
// Поэтому используем double для деления:
double srednee = (double) summa / 5; // Преобразуем summa в double
System.out.println("Средняя оценка: " + srednee);
// Вывод: Средняя оценка: 4.2
// Если бы мы написали summa / 5, то получили бы 4 (отбросили 0.2)
int nepravilno = summa / 5;
System.out.println("Неправильное среднее: " + nepravilno);
// Вывод: Неправильное среднее: 4
}
}Здесь мы использовали приведение типов — (double) summa говорит Java: «Возьми переменную summa (которая int) и временно считай её дробным числом». Это как если бы ты сказал: «У меня 5 яблок, но для расчёта представим, что это 5.0 яблок». Без этого деление дало бы 4, а не 4.2.
В Python приведение типов тоже есть, но оно происходит автоматически, когда ты делишь целое на целое — ты получаешь дробь. В Java нужно быть внимательным!
Типичные ошибки
Давай разберём ошибки, которые чаще всего делают новички в Java (и не только). Я покажу неправильный код и объясню, почему он не работает.
Ошибка 1: Забыли точку с запятой
public class Main {
public static void main(String[] args) {
int a = 5
int b = 3
System.out.println(a + b)
}
}Ошибка: После каждой команды в Java обязательно ставится точка с запятой ;. Компилятор выдаст ошибку: ';' expected. В Python точки с запятой не нужны, но в Java это обязательно.
Исправление: int a = 5; int b = 3; System.out.println(a + b);
Ошибка 2: Деление целых чисел без учёта дробной части
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 3;
double result = a / b; // Думаешь, что будет 3.333?
System.out.println(result); // На самом деле 3.0!
}
}Почему? Сначала выполняется деление a / b как целых чисел — получается 3. Потом это 3 преобразуется в double (3.0). Результат — 3.0, а не 3.333. В Python такого не случится, но в Java нужно быть внимательным.
Исправление: double result = (double) a / b; или double result = a / 3.0;
Ошибка 3: Деление на ноль
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 0;
int result = a / b; // Ошибка!
System.out.println(result);
}
}Ошибка: На ноль делить нельзя! Java выбросит исключение ArithmeticException и программа остановится. В Python будет то же самое (ZeroDivisionError). Это математическое правило: делить на ноль нельзя ни в одной программе.
Исправление: Всегда проверяй, что делитель не равен нулю: if (b != 0) { ... }
Ошибка 4: Путаница между = и ==
public class Main {
public static void main(String[] args) {
int a = 5;
if (a = 10) { // Ошибка! Должно быть a == 10
System.out.println("a равно 10");
}
}
}Почему? Один знак = — это присваивание (положить значение в переменную). Два знака == — это сравнение (проверить, равны ли значения). В Python то же самое правило. Java выдаст ошибку компиляции, потому что if ожидает логическое выражение, а присваивание возвращает число.
Исправление: if (a == 10)
Ошибка 5: Забыли, что приоритет операций существует
public class Main {
public static void main(String[] args) {
int result = 5 + 3 * 2; // Думаешь, что будет 16?
System.out.println(result); // На самом деле 11!
}
}Почему? В Java умножение и деление выполняются раньше сложения и вычитания (как в математике). Сначала 3 * 2 = 6, потом 5 + 6 = 11. Если хочешь сначала сложить — используй скобки: (5 + 3) * 2 = 16.