Kotlin Academy · Урок

Локальные классы

Классы внутри функций

«Локальные классы» — бесплатный урок Kotlin Academy на CoddyKit. Это урок 4 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Kotlin Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Kotlin Academy содержит 4 уроков всего.

Классы внутри функций

Kotlin позволяет объявлять локальный класс внутри тела функции. Он виден только внутри этой функции.

fun main() {
    class Greeting(val text: String) {
        fun show() = println(text)
    }
    Greeting("Hello local").show()
}

Область видимости функции

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

fun build(): String {
    class Builder {
        fun make() = "built"
    }
    return Builder().make()
}

fun main() {
    println(build())
}

Захват локальных переменных

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

fun main() {
    val prefix = ">> "
    class Logger {
        fun log(msg: String) = println(prefix + msg)
    }
    Logger().log("started")
}

Несколько экземпляров

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

fun main() {
    class Point(val x: Int)
    val a = Point(1)
    val b = Point(2)
    println(a.x + b.x)
}

Локальный класс с методами

Локальные классы являются полноценными классами: для них работают конструкторы, свойства и методы.

fun main() {
    class Account(var balance: Int) {
        fun deposit(n: Int) { balance += n }
    }
    val acc = Account(100)
    acc.deposit(50)
    println(acc.balance)
}

Зачем нужен локальный класс

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

fun parseLine(line: String): Int {
    class Token(val value: String)
    val tokens = line.split(",").map { Token(it) }
    return tokens.size
}

fun main() {
    println(parseLine("a,b,c"))
}

Захват изменяемого состояния

Локальный класс может изменять захваченные изменяемые переменные из своей объемлющей области видимости.

fun main() {
    var total = 0
    class Adder {
        fun add(n: Int) { total += n }
    }
    val a = Adder()
    a.add(5)
    a.add(7)
    println(total)
}

Локальная реализация интерфейсов

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

interface Step { fun run(): String }

fun main() {
    class First : Step {
        override fun run() = "first"
    }
    println(First().run())
}

Локальный класс и анонимный объект

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

fun main() {
    class Repeater(val times: Int) {
        fun run() = "x".repeat(times)
    }
    println(Repeater(3).run())
}

Вложенность внутри циклов

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

fun main() {
    for (i in 1..2) {
        class Tag(val id: Int)
        println(Tag(i).id)
    }
}

Практический вспомогательный тип

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

fun report(values: List<Int>): String {
    class Stats(val sum: Int, val max: Int)
    val s = Stats(values.sum(), values.max())
    return "sum=${s.sum} max=${s.max}"
}

fun main() {
    println(report(listOf(3, 7, 2)))
}

Быстрая проверка

Проверьте, насколько хорошо Вы поняли локальные классы.

Итоги

Вы узнали о локальных классах:

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

fun main() {
    val tag = "L"
    class C { fun show() = tag }
    println(C().show())
}

Часто задаваемые вопросы

Урок «Локальные классы» бесплатный?

Да — полный текст урока «Локальные классы» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Kotlin Academy, подпишись на CoddyKit PRO. Курс Kotlin Academy содержит 4 уроков всего.

Чему я научусь в уроке «Локальные классы»?

Классы внутри функций Ты практикуешь Kotlin Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Kotlin Academy?

Предыдущий опыт не требуется. Kotlin Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 4 из 4.

Сколько времени занимает урок «Локальные классы»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Kotlin Academy?

Да. Каждый урок Kotlin Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к Kotlin Academy