Kotlin

Оператор безопасного вызова. Bспользуется для безопасного обращения к свойствам или методам nullable-объектов. Если объект равен null, дальнейшая цепочка вызовов будет проигнорирована.

val length = name?.length  // Возвращает длину строки или null

Оператор Элвиса. Позволяет указать значение по умолчанию, если переменная равна null.

val length = name?.length ?: 0  // Если name == null, возвращается 0

Оператор небезопасного приведения. Используется, когда уверены, что значение не null. Но если оно окажется null, выбросится исключение NullPointerException.

val length = name!!.length  // NullPointerException, если name == null

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

// Файл расположен в папке src/main/kotlin/com/example/myapp

package com.example.myapp

class MyClass {
    fun greet() {
        println("Hello from MyClass!")
    }
}

fun main() {
    val myClass = MyClass()
    myClass.greet()
}

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

• Импорт класса

import java.util.Date

fun main() {
    val currentDate = Date()
    println(currentDate)
}

• Импорт функции

import kotlin.math.sqrt

fun main() {
    val number = 16.0
    val result = sqrt(number)
    println("Square root of $number is $result")
}

• Импорт с использованием псевдонимов

import kotlin.collections.HashMap as MapAlias

fun main() {
    val map = MapAlias<String, Int>()
    map["one"] = 1
    map["two"] = 2
    println(map)
}

• Импорт всех элементов пакета

import kotlin.math.*

fun main() {
    val number = 25.0
    println("Square root: ${sqrt(number)}")
    println("Cosine: ${cos(number)}")
}

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

public class Person(val name: String) {
    public fun greet() {
        println("Hello, my name is $name")
    }
}

fun main() {
    val person = Person("Alice")
    person.greet() // Выведет: Hello, my name is Alice
}

Ограничивает доступ к элементам (свойствам, методам или конструкторам) только в пределах класса и его подклассов. Применяется только к классам и интерфейсам.

open class Animal {
    protected fun makeSound() {
        println("Animal sound")
    }
}

class Dog: Animal() {
    fun bark() {
        makeSound() // Доступно, так как это подкласс
        println("Dog barks")
    }
}

fun main() {
    val dog = Dog()
    dog.bark() // Выведет: Animal sound, Dog barks
    // dog.makeSound() // Ошибка: makeSound() недоступен вне класса и его подклассов
}

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

class Person(private val name: String) {
    private fun showName() {
        println("Name is $name")
    }

    fun introduce() {
        showName() // Можно вызвать внутри класса
    }
}

fun main() {
    val person = Person("Alice")
    person.introduce() // Выведет: Name is Alice
    // person.showName() // Ошибка: showName() недоступен вне класса
}

Используется для ограничения доступа к элементам (классам, функциям, свойствам и конструкторам) в пределах одного модуля. Модуль — это набор файлов, которые компилируются вместе, например, проект, библиотека или единица сборки Gradle. В Java нет модификатора internal, при компиляции класс станет общедоступным public. Имена internal-методов будут искажены, чтобы их было сложнее случайно вызвать.

• На класс и его методы

internal class Car(val model: String) {
    internal fun drive() {
        println("$model is driving")
    }
}

fun main() {
    val car = Car("Toyota")
    car.drive() // Доступно, так как находится в том же модуле
}

• На уровне файла

internal fun calculateSum(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    println(calculateSum(5, 10)) // Доступно, так как находится в том же модуле
}

• Конструктор

class User internal constructor(val name: String) {
    fun greet() {
        println("Hello, $name")
    }
}

fun main() {
    val user = User("Alice") // Доступно, так как находится в том же модуле
    user.greet()
}

Используется для того, чтобы разрешить классу, методу или свойству быть унаследованными или переопределенными. В Kotlin по умолчанию все классы и методы являются закрытыми (final). Это сделано для повышения безопасности и предсказуемости кода.

• open класс и наследование

open class Animal {
    open fun sound() {
        println("Some generic animal sound")
    }
}

class Dog: Animal() {
    override fun sound() {
        println("Bark!")
    }
}

fun main() {
    val dog = Dog()
    dog.sound() // Выведет: Bark!
}

• open свойства

open class Car {
    open val maxSpeed: Int = 180

    open fun drive() {
        println("Driving at speed: $maxSpeed")
    }
}

class SportsCar: Car() {
    override val maxSpeed: Int = 300

    override fun drive() {
        println("Driving at high speed: $maxSpeed")
    }
}

fun main() {
    val car = SportsCar()
    car.drive() // Выведет: Driving at high speed: 300
}

• open и protected

open class Vehicle {
    protected open fun startEngine() {
        println("Engine started")
    }
}

class Truck: Vehicle() {
    override fun startEngine() {
        println("Truck engine started")
    }

    fun start() {
        startEngine() // Доступен, так как он protected и переопределен
    }
}

fun main() {
    val truck = Truck()
    truck.start() // Выведет: Truck engine started
}

Используется для того, чтобы запретить повторное наследование или переопределение класса, метода или свойства.

open class GrandPa {
    open fun smoke() {
        println("Дед курит сигары")
    }
}
    
open class Dad: GrandPa() {
    final override fun smoke() {
        println("Батя унаследовал от деда привычку курить сигары, но запретил ее передачу сыну")
    }
}
    
class Son: Dad() {
    // Сын не может наследовать метод курить, потому что он final
}

Базовый класс для всех типов (аналог Object в Java). Все классы Kotlin по умолчанию наследуют Any. Он включает 3 метода: equals(), hashCode(), и toString().

fun printInfo(obj: Any) {
    println("Class: ${obj::class.simpleName}")
}

fun main() {
    printInfo("Hello, Kotlin!")
    printInfo(123)
}

Тип, который указывает, что функция не возвращает значимого значения (аналогичен void в Java). Unit является полноценным типом и может использоваться как значение. Функция с типом Unit возвращает единственный объект Unit.

fun printMessage(): Unit {
    println("Hello, Kotlin!")
}

