Android Academy · Aula

Funções de Extensão e Funções de Ordem Superior

Adicione comportamento a tipos existentes com funções de extensão e use funções de ordem superior e funções de escopo (let, apply, also, run, with) para escrever código Kotlin expressivo.

Funções de Extensão e Funções de Ordem Superior é uma aula grátis de Android 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 Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

Funções de extensão

Uma função de extensão permite adicionar novas funções a classes existentes sem modificá-las nem usar herança. Você pode estender String, Int, suas próprias classes ou até mesmo a View do Android.

Sintaxe: fun TypeName.functionName() { }

Escrevendo funções de extensão

Dentro de uma função de extensão, this faz referência ao objeto receptor:

fun String.isPalindrome(): Boolean {
    val cleaned = this.lowercase().filter { it.isLetter() }
    return cleaned == cleaned.reversed()
}

fun Int.isEven() = this % 2 == 0

fun main() {
    println("racecar".isPalindrome())  // true
    println("hello".isPalindrome())    // false
    println(4.isEven())                // true
    println(7.isEven())                // false
}

Funções de extensão em Views do Android

Padrão comum do Android — oculte ou exiba views com uma extensão em vez de repetir código repetitivo:

import android.view.View

fun View.show() { visibility = View.VISIBLE }
fun View.hide() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }

// Usage in Activity:
// binding.progressBar.show()
// binding.recyclerView.hide()

Funções de ordem superior

Uma função de ordem superior recebe uma função como parâmetro ou retorna uma função. Você já as utilizou: filter, map e forEach são todas funções de ordem superior.

Sintaxe do tipo de função: (ParamType) -> ReturnType

Passando funções como parâmetros

Defina uma função que aceite outra função:

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum  = operate(3, 4) { x, y -> x + y }
    val prod = operate(3, 4) { x, y -> x * y }
    val max  = operate(3, 4, ::maxOf)   // method reference

    println(sum)   // 7
    println(prod)  // 12
    println(max)   // 4
}

Retornando funções

As funções também podem retornar outras funções — isso é útil para criar comportamentos configuráveis:

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)

    println(double(5))   // 10
    println(triple(5))   // 15

    val numbers = listOf(1, 2, 3, 4)
    println(numbers.map(double))  // [2, 4, 6, 8]
}

Funções de escopo: let

As funções de escopo do Kotlin executam um bloco em um objeto e retornam um resultado. let é usado para verificações de nulos e transformações:

fun main() {
    val name: String? = "Alice"

    // Only runs if name is not null
    name?.let {
        println("Name length: ${it.length}")
        println("Upper: ${it.uppercase()}")
    }

    // Transform a value
    val length = name?.let { it.length } ?: 0
    println("Length: $length")  // 5
}

Funções de escopo: apply e also

apply configura um objeto e retorna o objeto. also executa um efeito colateral e retorna o objeto:

data class Config(var host: String = "", var port: Int = 0, var timeout: Int = 0)

fun main() {
    // apply: configure an object (this = receiver)
    val config = Config().apply {
        host = "api.example.com"
        port = 443
        timeout = 30
    }
    println(config)  // Config(host=api.example.com, port=443, timeout=30)

    // also: log or debug (it = receiver)
    val result = listOf(1, 2, 3)
        .also { println("Original: $it") }
        .map { it * 2 }
        .also { println("Doubled: $it") }
}

Funções de escopo: run e with

run executa um bloco em um objeto e retorna o resultado do bloco. with é semelhante, mas não é uma extensão:

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Bob", 30)

    // run: compute something using the object
    val greeting = user.run {
        if (age >= 18) "Hello, $name!" else "Hi, $name!"
    }
    println(greeting)  // Hello, Bob!

    // with: group operations on an object
    val info = with(user) {
        "Name: $name, Age: $age"
    }
    println(info)  // Name: Bob, Age: 30
}

Tabela de referência das funções de escopo

Referência rápida para escolher a função de escopo correta:

let — bloco seguro para nulos, transforma o objeto e retorna o resultado da expressão lambda
apply — configura o objeto e retorna o objeto (this)
also — efeitos colaterais (registro de eventos) e retorna o objeto (it)
run — calcula um resultado a partir do objeto e retorna o resultado da expressão lambda
with — agrupa chamadas em um objeto; não é uma extensão

Funções inline e reified

Marque uma função de ordem superior como inline para evitar a alocação de um objeto lambda durante a execução. reified permite usar o tipo genérico T durante a execução (normalmente apagado):

inline fun <reified T> Any.isOfType(): Boolean = this is T

fun main() {
    println("hello".isOfType<String>())   // true
    println(42.isOfType<String>())         // false
    println(3.14.isOfType<Double>())       // true
}

Verificação rápida

Qual função de escopo é melhor para configurar um objeto recém-criado e retornar esse mesmo objeto?

Recapitulação: extensões e funções de ordem superior

Agora o conjunto de ferramentas funcionais do Kotlin está à sua disposição:

Funções de extensão — adicionam comportamento a qualquer tipo sem herança
Funções de ordem superior — passam e retornam funções para APIs flexíveis
Funções de escopo: let (verificação de nulos), apply (configuração), also (efeito colateral), run/with (cálculo)
inline + reified — lambdas sem custo adicional, com informações de tipo em tempo de execução

A seguir: crie aplicativos com várias telas usando Fragmentos.

Perguntas Frequentes

A aula “Funções de Extensão e Funções de Ordem Superior” é grátis?

Sim — o texto completo de “Funções de Extensão e Funções de Ordem Superior” é 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 Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Funções de Extensão e Funções de Ordem Superior”?

Adicione comportamento a tipos existentes com funções de extensão e use funções de ordem superior e funções de escopo (let, apply, also, run, with) para escrever código Kotlin expressivo. Você pratica Android 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 Android Academy?

Nenhuma experiência prévia é necessária. Android 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 “Funções de Extensão e Funções de Ordem Superior”?

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 Android Academy?

Sim. Cada aula de Android 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

Segurança contra Nulos
Classes e Objetos
Classes de Dados e Classes Seladas
Funções de Extensão e Funções de Ordem Superior

← Voltar para Android Academy