Android Academy · Lesson

Functions & Lambdas

Define functions with parameters and return types, use default and named arguments, and write concise lambda expressions.

Lesson 2 of 311 steps

Functions & Lambdas is a free Android Academy lesson on CoddyKit. This is lesson 2 of 3. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Android Academy learning path, and your progress syncs across the web and the CoddyKit app. The Android Academy course includes 3 lessons in total.

Why Functions?

Functions let you write a block of code once and reuse it anywhere.

Reduce duplication
Make code easier to read and test
Break big problems into smaller pieces

In Kotlin, functions are first-class — you can store them in variables and pass them around.

Basic Function Syntax

A Kotlin function uses the fun keyword:

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

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

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

Single-Expression Functions

When a function body is a single expression, you can use = and skip the braces and 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
}

Default & Named Arguments

Kotlin functions support default parameter values — no need for overloads:

Default: fun greet(name: String = "World")
Named: call with greet(name = "Alice") to skip positional order

Default & Named in Action

Default arguments keep your API clean:

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"))
}

What Are Lambdas?

A lambda is an anonymous function — a function without a name.

Syntax: { params -> body }
Stored in a variable: val double = { x: Int -> x * 2 }
Passed to another function as an argument

Lambdas are everywhere in Android: click listeners, list transformations, coroutines.

Lambda Examples

Store and call lambdas just like regular functions:

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!
}

Higher-Order Functions

A higher-order function takes another function as a parameter or returns one.

The Kotlin standard library is full of them: filter, map, forEach.

Trailing lambda syntax: when the last argument is a lambda, move it outside the parentheses.

Trailing Lambda Syntax

Pass a lambda as the last argument outside the parentheses:

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
}

Quick Check

Look at this code. What will it print?

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

Answer it in the interactive lesson

Recap: Functions & Lambdas

You've learned:

fun defines a function with params and return type
Single-expression functions use = shorthand
Default and named arguments replace overloads
Lambdas are anonymous functions: { params -> body }
Higher-order functions accept functions as parameters

Next: controlling program flow with conditions and loops.

Free to start

Learn Kotlin with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 36
Lessons: 152

Start learning free View the full course

Frequently Asked Questions

Is the “Functions & Lambdas” lesson free?

Yes — any 3 lessons of the Android Academy learning path, including “Functions & Lambdas”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Android Academy course includes 3 lessons in total.

What will I learn in “Functions & Lambdas”?

Define functions with parameters and return types, use default and named arguments, and write concise lambda expressions. You practise Android Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Android Academy?

No prior experience is required. Android Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 3.

How long does the “Functions & Lambdas” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Android Academy lesson?

Yes. Every Android Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Android Academy