val printHello: () -> Unit = { println("Hello, World!") }

fun main() {
    printHello()
}

Обозначает тип, который никогда не имеет значений и указывает на отсутствие завершения (например, выброс исключения). Обычно применяется, чтобы сообщить компилятору, что функция никогда не возвращается.

fun fail(): Nothing {
    throw IllegalArgumentException("Ошибка")
}

fun main() {
    fail() // Программа завершится с исключением
}

sealed class Result<out A: Any, out B: Any> {
    data class Success<A: Any>(val value: A): Result<A, Nothing>()
    data class Failure<B: Any>(val error: B): Result<Nothing, B>()
}

Конструкция constructor используется для объявления конструкторов классов. В языке есть два вида конструкторов: primary constructor (главный конструктор) и secondary constructors (вторичные конструкторы). Главный конструктор задается сразу при объявлении класса и является его основной точкой инициализации. Он может быть пустым или содержать параметры для передачи значений.

class Person(val name: String, var age: Int) {
    init {
        println("Создан объект с именем: $name и возрастом: $age")
    }
}

• Можно задать видимость конструктора с помощью модификаторов доступа private, protected и internal.

class Restricted private constructor(val name: String) {
    // В этом классе никто не сможет создать экземпляр через обычный конструктор
}

• Можно задавать значения по умолчанию для параметров конструктора.

class Employee(val name: String, val position: String = "Инженер")

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

• Может быть несколько вторичных конструкторов в одном классе.

• Вторичные конструкторы обязаны вызывать либо главный конструктор, либо другие вторичные конструкторы.

class Book {
    var title: String
    var author: String
    
    // Главный конструктор
    constructor(title: String) {
        this.title = title
        this.author = "Неизвестный автор"
    }

    // Вторичный конструктор, вызывает другой конструктор
    constructor(title: String, author: String): this(title) {
        this.author = author
    }
}

class Animal(val species: String) {
    var age: Int = 0

    // Вторичный конструктор
    constructor(species: String, age: Int): this(species) {
        this.age = age
    }
}

Оператор == сравнивает значения, а === ссылки на переменные.

val number = Integer(1)
val anotherNumber = Integer(1)
number == anotherNumber // true (structural equality)
number === anotherNumber // false (referential equality)

Cпециальный тип интерфейсов, предназначенный для функциональных интерфейсов (также известных как Single Abstract Method (SAM) интерфейсы). Это интерфейсы, которые содержат только один абстрактный метод, и они могут быть использованы для создания лямбд и сокращенного синтаксиса функциональных объектов.

fun interface Calculator {
    fun calculate(a: Int, b: Int): Int
}

fun main() {
    // Используем лямбду вместо создания объекта
    val sum: Calculator = Calculator { a, b -> a + b }
    println(sum.calculate(5, 3)) // Выведет: 8

    val multiply: Calculator = Calculator { a, b -> a * b }
    println(multiply.calculate(5, 3)) // Выведет: 15
}

Возвращает имя элемента enum-класса в виде строки.

enum class Color {
    RED, GREEN, BLUE
}

fun main() {
    val color = Color.RED
    println(color.name) // Выведет: RED
}

Возвращает порядковый номер (индекс) элемента в enum-классе.

enum class Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

fun main() {
    val day = Day.WEDNESDAY
    println("The ordinal of $day is ${day.ordinal}") // Выведет: The ordinal of WEDNESDAY is 2
}

Возвращает список (List) всех элементов enum-класса.

enum class Direction {
    NORTH, EAST, SOUTH, WEST
}

fun main() {
    val directions: List<Direction> = Direction.entries
    directions.forEach { direction ->
        println(direction) // listOf(NORTH, EAST, SOUTH, WEST)
    }
}

Возвращает массив (Array) всех элементов enum-класса. Метод устарел, рекомендуется заменить на Enum.entries начиная с версии Kotlin 1.9.

enum class Direction {
    NORTH, EAST, SOUTH, WEST
}

fun main() {
    val directions: Array<Direction> = Direction.values()
    directions.forEach { direction ->
        println(direction) // [NORTH, EAST, SOUTH, WEST]
    }
}

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

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

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

• val требует немедленной инициализации при объявлении или инициализации в блоке инициализации.

• val может быть объявлен на уровне класса, функции или блока, что определяет его область видимости.

val pi = 3.14
val name: String = "Alice"

class Example {
	  val a: Int
    
    init {
        a = 0
    }
}

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

• Переменные, объявленные с помощью var, могут быть инициализированы значением и изменены позже.

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

• var может быть объявлен на уровне класса, функции или блока, определяя его область видимости.

var count = 0
count += 1 // Теперь count равно 1

var name: String = "Alice"

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

• Можно использовать только с переменными, которые имеют тип String или примитивные типы.

• Значения, объявленные с помощью const, должны быть известны на этапе компиляции и не могут быть изменены. Они не могут быть инициализированы с помощью выражений, которые зависят от выполнения кода.

• Делает код более читаемым и оптимизированным, так как компилятор заменяет все вхождения const переменной ее значением на этапе компиляции.

• Переменные должны быть объявлены на верхнем уровне файла или в именованном объекте или в companion object. Их нельзя объявить внутри функции или класса напрямую.

const val CONST_ON_TOP_LEVEL = "Name"

object MyObject {
		const val CONST_IN_NAMED_OBJECT = 10
}

class MyClass {
		companion object {
				const val CONST_IN_COMPANION_OBJECT = 'A'
		}
}

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

• В одной функции может быть только один параметр, объявленный как vararg.

• Параметр vararg должен быть последним в списке параметров функции.

• Можно комбинировать vararg с другими параметрами, но vararg всегда должен быть в конце.

fun printNumbers(vararg numbers: Int) {
    for (number in numbers) {
        println(number)
    }
}

printNumbers(1, 2, 3, 4, 5)  // Передача отдельных значений

val nums = intArrayOf(6, 7, 8)
printNumbers(*nums)  // Передача массива

