Kotlin Academy · Aula

Classes Locais

Classes dentro de funções

Classes Locais é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Classes em funções

A linguagem Kotlin permite declarar uma classe local dentro do corpo de uma função. Ela fica visível somente dentro dessa função.

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

Limitada ao escopo da função

Uma classe local não pode ser usada fora da função em que foi declarada, mantendo os tipos auxiliares bem contidos.

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

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

Capturando variáveis locais

Assim como os fechamentos, as classes locais podem capturar variáveis da função que as contém.

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

Várias instâncias

É possível criar quantas instâncias de uma classe local forem necessárias dentro da função.

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

Classe local com métodos

Classes locais são classes completas: construtores, propriedades e métodos funcionam normalmente.

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

Por que usar uma classe local

Use uma quando um tipo auxiliar só tiver significado dentro de uma única função, evitando poluir o arquivo com tipos de nível superior.

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"))
}

Capturando estado mutável

Uma classe local pode modificar variáveis mutáveis capturadas do escopo que a contém.

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

Implementando interfaces localmente

Classes locais podem implementar interfaces, o que é útil quando você precisa de uma implementação nomeada e reutilizável dentro de uma única função.

interface Step { fun run(): String }

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

Local versus anônima

Escolha uma classe local quando precisar de um nome, para criar várias instâncias ou fazer referência ao tipo. Escolha um objeto anônimo para uma única instância inline.

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

Aninhamento dentro de laços

Uma classe local pode até ser declarada dentro de blocos, como laços, ficando limitada ao escopo desse bloco.

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

Um auxiliar prático

Classes locais são ideais para auxiliares de domínio de curta duração usados por exatamente uma função.

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)))
}

Teste rápido

Teste sua compreensão sobre classes locais.

Recapitulação

Você aprendeu sobre classes locais:

Declaradas dentro de uma função e limitadas ao escopo dela.
Podem capturar e modificar variáveis locais do contexto que as contém.
São classes completas: têm construtores, propriedades, métodos e interfaces.
Use uma classe local quando precisar de um nome; use um objeto anônimo para uma única instância inline.

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

Perguntas Frequentes

A aula “Classes Locais” é grátis?

Sim — o texto completo de “Classes Locais” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Classes Locais”?

Classes dentro de funções Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Classes Locais”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy