Урок 2: Арифметические операции в языке Kotlin

Здравствуйте. Классические операции, такие как сложение, вычитание, умножение, деление – в языке программирования Kotlin работают по тем же законам, что и в математике, и используются точно такие же операторы. Сейчас мы научимся с ними работать, а также я покажу еще несколько полезных конструкций языка, чтобы изящно решать рутинные бизнес задачи.

Перед тем, как начнем практиковаться, произведем небольшой рефакторинг и наведем в проекте порядок. Чтобы материалы не путались, я буду создавать отдельный файл под каждый урок, чего и вам также настоятельно рекомендую делать.

Сначала переименую файл первого урока. Жму на него ПКМ → Refactor → Rename. Пусть название будет, например, lesson_1. Для заданий в рамках практикума вы будете добавлять в название файла еще и номер задачи, но сейчас это не требуется.

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

Чтобы создать новый файл, жмем на папку kotlin ПКМ → New → Kotlin Class/File. Назовем его, соответственно, lesson_2. Пишем новую точку входа в приложение с помощью стандартной функции main(), чтобы код внутри фигурных скобок стал исполняемым. Отлично, мы готовы к работе.

Инициализация числом и выражением

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

val a = 5
val b = 7
println(a + b)

Вызовем метод println() и отправим в него выражение, например, сумму этих чисел и распечатаем. Также результат можно записать в отдельную переменную, назовем ее sum, и распечатаем результат.

val a = 5
val b = 7
val sum = a + b
println(sum)

В обоих случаях в консоли отобразится результат сложения двух чисел. Можете поэкспериментировать с более сложными выражениями – разными знаками и дополнительными скобками.

Смотрите, проинициализировать переменную можно как обычным числом, так и неким выражением сразу. В последнем случае результат сначала будет посчитан, а затем присвоен переменной sum.

Еще несколько нюансов, которые стоит записать в свой конспект про объявление и инициализацию переменных любого типа. Нельзя просто так взять и объявить переменную с одним только названием, не проинициализировав ее или не указав тип.

Например, val c. Среда разработки подсветит ошибку, а программа упадет на этапе компиляции. Это произойдет, потому что компилятору непонятно, какого типа будет переменная.

• при объявлении переменной сразу проинициализировать ее, тогда тип присвоится автоматически;
• при объявлении переменной принудительно указывать ее тип, например, val c: Int.

Деление дробных и целых чисел

Окей. Естественно, в метод println() можно отправлять данные не только через переменные, а напрямую любые нетипизированные выражения. Например, разделим два числа:

println(10 / 3)

И получим ответ 3. Почему так, если точно известно, что результатом будет дробное число? Дело в типизации. Мы передали в функцию println() целые числа, поэтому результат вычисления тоже будет целым, с отбрасыванием дробной части.

val intNum1: Int = 10
val intNum2: Int = 3
println(intNum1 / intNum2) // 3

val floatNum1: Float = 10f
val floatNum2: Float = 3f
println(floatNum1 / floatNum2) // 3.3333333

val doubleNum1: Double = 10.0
val doubleNum2: Double = 3.0
println(doubleNum1 / doubleNum2) // 3.3333333333333335

Итак, при делении целых чисел получаем целое число.

Для инициализации дробного числа типа Float добавляем f в конце значения.

Для инициализации дробного числа типа Double делаем его дробным, добавив точку.

Теперь распечатываем значения в консоль. Разница очевидна. Напомню, double и float отличаются только максимально возможным объемом хранимого числа. Обратите внимание на различия в выводе. Итог: чтобы получить дробное число, нужно позаботиться об его явной типизации при объявлении.

Комбинация различных операций

Хорошо. Часто при разработке приходится использовать комбинации из нескольких арифметических операций. Рассмотрим пример:

val complexExpression = (a + b) * 2 - 4 / 2
println(complexExpression)

В этом примере выполняются несколько операций с разными приоритетами: сложение, умножение, деление и вычитание. Важно помнить, что порядок выполнения операций такой же, как в математике: сначала выполняются умножение и деление, затем сложение и вычитание. Скобки позволяют изменить приоритет и влияют на порядок вычислений.

Остаток от деления

В Kotlin есть оператор, который позволяет получить остаток от деления на число. Например, остаток от деления 10 на 3 будет 1. Чтобы получить это значение в коде, используется знак %.

println(10 % 3)

Самый популярный метод применения этого оператора – это определение четности или нечетности числа. Если остаток от деления на 2 – ноль, значит число четное.

Как формируется конечный тип переменной

Что если в выражении встретились два разных типа? Например, Int и Double. Какой тип сохранится в результате? Рассмотрим на примере.

val c = intNum1 + floatNum1
println(c::class.simpleName) // float

val d = intNum1 + floatNum1 + doubleNum1
println(d::class.simpleName) // double

Первое. Если в выражении присутствуют одновременно целочисленный и дробный типы, результат вычислений будет всегда дробным. Второе. Если среди вычислений будут одновременно типы Float и Double, результат будет иметь тип Double, за счет преимущества по объему вмещаемой памяти (8 байт у Double против 4 у Float).

В Котлин можно вывести тип переменной. Чтобы сделать это – нужно использовать оператор ::class.simpleName. Это оператор ссылки на метод или класс. Таким образом, можно получить имя класса переменной.

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

Присваивание через +=, инкремент, декремент

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

Объявим изменяемую переменную с названием counter и присвоим ей 0. Прибавлять единицу можно несколькими способами:

• Присваиваем переменной результат суммы значения текущей переменной и единицы:

counter = counter + 1

• Используем оператор сложения с присваиванием +=:

counter += 1

• Используем оператор инкремента ++:

counter++

Все эти операторы делают одно и то же. Точно так же можно отнимать единицу, используя оператор вычитания с присваиванием и декремент (--).

counter -= 1
counter--

Инкремент и декремент могут использоваться и в префиксной форме, поставив плюсы или минусы перед переменной:

++counter
--counter

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

Операторы сравнения

Наконец, пройдемся по операторам сравнения. Мы уже проинициализировали две переменные a и b (они хранят числа 5 и 7). Используем их. В методе println запишем различные варианты сравнения и распечатаем результаты.

println(a > b)
println(a < b)
println(a >= b)
println(a <= b)
println(a == b)
println(a != b)

Каждый из этих операторов возвращает результат типа Boolean. Переменные этого типа могут хранить в себе только два значения: истину или ложь. Именно этот результат мы увидим в консоли.