Модификатор, который используется для объявления переменных, которые будут инициализированы позже, но перед использованием. Он позволяет избежать необходимости присваивать значение переменной в момент её объявления, что особенно полезно для не-nullable переменных, которые не могут иметь значение по умолчанию.

• lateinit можно использовать только с переменными, которые являются изменяемыми (var).

• lateinit не могут иметь тип, основанный на примитивных типах (например, Int Long Float Double Boolean Char).

• lateinit применим только к переменным класса, а не к локальным переменным в методах.

• Если попытаться получить доступ к lateinit-переменной до инициализации, будет выброшено исключение UninitializedPropertyAccessException.

class Example {
    lateinit var name: String
}

fun main() {
    val example = Example()
    example.name = "Kotlin"  // Инициализация
    println(example.name)    // Вывод: Kotlin
}

fun main() {
    val example = Example()
    if (::example.name.isInitialized) {
        println(example.name)
    } else {
        println("name не инициализирована")
    }
}

Используется для объявления функций.

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

• Функции поддерживают значения по умолчанию.

fun greet(name: String = "Гость") {
    println("Привет, $name!")
}

// Вызывается как greet() или greet("Иван")

• Функции поддерживают переменное количество аргументов.

fun printNumbers(vararg numbers: Int) {
    for (number in numbers) {
        println(number)
    }
}

// Пример вызова: printNumbers(1, 2, 3, 4)

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

// Здесь функция factorial вычисляет факториал числа.
// Благодаря ключевому слову tailrec, компилятор оптимизирует рекурсивные вызовы в цикл, что предотвращает переполнение стека при больших значениях n.

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n <= 1) acc else factorial(n - 1, acc * n)
}

fun main() {
    println(factorial(5))  // Вывод: 120
}

Используется для перегрузки операторов. Оно позволяет разработчикам определять, как стандартные операторы (например, +, -, *, ==, [], и т. д.) должны вести себя при применении к объектам определенного класса. Это делает код более читаемым и интуитивно понятным, позволяя использовать синтаксис, похожий на встроенные типы данных, для своих собственных классов.

• Перегрузка оператора сложения +

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

fun main() {
    val p1 = Point(3, 4)
    val p2 = Point(1, 2)
    val p3 = p1 + p2 // Используется перегруженный оператор +
    println(p3) // Выведет: Point(x=4, y=6)
}

• Перегрузка оператора вычитания -

data class Point(val x: Int, val y: Int) {
    operator fun minus(other: Point): Point {
        return Point(x - other.x, y - other.y)
    }
}

fun main() {
    val p1 = Point(5, 7)
    val p2 = Point(2, 3)
    println(p1 - p2) // Выведет: Point(x=3, y=4)
}

• Перегрузка оператора умножения *

data class Vector(val x: Int, val y: Int) {
    operator fun times(scale: Int): Vector {
        return Vector(x * scale, y * scale)
    }
}

fun main() {
    val v = Vector(2, 3)
    val scaled = v * 5 // Используется перегруженный оператор *
    println(scaled) // Выведет: Vector(x=10, y=15)
}

• Перегрузка оператора деления /

data class Fraction(val numerator: Int, val denominator: Int) {
    operator fun div(other: Fraction): Fraction {
        return Fraction(
            numerator * other.denominator,
            denominator * other.numerator
        )
    }
}

fun main() {
    val f1 = Fraction(3, 4)
    val f2 = Fraction(2, 5)
    println(f1 / f2) // Выведет: Fraction(numerator=15, denominator=8)
}

• Перегрузка оператора остатка от деления %

data class ModNumber(val value: Int) {
    operator fun rem(other: Int): Int {
        return value % other
    }
}

fun main() {
    val num = ModNumber(10)
    println(num % 3) // Выведет: 1
}

• Перегрузка операторов равенства == ≠

data class Person(val name: String, val age: Int) {
    operator fun equals(other: Person): Boolean {
        return this.name == other.name && this.age == other.age
    }
}

fun main() {
    val person1 = Person("Alice", 25)
    val person2 = Person("Alice", 25)
    println(person1 == person2) // Выведет: true
    println(person1 != person2) // Выведет: false
}

• Перегрузка операторов сравнения > < >= <=

data class Box(val weight: Int) : Comparable<Box> {
    override operator fun compareTo(other: Box): Int {
        return this.weight - other.weight
    }
}

fun main() {
    val box1 = Box(5)
    val box2 = Box(10)
    println(box1 < box2)  // Выведет: true
    println(box1 > box2)  // Выведет: false
    println(box1 <= box2) // Выведет: true
    println(box1 >= box2) // Выведет: false
}

• Перегрузка операторов инкремента и декремента ++ --

data class Counter(var value: Int) {
    operator fun inc(): Counter {
        value++
        return this
    }
    
    operator fun dec(): Counter {
        value--
        return this
    }
}

fun main() {
    var counter = Counter(5)
    counter++
    println(counter.value) // Выведет: 6
    counter--
    println(counter.value) // Выведет: 5
}

• Перегрузка оператора логического отрицания !

data class Light(val isOn: Boolean) {
    operator fun not() = Light(!isOn)
}

fun main() {
    val light = Light(true)
    println(!light) // Выведет: Light(isOn=false)
}

• Перегрузка оператора доступа к элементу get

class Matrix(private val data: Array<Array<Int>>) {
    operator fun get(row: Int, col: Int): Int {
        return data[row][col]
    }
}

fun main() {
    val matrix = Matrix(arrayOf(arrayOf(1, 2), arrayOf(3, 4)))
    println(matrix[0, 1]) // Используется перегруженный оператор []
    // Выведет: 2
}

• Перегрузка оператора установки значения set

class MutableListWrapper<T>(private val list: MutableList<T>) {
    operator fun set(index: Int, value: T) {
        list[index] = value
    }
    
    override fun toString(): String {
        return list.toString()
    }
}

