Урок 2. Переменные val и var, типы данных

Программе нужно где-то хранить данные: имя пользователя, счёт в игре, цену товара. Для этого есть переменные — именованные ячейки, в которых лежат значения. В этом уроке — как их объявлять, какие бывают типы и как считать.

val и var

В Kotlin переменную объявляют одним из двух слов:

• val (value — значение) — значение задаётся один раз и больше не меняется;
• var (variable — переменная) — значение можно менять сколько угодно.

fun main() {
    val name = "Anna"
    var age = 20
    println(name)
    println(age)
    age = 21
    println(age)
}

Anna
20
21

Знак = здесь — не равенство, а присваивание: «положить в переменную значение справа». Если написать name = "Olga", программа не соберётся: компилятор сообщит, что val нельзя присвоить заново (val cannot be reassigned).

Какое слово выбирать? По умолчанию — val. Когда значение не меняется, программу проще читать: не нужно искать, где его могли изменить. var берите только тогда, когда значение действительно меняется — например, счётчик в цикле. Подробнее — в справке Чем val отличается от var.

Типы данных

У каждой переменной есть тип — какие значения в ней могут лежать. Основные:

Тип можно не писать: компилятор сам поймёт его по значению. Это называется выводом типа. Но его можно указать явно — через двоеточие после имени:

fun main() {
    val count: Int = 5
    val price: Double = 9.99
    val isOpen: Boolean = true
    val letter: Char = 'K'
    val city: String = "Minsk"
    val population = 2_000_000
    println(count)
    println(price)
    println(isOpen)
    println(letter)
    println(city)
    println(population)
}

5
9.99
true
K
Minsk
2000000

Подчёркивания в числах — только для удобства чтения: 2_000_000 — то же, что 2000000. Дробная часть отделяется точкой, не запятой: 9.99.

Тип переменной задаётся один раз и не меняется. В var age = 20 можно положить 21, но не "twenty": компилятор сообщит о несовпадении типов (type mismatch).

Арифметика

fun main() {
    val a = 17
    val b = 5
    println(a + b)
    println(a - b)
    println(a * b)
    println(a / b)
    println(a % b)
    println(a.toDouble() / b)
}

22
12
85
3
2
3.4

Главное, что здесь нужно запомнить: деление двух целых чисел даёт целое число, дробная часть отбрасывается. 17 / 5 — это 3, а не 3.4. Знак % даёт остаток от деления: 17 % 5 — 2. Чтобы получить дробный результат, хотя бы одно из чисел должно быть дробным: 17.0 / 5 или a.toDouble() / b.

Для изменения переменной есть короткие записи:

Все они работают только с var.

Перевод из типа в тип

Kotlin сам не превращает переменную одного числового типа в другой — даже Int в Long, хотя любое Int поместится в Long. Строка val big: Long = n при val n = 7 не соберётся. (Число, записанное прямо в коде, подстраивается под тип само: val big: Long = 7 — можно.) Перевод пишут явно:

fun main() {
    val n = 7
    val big: Long = n.toLong()
    val d = n.toDouble()
    val back = 3.99.toInt()
    println(big)
    println(d)
    println(back)
    println(n.toString() + "!")
}

7
7.0
3
7!

• toLong(), toDouble(), toInt() — перевод между числовыми типами;
• toInt() у дробного числа отбрасывает дробную часть, а не округляет: 3.99.toInt() — это 3;
• toString() — число в строку.

Дробное число выводится с точкой и хотя бы одной цифрой после неё: 7.0, а не 7.

Перевод строки в число ("42".toInt()) разобран в следующем уроке и в справке Как перевести строку в число.

Переполнение

У Int есть предел. Если результат за него выходит, число «переворачивается» и становится отрицательным, причём без всякой ошибки:

fun main() {
    val big = 2_000_000_000
    println(big + big)
    println(big.toLong() + big)
}

-294967296
4000000000

Если числа могут быть больше двух миллиардов (суммы денег в копейках, факториалы, время в миллисекундах), берите Long. Число, которое не помещается в Int, компилятор сам делает Long: у val x = 3_000_000_000 тип Long.

Строки и символы

Строки складываются знаком +. К строке можно прибавить число — оно станет текстом:

fun main() {
    val word = "Kot" + "lin"
    println(word)
    println(word.length)
    println("Age: " + 20)
}

Kotlin
6
Age: 20

length — длина строки в символах. Обратный порядок, 20 + " years", не соберётся: к числу строку прибавить нельзя. Удобнее всего вставлять значения в текст через строковые шаблоны — о них в следующем уроке.

Char и String — разные типы: 'A' — один символ, "A" — строка из одного символа.

Константы

Значение, которое известно заранее и нужно в разных местах программы, объявляют вне функций как const val:

const val MAX_SCORE = 100

fun main() {
    println(MAX_SCORE)
}

100

Имена констант принято писать большими буквами через подчёркивание. Обычные переменные — в стиле camelCase: первое слово с маленькой буквы, следующие с большой: userName, totalPrice.

Коротко

• val — нельзя изменить после присваивания, var — можно. По умолчанию — val.
• Основные типы: Int, Long, Double, Boolean, Char, String. Тип можно не писать — компилятор выведет его.
• Целое делить на целое — целое: 17 / 5 даёт 3; остаток — %.
• Типы переводятся явно: toInt(), toLong(), toDouble(), toString().
• Int переполняется без ошибки — для больших чисел берите Long.

Проверьте себя

fun main() {
    var x = 10
    x += 5
    x--
    println(x)
}