Kotlin Academy · Aula

Objetos Anônimos

Implementações em linha

Objetos Anônimos é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 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.

Implementações inline

Um objeto anônimo cria uma instância de uma classe ou interface sem nomear uma nova classe. Use a expressão object.

interface Greeter { fun greet(): String }

fun main() {
    val g = object : Greeter {
        override fun greet() = "Hi"
    }
    println(g.greet())
}

Implementando uma interface

Uma expressão de objeto pode implementar uma ou mais interfaces exatamente no local em que é necessária.

interface Clickable { fun click() }

fun main() {
    val button = object : Clickable {
        override fun click() = println("Clicked")
    }
    button.click()
}

Substituindo membros de uma classe

É possível criar anonimamente uma subclasse de uma classe aberta e substituir seus membros.

open class Animal { open fun sound() = "..." }

fun main() {
    val cat = object : Animal() {
        override fun sound() = "Meow"
    }
    println(cat.sound())
}

Mantendo estado adicional

Um objeto anônimo pode declarar suas próprias propriedades além dos membros que substitui.

fun main() {
    val point = object {
        val x = 3
        val y = 4
    }
    println("${point.x}, ${point.y}")
}

Objeto sem supertipo

Se você omitir um supertipo, o objeto será apenas um conjunto ad hoc de membros, útil para um agrupamento local rápido.

fun main() {
    val config = object {
        val retries = 3
        val timeout = 30
    }
    println(config.retries)
}

Capturando variáveis locais

Objetos anônimos podem capturar variáveis do escopo que os contém, ao contrário de classes aninhadas semelhantes a estáticas.

fun makeCounter(start: Int): () -> Int {
    var count = start
    val obj = object {
        fun next() = count++
    }
    return { obj.next() }
}

fun main() {
    val c = makeCounter(10)
    println(c())
    println(c())
}

Como ouvinte

Um uso comum é passar uma implementação inline como retorno de chamada ou ouvinte.

interface OnDone { fun done(result: Int) }

fun compute(cb: OnDone) {
    cb.done(42)
}

fun main() {
    compute(object : OnDone {
        override fun done(result: Int) = println("Got $result")
    })
}

Tipo de um objeto anônimo

Quando retornado por uma função, o tipo inferido é o supertipo declarado ou um tipo genérico, caso não haja nenhum. Membros adicionais ficam visíveis apenas localmente.

interface Named { val name: String }

fun make(): Named = object : Named {
    override val name = "X"
}

fun main() {
    println(make().name)
}

Objetos anônimos versus funções lambda

Para interfaces com um único método, uma função lambda é mais curta, mas objetos anônimos são necessários quando é preciso substituir vários membros ou manter estado.

interface Handler {
    fun onStart()
    fun onStop()
}

fun main() {
    val h = object : Handler {
        override fun onStart() = println("start")
        override fun onStop() = println("stop")
    }
    h.onStart()
    h.onStop()
}

Expressão de objeto versus declaração de objeto

Uma expressão de objeto cria uma nova instância a cada vez. Uma declaração de objeto (object Name {}) é um singleton nomeado. Elas parecem semelhantes, mas diferem no ciclo de vida.

object Singleton { val id = 1 }

fun main() {
    val fresh = object { val id = 2 }
    println(Singleton.id)
    println(fresh.id)
}

Um comparador compacto

Objetos anônimos são úteis para comparadores ou estratégias usados uma única vez.

fun main() {
    val cmp = object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    }
    val list = listOf(1, 3, 2).sortedWith(cmp)
    println(list)
}

Teste rápido

Teste sua compreensão sobre objetos anônimos.

Recapitulação

Você aprendeu sobre objetos anônimos:

A expressão object : Type {} cria uma instância sem nome.
Eles podem implementar interfaces, criar subclasses de classes abertas e manter estado.
Eles capturam variáveis locais do contexto que os contém.
Use-os para retornos de chamada com vários métodos; prefira funções lambda para métodos únicos.

interface Run { fun go() }

fun main() {
    val r = object : Run { override fun go() = println("go") }
    r.go()
}

Perguntas Frequentes

A aula “Objetos Anônimos” é grátis?

Sim — o texto completo de “Objetos Anônimos” é 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 “Objetos Anônimos”?

Implementações em linha 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 3 de 4.

Quanto tempo leva a aula “Objetos Anônimos”?

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