fun main() {
    val list = MutableListWrapper(mutableListOf(1, 2, 3))
    list[1] = 10
    println(list) // Выведет: [1, 10, 3]
}

• Перегрузка оператора вызова функции ()

class Greeter(val greeting: String) {
    operator fun invoke(name: String) {
        println("$greeting, $name!")
    }
}

fun main() {
    val greeter = Greeter("Hello")
    greeter("Kotlin") // Выведет: Hello, Kotlin!
}

Имя параметра по умолчанию для одиночного параметра в лямбда-выражении. Когда лямбда принимает только один аргумент, его можно не называть явно, и тогда к нему можно обращаться через it.

val numbers = listOf(1, 2, 3, 4, 5)
val doubledNumbers = numbers.map { it * 2 }

println(doubledNumbers) // Выведет: [2, 4, 6, 8, 10]

Оператор ссылки на функцию (function reference). Он позволяет передавать функции или свойства в качестве параметров другим функциям или сохранять их в переменные. Этот оператор может ссылаться как на функции, так и на свойства класса.

• Ссылка на функцию

fun greet() {
    println("Hello!")
}

val greetFunction = ::greet
greetFunction() // Вызовет функцию greet, результат: "Hello!"

• Ссылка на методы класса

class Greeter {
    fun sayHello() {
        println("Hello from the Greeter!")
    }
}

val greeter = Greeter()
val helloFunction = greeter::sayHello
helloFunction() // Выведет: "Hello from the Greeter!"

• Ссылка на конструктор

class Person(val name: String, val age: Int)

val createPerson = ::Person
val person = createPerson("John", 25)
println(person.name) // Выведет: "John"

• Ссылка на свойства

val x = 42
val propertyRef = ::x
println(propertyRef.get()) // Выведет: 42

• Использование в лямбдах

val numbers = listOf(1, 2, 3, 4, 5)
val squares = numbers.map(Int::toString)
println(squares) // Выведет: ["1", "2", "3", "4", "5"]

• C функциями расширениями:

fun String.printWithExclamation() {
    println(this + "!")
}

val printExclaim = String::printWithExclamation
printExclaim("Hello") // Выведет: "Hello!"

Локальные функции — это функции, определенные внутри другой функции. Они могут быть вызваны только изнутри той функции, где они объявлены. Локальные функции полезны для структурирования кода и уменьшения дублирования, а также для повышения его читабельности.

fun main() {
    fun outerFunction(number: Int): Int {
        // Локальная функция
        fun double(x: Int) = x * 2
        
        // Использование локальной функции
        return double(number) + double(number)
    }

    val result = outerFunction(5)
    println(result) // Выведет: 20
}

Функция высшего порядка — это функция, которая принимает другую функцию в качестве аргумента или возвращает функцию в качестве результата.

// Эта функция принимает значение value и функцию func, которая преобразует value.
// Она применяет функцию дважды и возвращает результат.

fun <T> applyTwice(value: T, func: (T) -> T): T {
    return func(func(value))
}

// Функция createMultiplier возвращает функцию, которая умножает входное число на заданный коэффициент.

fun createMultiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

Анонимная функция — это функция без имени, которую можно объявить и использовать в месте, где она нужна. В Kotlin они могут быть созданы с помощью ключевого слова fun. Обычно используются для кратковременных операций и передаются как аргументы в другие функции. Это похоже на лямбда-выражения, но с явным определением типов и тела функции.

val sum = fun(a: Int, b: Int): Int {
    return a + b
}

Выполняет блок кода, пока условие истинно.

var i = 0
while (i < 5) {
    println(i)
    i++
}

Cначала выполняет блок кода, а затем проверяет условие. Он гарантирует хотя бы одно выполнение.

var i = 0
do {
    println(i)
    i++
} while (i < 5)

Используется для итерации по коллекциям, диапазонам и последовательностям.

• Итерация по диапазону. Используется оператор in. Итерация проходит от начального до конечного значения (включительно):

for (i in 1..5) {
    println(i)  // Выведет: 1, 2, 3, 4, 5
}

• until — итерация до верхней границы (исключительно):

for (i in 1 until 5) {
    println(i)  // Выведет: 1, 2, 3, 4 (5 не включено)
}

• downTo — итерация в обратном порядке:

for (i in 5 downTo 1) {
    println(i)  // Выведет: 5, 4, 3, 2, 1
}

• step — позволяет задать шаг для увеличения или уменьшения значений:

for (i in 1..10 step 2) {
    println(i)  // Выведет: 1, 3, 5, 7, 9
}

for (i in 10 downTo 1 step 3) {
    println(i)  // Выведет: 10, 7, 4, 1
}

• Итерация по коллекции. Итерация по элементам коллекции (например, список или массив):

val items = listOf("a", "b", "c")
for (item in items) {
    println(item)  // Выведет: a, b, c
}

• Итерация по индексам коллекции. Можно итерироваться по индексам коллекции с использованием .indices:

val items = listOf("a", "b", "c")
for (i in items.indices) {
    println("Index $i contains ${items[i]}")
}

• Итерация по паре индекс-значение. Используя функцию .withIndex(), можно получать одновременно и индекс, и элемент:

val items = listOf("a", "b", "c")
for ((index, value) in items.withIndex()) {
    println("Item at index $index is $value")
}

Досрочно завершает выполнение цикла. После его вызова цикл немедленно прерывается.

val items = listOf("a", "b", "c", "d")
for (item in items) {
    if (item == "c") break  // Прерываем цикл, когда находим "c"
    println(item)  // выведет: a, b
}

Пропускает оставшуюся часть текущей итерации и переходит к следующей.

val items = listOf("a", "b", "c", "d")
for (item in items) {
    if (item == "c") continue  // Пропускаем "c" и продолжаем с "d"
    println(item)  // выведет: a, b, d
}

Позволяют управлять потоком выполнения кода, особенно когда нужно прервать цикл, вернуть значение или продолжить выполнение из вложенного блока. Создаются с помощью символа @, и их можно использовать вместе с return, break, и continue для указания конкретного уровня блока или лямбды, к которому нужно вернуться.

