Обзор базового синтаксиса

Объявление пакета и импорты

Объявление пакета должно находиться в начале исходного файла:

package my.demo

import kotlin.text.*

// ...

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

См. Пакеты.

Точка входа программы

Точкой входа приложения Kotlin является функция main:

fun main() {
    println("Hello world!")
}

Другая форма main принимает переменное количество аргументов String:

fun main(args: Array<String>) {
    println(args.contentToString())
}

Вывод в стандартный поток

print выводит свой аргумент в стандартный поток:

fun main() {
//sampleStart
    print("Hello ")
    print("world!")
//sampleEnd
}

println выводит свои аргументы и добавляет перевод строки, так что следующий вывод появится на следующей строке:

fun main() {
//sampleStart
    println("Hello world!")
    println(42)
//sampleEnd
}

Чтение из стандартного потока

Функция readln() читает данные из стандартного потока. Она считывает всю введенную пользователем строку как строку.

Функции println(), readln() и print() можно использовать вместе, чтобы выводить сообщения с запросом и отображением пользовательского ввода:

// Prints a message to request input
println("Enter any word: ")

// Reads and stores the user input. For example: Happiness
val yourWord = readln()

// Prints a message with the input
print("You entered the word: ")
print(yourWord)
// You entered the word: Happiness

Дополнительную информацию см. в разделе Чтение из стандартного потока.

Функции

Функция с двумя параметрами Int и возвращаемым типом Int:

//sampleStart
fun sum(a: Int, b: Int): Int {
    return a + b
}
//sampleEnd

fun main() {
    print("sum of 3 and 5 is ")
    println(sum(3, 5))
}

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

//sampleStart
fun sum(a: Int, b: Int) = a + b
//sampleEnd

fun main() {
    println("sum of 19 and 23 is ${sum(19, 23)}")
}

Функция, не возвращающая значимого значения:

//sampleStart
fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}
//sampleEnd

fun main() {
    printSum(-1, 8)
}

Тип возвращаемого значения Unit можно опустить:

//sampleStart
fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}
//sampleEnd

fun main() {
    printSum(-1, 8)
}

См. Функции.

Переменные

В Kotlin объявление переменной начинается с ключевого слова val или var, за которым следует имя переменной.

Используйте ключевое слово val для объявления переменных, которым присваивается значение только один раз. Это неизменяемые локальные переменные только для чтения, которым нельзя присвоить другое значение после инициализации:

fun main() {
//sampleStart
    // Declares the variable x and initializes it with the value of 5
    val x: Int = 5
    // 5
//sampleEnd
    println(x)
}

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

fun main() {
//sampleStart
    // Declares the variable x and initializes it with the value of 5
    var x: Int = 5
    // Reassigns a new value of 6 to the variable x
    x += 1
    // 6
//sampleEnd
    println(x)
}

Kotlin поддерживает вывод типов и автоматически определяет тип данных объявленной переменной. При объявлении переменной тип после ее имени можно опустить:

fun main() {
//sampleStart
    // Declares the variable x with the value of 5;`Int` type is inferred
    val x = 5
    // 5
//sampleEnd
    println(x)
}

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

fun main() {
//sampleStart
    // Initializes the variable x at the moment of declaration; type is not required
    val x = 5
    // Declares the variable c without initialization; type is required
    val c: Int
    // Initializes the variable c after declaration 
    c = 3
    // 5 
    // 3
//sampleEnd
    println(x)
    println(c)
}

Переменные можно объявлять на верхнем уровне:

//sampleStart
val PI = 3.14
var x = 0

fun incrementX() {
    x += 1
}
// x = 0; PI = 3.14
// incrementX()
// x = 1; PI = 3.14
//sampleEnd

fun main() {
    println("x = $x; PI = $PI")
    incrementX()
    println("incrementX()")
    println("x = $x; PI = $PI")
}

Сведения об объявлении свойств см. в разделе Свойства.

Создание классов и экземпляров

Для определения класса используйте ключевое слово class:

class Shape

Свойства класса можно перечислить в его объявлении или теле:

class Rectangle(val height: Double, val length: Double) {
    val perimeter = (height + length) * 2 
}

Конструктор по умолчанию с параметрами, перечисленными в объявлении класса, доступен автоматически:

class Rectangle(val height: Double, val length: Double) {
    val perimeter = (height + length) * 2 
}
fun main() {
    val rectangle = Rectangle(5.0, 2.0)
    println("The perimeter is ${rectangle.perimeter}")
}

Наследование классов объявляется с помощью двоеточия (:). По умолчанию классы final; чтобы разрешить наследование от класса, пометьте его как open:

open class Shape

class Rectangle(val height: Double, val length: Double): Shape() {
    val perimeter = (height + length) * 2 
}

Дополнительную информацию о конструкторах и наследовании см. в разделах Классы и Объекты и экземпляры.

Комментарии

Как и большинство современных языков, Kotlin поддерживает однострочные (или в конце строки) и многострочные (блочные) комментарии:

// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */

Блочные комментарии в Kotlin можно вкладывать друг в друга:

/* The comment starts here
/* contains a nested comment *​/  
and ends here. */

Сведения о синтаксисе комментариев документации см. в разделе Документирование кода Kotlin.

Шаблоны строк

fun main() {
//sampleStart
    var a = 1
    // simple name in template:
    val s1 = "a is $a" 
    
    a = 2
    // arbitrary expression in template:
    val s2 = "${s1.replace("is", "was")}, but now is $a"
//sampleEnd
    println(s2)
}

Подробную информацию см. в разделе Шаблоны строк.

Условные выражения

//sampleStart
fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}
//sampleEnd

fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

В Kotlin if также можно использовать как выражение:

//sampleStart
fun maxOf(a: Int, b: Int) = if (a > b) a else b
//sampleEnd

fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

См. выражения if.

Цикл for

fun main() {
//sampleStart
    val items = listOf("apple", "banana", "kiwifruit")
    for (item in items) {
        println(item)
    }
//sampleEnd
}

или:

fun main() {
//sampleStart
    val items = listOf("apple", "banana", "kiwifruit")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
//sampleEnd
}

См. Цикл for.

Цикл while

fun main() {
//sampleStart
    val items = listOf("apple", "banana", "kiwifruit")
    var index = 0
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
//sampleEnd
}

См. Цикл while.

Выражение when

//sampleStart
fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }
//sampleEnd

fun main() {
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}

См. Выражения и инструкции when.

Диапазоны

Проверьте, входит ли число в диапазон, с помощью оператора in:

fun main() {
//sampleStart
    val x = 10
    val y = 9
    if (x in 1..y+1) {
        println("fits in range")
    }
//sampleEnd
}

Проверьте, находится ли число вне диапазона:

fun main() {
//sampleStart
    val list = listOf("a", "b", "c")
    
    if (-1 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range, too")
    }
//sampleEnd
}

Переберите диапазон:

fun main() {
//sampleStart
    for (x in 1..5) {
        print(x)
    }
//sampleEnd
}

Или последовательность:

fun main() {
//sampleStart
    for (x in 1..10 step 2) {
        print(x)
    }
    println()
    for (x in 9 downTo 0 step 3) {
        print(x)
    }
//sampleEnd
}

См. Диапазоны и последовательности.

Коллекции

Переберите коллекцию:

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
//sampleStart
    for (item in items) {
        println(item)
    }
//sampleEnd
}

Проверьте, содержит ли коллекция объект, с помощью оператора in:

fun main() {
    val items = setOf("apple", "banana", "kiwifruit")
//sampleStart
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
//sampleEnd
}

Используйте лямбда-выражения для фильтрации и преобразования коллекций:

fun main() {
//sampleStart
    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits
      .filter { it.startsWith("a") }
      .sortedBy { it }
      .map { it.uppercase() }
      .forEach { println(it) }
//sampleEnd
}

См. Обзор коллекций.

Nullable-значения и проверки на null

Если возможно значение null, ссылку необходимо явно пометить как nullable. Имена nullable-типов заканчиваются на ?. Например, Int?.

Верните null, если str не содержит целое число:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

Используйте функцию, возвращающую nullable-значение:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

//sampleStart
fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x and y are automatically cast to non-nullable after null check
        println(x * y)
    }
    else {
        println("'$arg1' or '$arg2' is not a number")
    }    
}
//sampleEnd

fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}

или:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    
//sampleStart
    // ...
    if (x == null) {
        println("Wrong number format in arg1: '$arg1'")
        return
    }
    if (y == null) {
        println("Wrong number format in arg2: '$arg2'")
        return
    }

    // x and y are automatically cast to non-nullable after null check
    println(x * y)
//sampleEnd
}

fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("99", "b")
}

См. Безопасность при работе с null.

Проверки типов и автоматические приведения

Оператор is проверяет, является ли выражение экземпляром типа. Если неизменяемая локальная переменная или свойство проверяется на соответствие конкретному типу, явно приводить его не нужно:

//sampleStart
fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` is automatically cast to `String` in this branch
        return obj.length
    }

    // `obj` is still of type `Any` outside of the type-checked branch
    return null
}
//sampleEnd

fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

или:

//sampleStart
fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null

    // `obj` is automatically cast to `String` in this branch
    return obj.length
}
//sampleEnd

fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

или даже:

//sampleStart
fun getStringLength(obj: Any): Int? {
    // `obj` is automatically cast to `String` on the right-hand side of `&&`
    if (obj is String && obj.length >= 0) {
        return obj.length
    }

    return null
}
//sampleEnd

fun main() {
    fun printLength(obj: Any) {
        println("Getting the length of '$obj'. Result: ${getStringLength(obj) ?: "Error: The object is not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength("")
    printLength(1000)
}

См. разделы Классы и Приведение типов.