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

Сложение, вычитание, умножение, деление — математика лежит в основе любой программы. В этом уроке мы разберём все арифметические операторы Java, узнаем про деление целых чисел и остаток от деления, а также поймём, почему 7 / 2 не равно 3.5.

➕ Базовые арифметические операции

Java поддерживает пять базовых арифметических операторов:

public class BasicMath {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println(a + b);   // 13
        System.out.println(a - b);   // 7
        System.out.println(a * b);   // 30
        System.out.println(a / b);   // 3 (не 3.333!)
        System.out.println(a % b);   // 1 (остаток)
    }
}

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

✂️ Деление целых чисел: ловушка новичков

Это одна из самых частых ошибок. Давайте разберём:

public class DivisionTrap {
    public static void main(String[] args) {
        // Оба operands — int, результат — int
        System.out.println(7 / 2);       // 3 (не 3.5!)
        System.out.println(10 / 3);      // 3 (не 3.333!)
        System.out.println(1 / 3);       // 0 (не 0.333!)
        System.out.println(-7 / 2);      // -3 (отбрасывается в сторону нуля)

        // Один из operands — double, результат — double
        System.out.println(7.0 / 2);     // 3.5
        System.out.println(7 / 2.0);     // 3.5
        System.out.println((double) 7 / 2); // 3.5 — явное приведение
    }
}

Правило простое: если оба operands — целые, результат целый. Чтобы получить дробный результат, хотя бы один из operands должен быть дробным.

Три способа получить точный результат:

// Способ 1: Сделать одно число дробным
double result1 = 7.0 / 2;  // 3.5

// Способ 2: Сделать одно число дробным (другой операнд)
double result2 = 7 / 2.0;  // 3.5

// Способ 3: Явное приведение типа (cast)
double result3 = (double) 7 / 2;  // 3.5

// НЕ работает:
double result4 = (double) (7 / 2);  // 3.0 — деление уже произошло!

🔄 Остаток от деления (модуль)

Оператор % возвращает остаток от целочисленного деления. Это не «проценты», как в калькуляторе!

public class Modulo {
    public static void main(String[] args) {
        System.out.println(10 % 3);   // 1  (10 = 3*3 + 1)
        System.out.println(15 % 4);   // 3  (15 = 4*3 + 3)
        System.out.println(10 % 5);   // 0  (делится нацело)
        System.out.println(7 % 10);   // 7  (7 < 10, остаток = 7)

        // Отрицательные числа
        System.out.println(-10 % 3);  // -1 (знак берётся из левого операнда)
        System.out.println(10 % -3);  // 1
    }
}

Зачем нужен остаток от деления? Вот типичные применения:

• Проверка чётности: n % 2 == 0 — чётное, n % 2 != 0 — нечётное
• Циклические операции: день недели (номер % 7), часы (номер % 12)
• Проверка делимости: n % 5 == 0 — делится на 5
• Цифры числа: n % 10 — последняя цифра, n / 10 — всё кроме последней

// Практический пример: определение чётности
int number = 42;
if (number % 2 == 0) {
    System.out.println(number + " — чётное");
} else {
    System.out.println(number + " — нечётное");
}

// Извлечение цифр числа
int n = 12345;
int digit5 = n % 10;        // 5 — последняя цифра
int remaining = n / 10;     // 1234 — без последней цифры
int digit4 = remaining % 10; // 4 — предпоследняя

⬆️ Инкремент и декремент

Прибавить 1 или вычесть 1 — настолько частая операция, что для неё есть специальные операторы:

int x = 5;
x++;      // x теперь 6 (инкремент: +1)
x--;      // x теперь 5 (декремент: -1)

// То же самое:
x = x + 1;
x = x - 1;

Но есть важный нюанс: префиксная и постфиксная формы работают по-разному в выражениях:

public class IncrementDemo {
    public static void main(String[] args) {
        int a = 5;

        // Постфиксная форма: сначала использует значение, потом увеличивает
        int b = a++;  // b = 5, a = 6
        System.out.println("a = " + a + ", b = " + b);  // a = 6, b = 5

        // Префиксная форма: сначала увеличивает, потом использует значение
        int c = ++a;  // a = 7, c = 7
        System.out.println("a = " + a + ", c = " + c);  // a = 7, c = 7
    }
}

Аналогия: представьте очередь. a++ — вы берёте человека из очереди (он идёт к вам), а потом очередь сдвигается. ++a — очередь сначала сдвигается, потом вы берёте человека.

На практике большинство программистов используют i++ в циклах, а разницу между префиксной и постфиксной формой запоминают как теорию. Вне контекста выражения (x++; или ++x;) разницы нет.

📝 Составные операторы: +=, -=, *=, /=

Вместо x = x + 5 можно написать x += 5. Это короче и чище:

public class CompoundOperators {
    public static void main(String[] args) {
        int x = 10;

        x += 5;    // x = x + 5  →  x = 15
        x -= 3;    // x = x - 3  →  x = 12
        x *= 2;    // x = x * 2  →  x = 24
        x /= 4;    // x = x / 4  →  x = 6
        x %= 4;    // x = x % 4  →  x = 2

        System.out.println(x);  // 2
    }
}

Составные операторы особенно удобны в циклах:

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;  // sum = sum + i
}
System.out.println("Сумма от 1 до 100: " + sum);  // 5050

🔢 Порядок операций (приоритет)

Когда в выражении несколько операций, Java выполняет их в определённом порядке:

1. Скобки () — выполняются первыми
2. Унарные ++, --, !
3. Умножение *, деление /, остаток %
4. Сложение +, вычитание -
5. Присваивание =, +=, -=

public class Precedence {
    public static void main(String[] args) {
        // * раньше +
        System.out.println(2 + 3 * 4);   // 14 (не 20!)
        System.out.println((2 + 3) * 4); // 20

        // Слева направо для одного приоритета
        System.out.println(10 - 3 - 2);  // 5 (не 9)
        System.out.println(10 / 2 * 3);  // 15 (не 1.667)

        // + и конкатенация (смешанные типы)
        System.out.println(2 + 3 + "abc"); // 5abc (сложение, потом конкатенация)
        System.out.println("abc" + 2 + 3); // abc23 (конкатенация идёт слева направо)
    }
}

Последний пример — классическая ловушка! Когда + встречает строку, он переключается из арифметического режима в режим конкатенации.

🛠️ Практический пример: разложение числа на цифры

public class DigitExtractor {
    public static void main(String[] args) {
        int number = 12345;

        int digit5 = number % 10;         // 5 — последняя цифра
        number = number / 10;             // 1234
        int digit4 = number % 10;         // 4
        number = number / 10;             // 123
        int digit3 = number % 10;         // 3
        number = number / 10;             // 12
        int digit2 = number % 10;         // 2
        number = number / 10;             // 1
        int digit1 = number % 10;         // 1

        System.out.println("Цифры числа 12345:");
        System.out.println(digit1 + " " + digit2 + " " + digit3 + " " + digit4 + " " + digit5);
        // 1 2 3 4 5

        // Проверка: сумма цифр
        int sum = digit1 + digit2 + digit3 + digit4 + digit5;
        System.out.println("Сумма цифр: " + sum);  // 15
    }
}

✅ Итоги урока

Далее: Преобразование типов — расширение, сужение, cast и автоматическое продвижение →