fun findNumber(matrix: List<List<Int>>, target: Int) {
    outerLoop@ for (row in matrix) {       // Лейбл для внешнего цикла
        for (cell in row) {
            if (cell == target) {
                println("Found $target")
                break@outerLoop            // Выход из внешнего цикла
            }
        }
    }
    println("Search complete")
}

fun processMatrix(matrix: List<List<Int>>) {
    outerLoop@ for (row in matrix) {          // Лейбл для внешнего цикла
        for (cell in row) {
            if (cell == 0) continue@outerLoop // Переход к следующей итерации внешнего цикла
            println(cell)
        }
    }
}

fun processNumbers(numbers: List<Int>) {
    numbers.forEach {
        if (it == 0) return@forEach        // Завершает только текущую итерацию в лямбде
        println(it)
    }
    println("Completed processing")
}

Тип данных для представления логических значений, который может содержать одно из двух значений: true или false. Boolean используется в условных операторах, циклах и для хранения результатов логических выражений.

val isAdult: Boolean = true

Тип данных, представляющий символ. Символ — это отдельный элемент текста, который может быть буквой, цифрой, специальным символом или любым другим символом из набора Unicode. В отличие от строк, Char представляет один символ и обозначается в коде одиночными кавычками.

val letter: Char = 'A'
val smiley: Char = '\u263A' // Unicode для ☺

val char: Char = 'A'
val charCode: Int = char.code // Преобразование Char в Int
println("Code of '$char': $charCode") // Выведет: Code of 'A': 65

val newChar: Char = charCode.toChar() // Преобразование Int в Char
println("Char from code $charCode: $newChar") // Выведет: Char from code 65: A

fun main() {
    val char1: Char = '5'
    val char2: Char = 'a'
    
    println("Is '$char1' a digit? ${char1.isDigit()}") // Выведет: Is '5' a digit? true
    println("Is '$char2' a digit? ${char2.isDigit()}") // Выведет: Is 'a' a digit? false
}

fun main() {
    val char1: Char = 'K'
    val char2: Char = '3'
    
    println("Is '$char1' a letter? ${char1.isLetter()}") // Выведет: Is 'K' a letter? true
    println("Is '$char2' a letter? ${char2.isLetter()}") // Выведет: Is '3' a letter? false
}

fun main() {
    val char1: Char = ' '
    val char2: Char = '\n'
    val char3: Char = 'a'
    
    println("Is ' ' a whitespace? ${char1.isWhitespace()}") // Выведет: Is ' ' a whitespace? true
    println("Is '\\n' a whitespace? ${char2.isWhitespace()}") // Выведет: Is '\n' a whitespace? true
    println("Is 'a' a whitespace? ${char3.isWhitespace()}") // Выведет: Is 'a' a whitespace? false
}

fun main() {
    val char1: Char = 'G'
    val char2: Char = 'g'
    
    println("Is '$char1' uppercase? ${char1.isUpperCase()}") // Выведет: Is 'G' uppercase? true
    println("Is '$char2' uppercase? ${char2.isUpperCase()}") // Выведет: Is 'g' uppercase? false
}

fun main() {
    val char1: Char = 'm'
    val char2: Char = 'M'
    
    println("Is '$char1' lowercase? ${char1.isLowerCase()}") // Выведет: Is 'm' lowercase? true
    println("Is '$char2' lowercase? ${char2.isLowerCase()}") // Выведет: Is 'M' lowercase? false
}

Представляет собой последовательность символов. Он является более общим типом, чем String, и предоставляет методы для работы с текстом. Это интерфейс, который не хранит данные сам по себе, а описывает поведение объектов, содержащих текст.

val text: CharSequence = "Kotlin is great!"

val text: CharSequence = "Hello, Kotlin"
println("Length: ${text.length}") // Выведет: Length: 13

val text: CharSequence = "Hello"
println("Character at index 1: ${text.get(1)}") // Выведет: Character at index 1: e

val text: CharSequence = "Kotlin Programming"
val subText = text.subSequence(0, 6)
println("Subsequence: $subText") // Выведет: Subsequence: Kotlin

val text: CharSequence = StringBuilder("Mutable text")
val str: String = text.toString()
println("String representation: $str") // Выведет: String representation: Mutable text

Класс для работы со строками.

val name = "Котлин"
println("Привет, $name!") // Привет, Котлин

базовый класс для числовых типов.

Оператор для выражения диапазона значений. Работает как until. Дает понять, что верхняя граница не включена

when (value) {
    in 0.0..<0.25 -> // first quarter
    in 0.25..<0.5 -> // second quarter
    in 0.5..<0.75 -> // third quarter
    in 0.75..1.0 ->  // last quarter  <- note closed range here
}

val a: Int = 65 % 10  // 5. Возвращает остаток от целочисленного деления двух чисел
											// 65 / 10 = 6.5. Результатом будет число после запятой
											// 10 % 3 = 1
											// 10 / 20 = 0.5. Если целых до запятой нет то результатом будет числитель.

val a: Int = 10
a += 2 // 12. Эквивалентно a = a + 2
a -= 2 // 8. Эквивалентно а = а - 2
a *= 2 // 20. Эквивалентно а = а * 2
a /= 2 // 5. Эквивалентно а = а / 2
a %= 3 // 1.

var x: Int = 5
val y = ++x // Префиксный инкремент увеличивает значение на единицу. x должен быть var
printLn(x)  // 6
printLn(y)  // 6

var x = 5
val y = --x // Префиксный декремент уменьшает значение на единицу. x должен быть var
println(x)  // x = 4
println(y)  // y = 4

var x = 5
val y = x++ // Постфиксный инкремент возвращает значение до увеличения на единицу. x должен быть var
println(x)  // x = 6
println(y)  // y = 5

