Kotlin Academy · Aula

Índice e Invocação

get, set e invoke

Índice e Invocação é 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.

O operador de índice

Definir operator fun get permite fazer leituras com a sintaxe de colchetes: obj[i].

class Row(val cells: List<String>) {
    operator fun get(i: Int) = cells[i]
}

fun main() {
    val r = Row(listOf("a", "b", "c"))
    println(r[1])
}

Escrevendo com atribuição por índice

operator fun set permite atribuições: obj[i] = value. O último parâmetro é o valor.

class Grid {
    private val data = IntArray(3)
    operator fun get(i: Int) = data[i]
    operator fun set(i: Int, value: Int) { data[i] = value }
}

fun main() {
    val g = Grid()
    g[0] = 42
    println(g[0])
}

Indexação com vários argumentos

get e set podem receber vários índices, o que é perfeito para matrizes.

class Matrix {
    private val d = Array(2) { IntArray(2) }
    operator fun get(r: Int, c: Int) = d[r][c]
    operator fun set(r: Int, c: Int, v: Int) { d[r][c] = v }
}

fun main() {
    val m = Matrix()
    m[1, 1] = 9
    println(m[1, 1])
}

Índices com chaves não inteiras

Os parâmetros de índice podem ser de qualquer tipo, permitindo um acesso semelhante ao de mapas.

class Settings {
    private val map = mutableMapOf<String, String>()
    operator fun get(key: String) = map[key]
    operator fun set(key: String, value: String) { map[key] = value }
}

fun main() {
    val s = Settings()
    s["theme"] = "dark"
    println(s["theme"])
}

O operador de chamada

Definir operator fun invoke permite chamar uma instância como uma função: obj().

class Greeter(val name: String) {
    operator fun invoke() = "Hello, $name"
}

fun main() {
    val g = Greeter("Sam")
    println(g())
}

Chamada com argumentos

invoke pode receber parâmetros, fazendo o objeto se comportar como uma função parametrizada.

class Multiplier(val factor: Int) {
    operator fun invoke(x: Int) = x * factor
}

fun main() {
    val triple = Multiplier(3)
    println(triple(5))
}

Objetos chamáveis com estado

Como o objeto mantém estado, invoke pode criar objetos configuráveis semelhantes a funções.

class Accumulator {
    var total = 0
    operator fun invoke(n: Int) { total += n }
}

fun main() {
    val acc = Accumulator()
    acc(5)
    acc(10)
    println(acc.total)
}

Múltiplas sobrecargas de invocação

Você pode declarar várias sobrecargas de invoke com parâmetros diferentes.

class Printer {
    operator fun invoke(s: String) = println(s)
    operator fun invoke(n: Int) = println("num: $n")
}

fun main() {
    val p = Printer()
    p("hi")
    p(7)
}

Índice em expressões

O acesso por índice combina naturalmente com outras operações.

class Scores(private val list: List<Int>) {
    operator fun get(i: Int) = list[i]
}

fun main() {
    val s = Scores(listOf(10, 20, 30))
    println(s[0] + s[2])
}

Combinando get e invoke

Um tipo pode oferecer suporte tanto à indexação quanto à chamada, criando uma API expressiva.

class Lookup(private val data: Map<String, Int>) {
    operator fun get(key: String) = data[key]
    operator fun invoke() = data.size
}

fun main() {
    val l = Lookup(mapOf("a" to 1))
    println(l["a"])
    println(l())
}

Como a biblioteca padrão usa isso

As operações list[i] das listas e map[key] dos mapas são exatamente esses operadores. Seus tipos também podem parecer igualmente naturais.

fun main() {
    val list = listOf(1, 2, 3)
    val map = mapOf("x" to 9)
    println(list[0])
    println(map["x"])
}

Verificação rápida

Teste sua compreensão sobre índice e invocação.

Recapitulação

Você aprendeu sobre índice e invocação:

get implementa obj[i]; set implementa obj[i] = v.
Os operadores de índice aceitam várias chaves e chaves que não são do tipo Int.
invoke permite chamar instâncias como funções, com ou sem argumentos.
As coleções padrão usam exatamente esses operadores.

class Box {
    private val m = mutableMapOf<String, Int>()
    operator fun get(k: String) = m[k]
    operator fun set(k: String, v: Int) { m[k] = v }
}

fun main() {
    val b = Box()
    b["x"] = 5
    println(b["x"])
}

Perguntas Frequentes

A aula “Índice e Invocação” é grátis?

Sim — o texto completo de “Índice e Invocação” é 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 “Índice e Invocação”?

get, set e invoke 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 “Índice e Invocação”?

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