Android Academy · Aula

Funções e Lambdas

Defina funções com parâmetros e tipos de retorno, use argumentos padrão e nomeados e escreva expressões lambda concisas.

Funções e Lambdas é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 2 de 3. 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 3 aulas no total.

Por que usar funções?

As funções permitem escrever um bloco de código uma vez e reutilizá-lo em qualquer lugar.

Reduzem a duplicação
Tornam o código mais fácil de ler e testar
Dividem problemas grandes em partes menores

No Kotlin, as funções são elementos de primeira classe — o senhor ou a senhora pode armazená-las em variáveis e passá-las adiante.

Sintaxe básica de funções

Uma função Kotlin usa a palavra-chave fun:

fun greet(name: String): String {
    return "Hello, $name!"
}

fun main() {
    val msg = greet("Alice")
    println(msg)  // Hello, Alice!

    println(greet("Bob"))  // Hello, Bob!
}

Funções de expressão única

Quando o corpo de uma função é uma única expressão, o senhor ou a senhora pode usar = e omitir as chaves e return:

fun square(n: Int): Int = n * n

fun add(a: Int, b: Int) = a + b  // type inferred

fun main() {
    println(square(5))   // 25
    println(add(3, 7))   // 10
}

Argumentos padrão e nomeados

As funções Kotlin aceitam valores padrão para parâmetros — não é necessário criar sobrecargas:

Padrão: fun greet(name: String = "World")
Nomeado: chame com greet(name = "Alice") para não depender da ordem posicional

Padrão e nomeados em ação

Os argumentos padrão mantêm sua API organizada:

fun buildProfile(
    name: String,
    age: Int = 0,
    role: String = "User"
): String {
    return "$name | age=$age | $role"
}

fun main() {
    println(buildProfile("Alice"))
    println(buildProfile("Bob", age = 30))
    println(buildProfile("Carol", 25, "Admin"))
}

O que são lambdas?

Uma lambda é uma função anônima — uma função sem nome.

Sintaxe: { params -> body }
Armazenada em uma variável: val double = { x: Int -> x * 2 }
Passada para outra função como argumento

As lambdas estão por toda parte no Android: ouvintes de cliques, transformações de listas e corrotinas.

Exemplos de lambdas

Armazene e chame lambdas como faria com funções comuns:

fun main() {
    val double = { x: Int -> x * 2 }
    println(double(4))   // 8

    val add = { a: Int, b: Int -> a + b }
    println(add(3, 5))   // 8

    // Lambda with no params
    val sayHi = { println("Hi!") }
    sayHi()              // Hi!
}

Funções de ordem superior

Uma função de ordem superior recebe outra função como parâmetro ou retorna uma função.

A biblioteca padrão do Kotlin está repleta delas: filter, map, forEach.

Sintaxe de lambda à direita: quando o último argumento é uma lambda, mova-a para fora dos parênteses.

Sintaxe de lambda à direita

Passe uma lambda como último argumento, fora dos parênteses:

fun applyTwice(n: Int, operation: (Int) -> Int): Int {
    return operation(operation(n))
}

fun main() {
    val result = applyTwice(3) { x -> x * 2 }
    println(result)  // 12  (3 * 2 = 6, 6 * 2 = 12)

    // 'it' is the implicit single parameter
    val doubled = applyTwice(5) { it + it }
    println(doubled) // 20
}

Verificação rápida

Observe este código. O que ele imprimirá?

val triple = { x: Int -> x * 3 } println(triple(4))

Recapitulação: funções e lambdas

O senhor ou a senhora aprendeu:

fun define uma função com parâmetros e tipo de retorno
Funções de expressão única usam a abreviação =
Argumentos padrão e nomeados substituem sobrecargas
Lambdas são funções anônimas: { params -> body }
Funções de ordem superior aceitam funções como parâmetros

A seguir: controlando o fluxo do programa com condições e laços.

Perguntas Frequentes

A aula “Funções e Lambdas” é grátis?

Sim — o texto completo de “Funções e Lambdas” é 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 3 aulas no total.

O que vou aprender em “Funções e Lambdas”?

Defina funções com parâmetros e tipos de retorno, use argumentos padrão e nomeados e escreva expressões lambda concisas. 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 2 de 3.

Quanto tempo leva a aula “Funções e Lambdas”?

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

← Voltar para Android Academy