var x = 5
val y = x-- // Постфиксный декремент возвращает значение до уменьшения на единицу. x должен быть var
println(x)  // x = 4
println(y)  // y = 5

val value: Double = 3.14123456789
val roundedValue: Double = value
    .toBigDecimal()
    .setScale(2, RoundingMode.HALF_EVEN)
    .toDouble() // 3.14

Используется для побитового логического И между двумя значениями типа Int, Long, или других целочисленных типов. Оператор and выполняет побитовое сравнение двух чисел. Он сравнивает каждую пару битов двух чисел, и если оба бита равны 1, результатом будет 1, иначе — 0.

val a = 5 // в двоичной системе 0101
val b = 3 // в двоичной системе 0011

val result = a and b // результат 1, в двоичной системе 0001
println(result)      // Выведет 1

Используется для выполнения побитовой операции «логическое ИЛИ» (bitwise OR) между целочисленными значениями (например, Int, Long). Оператор or выполняет побитовое сравнение двух чисел. Если хотя бы один бит из двух операндов равен 1, результатом для этого бита будет 1. Если оба бита равны 0, результатом будет 0.

val a = 5 // в двоичной системе: 0101
val b = 3 // в двоичной системе: 0011

val result = a or b // результат: 7 (в двоичной: 0111)
println(result)     // Выведет 7

Используется для выполнения побитовой операции «исключающее ИЛИ» между двумя целыми числами. Оператор обозначается символом ^.

// a xor b возвращает 1, если биты a и b различны (один из них 1, а другой 0).
// Возвращает 0, если биты a и b одинаковы (оба 0 или оба 1).
fun main() {
    val a = 5 // Бинарное представление: 0101
    val b = 3 // Бинарное представление: 0011
    val result = a xor b // 0110 (6 в десятичной системе)

    println(result) // Выведет: 6
}

Оператор сдвига влево. Сдвигает биты целого числа влево на указанное количество позиций, сохраняя исходный знак целого числа. Младшие значащие биты с правой стороны значения заполняются нулями. Операция эквивалентна умножению целого числа на n^2.

@Test
fun `shifts bits left in an integer`() {
    assertEquals(512, 128 shl 2)
}

Оператор сдвига вправо. Сдвигает биты целого числа вправо на указанное количество позиций. Эта операция эквивалентна делению целого числа на n^2, сохраняя знак исходного целого числа.

@Test
fun `shifts bits right in a positive integer`() {
    assertEquals(32, 128 shr 2)
}

@Test
fun `shifts bits right in a negative integer`() {
    val a = -128 // 11111111111111111111111110000000
    val expected = -32 // 11111111111111111111111111100000
    assertEquals(expected, a shr 2)
}

Оператор сдвига вправо без знака. Сдвигает биты целого числа вправо на указанное количество позиций. Избыточные биты, сдвинутые вправо, отбрасываются, а нулевые биты всегда сдвигаются слева. В отличие от оператора shr оператор ushr не сохраняет знак исходного целого числа.

@Test
fun `shifts unsigned bits right in an integer`() {
    val a = -128 // 11111111111111111111111110000000
    val expected = 1073741792 // 00111111111111111111111111100000
    assertEquals(expected, a ushr 2)
}

Используется для выполнения побитовой операции «NOT» (инверсия) над целым числом. Этот оператор инвертирует все биты числа, превращая 0 в 1 и 1 в 0. Для целых чисел, таких как Int или Long, операция inv меняет каждый бит числа на противоположный. Например, если в двоичном представлении число было 0101, то после применения inv получится 1010.

fun main() {
    val a = 5            // Бинарное представление: 0000 0101
    val result = a.inv() // Инвертирует все биты: 1111 1010

    println(result) // Выведет: -6
}

Используется для подсчета количества единичных битов (1) в бинарном представлении числа.

fun main() {
    val a = 5                    // Бинарное представление: 0101
    val count = a.countOneBits() // 2 (два единичных бита)

    println(count) // Выведет: 2
}

Используется для подсчета количества ведущих нулевых битов в бинарном представлении целого числа. Возвращает количество нулевых битов, расположенных в начале (слева) бинарного представления числа, до первого встреченного бита 1.

fun main() {
    val a = 5 // Бинарное представление: 0000 0101
    val count = a.countLeadingZeroBits() // 4

    println(count) // Выведет: 4
}

Используется для подсчета количества завершающих нулевых битов в бинарном представлении целого числа. Возвращает количество нулевых битов, расположенных в конце (справа) бинарного представления числа, после последнего встреченного бита 1.

fun main() {
    val a = 40 // Бинарное представление: 0010 1000
    val count = a.countTrailingZeroBits() // 3

    println(count) // Выведет: 3
}

Возвращает значение, которое содержит только самый старший бит в бинарном представлении целого числа, установленных в 1. Все остальные биты устанавливаются в 0. Находит самый старший бит, установленный в 1, и устанавливает только этот бит в результирующее значение, в то время как все остальные биты устанавливаются в 0.

fun main() {
    val a = 42 // Бинарное представление: 0010 1010
    val result = a.takeHighestOneBit() // 0010 0000 (32 в десятичной системе)

    println(result) // Выведет: 32
}

Возвращает значение, в котором установлен только самый младший бит, установленный в 1 в бинарном представлении числа. Все остальные биты устанавливаются в 0. Находит самый младший бит, установленный в 1, и устанавливает только этот бит в результирующее значение, в то время как все остальные биты устанавливаются в 0.

fun main() {
    val a = 42 // Бинарное представление: 0010 1010
    val result = a.takeLowestOneBit() // 0000 0010 (2 в десятичной системе)

    println(result) // Выведет: 2
}

Используется для побитового циклического сдвига (или вращения) чисел влево. Это означает, что биты числа сдвигаются влево на указанное количество позиций, а биты, вышедшие за пределы числа, переносятся в начало. Сдвигает биты числа влево на указанное количество позиций. Биты, которые “выпадают” за левую границу, возвращаются в начало числа с правой стороны.

