0Pricing
Kotlin Academy · Aula

Objetos anônimos e expressões de objeto

Use expressões de objeto para criar implementações pontuais de interfaces.

Objetos anônimos e expressões de objeto é 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.

Expressões de objeto

Uma expressão de objeto cria uma instância anônima e única de uma classe ou interface — o equivalente do Kotlin às classes internas anônimas do Java, mas com mais recursos.

Implementando uma interface anonimamente

Use object : Interface { ... } para criar uma implementação embutida.

interface ClickListener {
    fun onClick(): String
}
fun main() {
    val listener = object : ClickListener {
        override fun onClick() = "clicked!"
    }
    println(listener.onClick())
}

Classe anônima com estado

Objetos anônimos podem manter estado e ter vários métodos.

fun main() {
    val counter = object {
        var count = 0
        fun inc() { count++ }
        fun show() = println("count = $count")
    }
    counter.inc(); counter.inc(); counter.inc()
    counter.show()
}

Tipo do objeto anônimo

O tipo de um objeto anônimo é inferido. Quando declarado no nível da função, você mantém acesso aos seus membros personalizados.

fun main() {
    val pair = object {
        val left = "L"
        val right = "R"
    }
    println("${pair.left} and ${pair.right}")
}

Exposição do tipo anônimo

Se um objeto anônimo for retornado por uma função com tipo inferido, os chamadores verão apenas o supertipo — os acréscimos do objeto anônimo ficarão inacessíveis externamente.

fun makeListener() = object {
    fun greet() = "hello"
}
fun main() {
    val l = makeListener()
    println(l.greet()) // OK — same compilation unit
}

Múltiplas interfaces

Um objeto anônimo pode implementar várias interfaces em uma única expressão.

interface Closeable { fun close() }
interface Flushable { fun flush() }
fun main() {
    val resource = object : Closeable, Flushable {
        override fun close() = println("closed")
        override fun flush() = println("flushed")
    }
    resource.flush()
    resource.close()
}

Estendendo uma classe

Objetos anônimos podem estender uma classe aberta enquanto substituem membros.

open class Animal(val name: String) {
    open fun speak() = "$name makes a sound"
}
fun main() {
    val pet = object : Animal("Rex") {
        override fun speak() = "$name barks!"
    }
    println(pet.speak())
}

Capturando variáveis do escopo externo

Objetos anônimos fecham sobre variáveis no escopo externo — podem lê-las e modificá-las —, ao contrário do requisito de final do Java.

fun main() {
    var log = mutableListOf<String>()
    val recorder = object {
        fun record(s: String) { log.add(s) }
    }
    recorder.record("event 1")
    recorder.record("event 2")
    println(log)
}

Quando usar objetos anônimos

Use objetos anônimos para implementações únicas que não justificam uma classe própria — normalmente retornos de chamada, ouvintes e comparadores.

fun main() {
    val nums = listOf(3, 1, 4, 1, 5, 9, 2, 6)
    val sorted = nums.sortedWith(object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a // descending
    })
    println(sorted)
}

Prefira expressões lambda quando possível

Se a interface tiver um único método abstrato (SAM), uma expressão lambda será mais simples que uma expressão de objeto.

fun main() {
    val nums = listOf(3, 1, 4, 1, 5, 9)
    // Old way:
    val sorted1 = nums.sortedWith(object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    })
    // New way — SAM conversion:
    val sorted2 = nums.sortedWith(Comparator { a, b -> b - a })
    println("$sorted1 / $sorted2")
}

Objeto anônimo versus declarado

Use object Name para um singleton nomeado. Use object : Type em uma expressão para uma instância anônima única.

// Named singleton (one instance, accessed globally)
object GlobalLogger { fun log(m: String) = println("[L] $m") }
// Anonymous (created at expression evaluation)
fun main() {
    val local = object { fun hi() = "hi" }
    GlobalLogger.log("hello")
    println(local.hi())
}

Verificação rápida

Qual sintaxe cria uma instância anônima que implementa uma interface de forma embutida?

Recapitulação

Expressões de objeto criam instâncias anônimas únicas de forma embutida. Elas podem implementar interfaces, estender classes, manter estado e fechar sobre variáveis do escopo externo. Prefira expressões lambda para interfaces de método único; use expressões de objeto quando precisar de vários métodos ou de estado.

Perguntas Frequentes

A aula “Objetos anônimos e expressões de objeto” é grátis?

Sim — o texto completo de “Objetos anônimos e expressões de objeto” é 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 e expressões de objeto”?

Use expressões de objeto para criar implementações pontuais de interfaces. 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 e expressões de objeto”?

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

  1. Declaração object: singletons do Kotlin
  2. companion object: membros semelhantes a estáticos no Kotlin
  3. Objetos anônimos e expressões de objeto
  4. Métodos de fábrica com companion object
← Voltar para Kotlin Academy