fun main() {
    val a = 9 // Бинарное представление: 0000 1001
    val result = a.rotateLeft(2) // 0010 0100 (36 в десятичной системе)

    println(result) // Выведет: 36
}

Используется для побитового циклического сдвига (или вращения) чисел вправо. Это означает, что биты числа сдвигаются вправо на указанное количество позиций, а биты, которые «выпадают» с правой стороны, переносятся в начало числа. Сдвигает биты числа вправо на указанное количество позиций. Биты, которые «выпадают» за правую границу, возвращаются в начало числа с левой стороны.

fun main() {
    val a = 36 // Бинарное представление: 0010 0100
    val result = a.rotateRight(2) // 0000 1001 (9 в десятичной системе)

    println(result) // Выведет: 9
}

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

• Добавить логику при доступе к переменной

var age: Int = 25
    get() {
        println("Геттер вызывается")
        return field
    }

• Использовать field

var name: String = "John"
    get() {
        return field.toUpperCase()
    } 

• Свойства val

val birthYear: Int = 1990
    get() = field + 1

• Переопределение геттера в производном классе

open class User {
    open val age: Int = 25
}

class AdultUser : User() {
    override val age: Int
        get() = super.age + 10
}

• Определение геттера в интерфейсе

interface Person {
    val age: Int
        get() = 18
}

• Применение геттера с Backing Field

// Применение геттеров с Backing Field
class User {
    private var _name: String? = null
    val name: String
        get() = _name ?: "No name provided"
}

Метод, который вызывается при присваивании значения свойству. В Kotlin сеттеры создаются по умолчанию только для изменяемых свойств (var).

• Логика при присвоении значения переменной

var age: Int = 25
    set(value) {
        println("Сеттер вызывается")
        field = value
    }

• Использование field

var age: Int = 25
    set(value) {
        field = value // `field` ссылается на свойство `age`
    }

• Валидация данных в сеттере

var age: Int = 25
    set(value) {
        if (value >= 0) {
            field = value
        } else {
            println("Возраст не может быть отрицательным")
        }
    }

• Переопределение сеттера в производном классе

open class User {
    open var age: Int = 25
}

class AdultUser: User() {
    override var age: Int = 30
        set(value) {
            if (value >= 18) {
                field = value
            } else {
                println("Возраст должен быть не меньше 18")
            }
        }
}

• Определение сеттера в интерфейсе

interface Person {
    var age: Int
        set(value) // Интерфейс определяет, что должно быть свойство с сеттером
}

class User : Person {
    override var age: Int = 18
        set(value) {
            field = value
        }
}

• Применение сеттеров с Backing Field

class User {
    private var _name: String = "John"
    var name: String
        get() = _name
        set(value) {
            _name = value.trim() // Устанавливаем значение, предварительно удалив лишние пробелы
        }
}

Используется внутри геттеров и сеттеров для обращения к свойству класса. Оно представляет бэкэнд-поле свойства, которое используется для хранения значения.

class Product {
    var price: Double = 0.0
        get() = field * 1.2 // Добавляем наценку 20%
}

fun main() {
    val product = Product()
    product.price = 100.0
    println(product.price) // Выведет: 120.0
}

Корневой класс всех исключений и ошибок в Kotlin (как и в Java). Он разделяется на два подкласса: Error и Exception.

Throwable
├── Error
│   ├── StackOverflowError
│   └── OutOfMemoryError
│
└── Exception
    ├── RuntimeException
    │   ├── NullPointerException
    │   ├── IllegalArgumentException
    │   └── IndexOutOfBoundsException
    ├── IOException
    └── SQLException

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

• Требует обязательного наличия блоков catch или finally.

try {
    val result = 10 / 0
} catch (e: ArithmeticException) {
    println("Ошибка деления на ноль")
} finally {
    println("Завершение операции")
}

try {
    val result = 10 / 0
} catch (e: ArithmeticException) {
    println("Ошибка деления на ноль")
}

try {
    val result = 10 / 5
} finally {
    println("Завершение операции")
}

Перехватывает исключения, возникшие внутри try. В catch можно указать конкретный тип исключения, который нужно обработать, или использовать общий тип Exception.

• Можно указать сколько угодно блоков catch.

try {
    val numbers = listOf(1, 2, 3)
    println(numbers[5]) // IndexOutOfBoundsException
    val result = 10 / 0 // ArithmeticException
} catch (e: ArithmeticException) {
    println("Ошибка: деление на ноль.")
} catch (e: IndexOutOfBoundsException) {
    println("Ошибка: индекс вне границ списка.")
} catch (e: Exception) {
    println("Произошло общее исключение: ${e.message}")
}

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

var inputStream: FileInputStream? = null
try {
    inputStream = FileInputStream(fileName)
    inputStream.readBytes()
} catch (e: IOException) {
    println("Ошибка")
} finally {
    inputStream?.close()
}

Используется для явного выбрасывания исключения. Оно позволяет создать и бросить экземпляр класса исключения, что приводит к немедленному прерыванию выполнения текущего блока кода и передаче управления ближайшему блоку catch, если он существует. Имеет тип Nothing.

fun validateAge(age: Int) {
    if (age < 18) {
        throw IllegalArgumentException("Возраст должен быть не меньше 18")
    }
}

Используется для явного указания на то, какие исключения могут быть выброшены из функции. Это особенно полезно при работе с Java-кодом, поскольку в Java существуют проверяемые исключения, которые требуют обработки или явного указания в сигнатуре метода. Можно указать одно или несколько исключений, которые могут возникнуть при выполнении функции. Когда такая функция вызывается из Java-кода, IDE и компиляторы будут предупреждать, если это исключение не обрабатывается. Аннотация @Throws не является обязательной в Kotlin, так как языковые конструкции уже позволяют обрабатывать исключения. Однако она полезна для обеспечения совместимости с Java.

@Throws(IllegalArgumentException::class)
fun validateAge(age: Int) {
    if (age < 18) {
        throw IllegalArgumentException("Возраст должен быть не меньше 18")
    }
}

Используется для проверки типа объекта во время выполнения. Позволяет проверить, соответствует ли объект определенному типу.

if (obj is SomeType) {
    // Действия, если obj является экземпляром SomeType
}

!is

Противоположный оператор, который проверяет, не является ли объект указанным типом.

fun checkNotString(obj: Any) {
    if (obj !is String) {
        println("This is not a String")
    } else {
        println("This is a String of length ${obj.length}")
    }
}

fun main() {
    checkNotString(100)     // Выведет: This is not a String
    checkNotString("Hello") // Выведет: This is a String of length 5
}

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

val obj: Any = "Hello, Kotlin"
val str: String = obj as String // Приведение типа к String

as?

Безопасное приведение типа.

val obj: Any = 123
val str: String? = obj as? String // Попытка приведения типа к String

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

annotation class Info(val author: String, val version: Int)

@Info(author = "John", version = 1)
class Example

Делает методы или свойства компаньон-объекта или объекта синглтона доступными как статические методы или свойства в Java.

// В Java это будет доступно как MyClass.staticMethod().

class MyClass {
    companion object {
        @JvmStatic
        fun staticMethod() {
            // ...
        }
    }
}

Генерирует перегруженные версии функции с параметрами по умолчанию для Java. Это позволяет вызывать функцию из Java без указания всех аргументов, которые имеют значения по умолчанию.

// В Java будут созданы перегруженные методы greet(String) и greet(String, int).

class MyClass {
    @JvmOverloads
    fun greet(message: String, times: Int = 1) {
        // ...
    }
}

Делает свойство публичным полем в Java, а не геттером/сеттером.

// В Java это будет доступно как myClass.someValue вместо myClass.getSomeValue().

class MyClass {
    @JvmField
    val someValue: Int = 42
}

Используется для объявлений класса, который будет компилироваться как «вложенный» inline-класс. Это позволяет уменьшить накладные расходы на создание экземпляров классов и улучшить производительность.

// В Java это будет представлено как обычный тип (например, int), что может улучшить производительность за счет уменьшения накладных расходов.

@JvmInline
value class MyValue(val value: Int)

Позволяет изменить имя класса, метода или свойства, видимое в Java. Это полезно для избежания конфликтов имен.

// В Java это будет доступно как renamedFunction().

@JvmName("renamedFunction")
fun myFunction() {
    // ...
}

Прячет методы или свойства от Java-кода. Это позволяет скрыть их от Java, делая их доступными только в Kotlin.

class MyClass {
    @JvmSynthetic
    fun hiddenMethod() {
        // ...
    }
}

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

interface MyInterface {
    @JvmDefault
    fun defaultMethod() {
        // ...
    }
}

Используется для создания и запуска нового потока. Он является удобной оберткой над классом Thread, позволяя вам легко создавать потоки с минимальными усилиями. Метод позволяет задавать параметры, такие как name, start, daemon, и contextClassLoader, чтобы настроить новый поток.

fun main() {
    thread {
        // Код выполняется в новом потоке
        println("Running in a separate thread")
    }
    println("Running in the main thread")
}

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

// В этом примере методы increment и getCount синхронизированы, что обеспечивает корректное обновление и чтение значения count из разных потоков.

class Counter {
    private var count = 0

    @Synchronized
    fun increment() {
        count++
    }

    @Synchronized
    fun getCount(): Int {
        return count
    }
}

var value: Int = 0
    @Synchronized get() = 5
    @Synchronized set(value) { field = value }

Функция для проверки аргументов.
Принимает параметры:
value и lazyMessage.
Если
value = false, то функция вернет IllegalArgumentException с сообщением lazyMessage.

Можно передать только value тогда текст ошибки будет стандартным: Failed requirement.

fun printPositiveNumber(num: Int) {
    require(num > 0)
    println(num)
}

fun printPositiveNumber(num: Int) {
    require(num > 0) { "Number must be positive" }
    println(num)
}

Функция для проверки аргумента на null.
Принимает параметры:
value и lazyMessage.
Если value = null, то функция вернет
IllegalArgumentException с сообщением lazyMessage.
Можно передать только
value тогда текст ошибки будет стандартным: ‎Required value was null.

private val _numberFlow = MutableStateFlow(0)
val numberFlow = _numberFlow.asStateFlow()

val number = requireNotNull(numberFlow.value)

Функция для проверки состояния.
Принимает параметры:
value и lazyMessage.
Если
value = false, то функция вернет IllegalStateException с сообщением переданным в lazyMessage.

Можно передать только value тогда текст ошибки будет стандартным: Check failed.

var someState: String = ""
val state = check(someState) { "State must be not empty" }

Функция для проверки состояние на null.
Принимает параметры:
value и lazyMessage.
Если value = null, то функция вернет
IllegalStateException с сообщением lazyMessage.
Можно передать только
value тогда текст ошибки будет стандартным: Required value was null.

var someState: String? = null
val state = checkNotNull(someState) { "State must be not null" }

Функция для намеренного вызова исключения в коде. Выдаст IllegalStateException.

fun divide(a: Int, b: Int): Int {
    if (b == 0) {
        error("Cannot divide by zero")
    }
    return a / b
}

Kotlin предоставляет мощные функции, такие как функции расширения, лямбды с приемником, именованные аргументы, что делает возможным создание удобных DSL.

fun String.hasLength(length: Int) = this.length == length

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

class HtmlTag(val name: String) {
    fun render() = "<$name></$name>"
}

fun html(init: HtmlTag.() -> Unit): HtmlTag {
    val tag = HtmlTag("html")
    tag.init()
    return tag
}

val result = html {
    // Внутри этой лямбды мы можем вызывать методы HtmlTag напрямую
}

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

fun buildHouse(floors: Int = 2, color: String = "White") {
    println("House with $floors floors and $color color")
}

buildHouse(floors = 3, color = "Blue")