Android Academy · Lekcja

Funkcje rozszerzające i funkcje wyższego rzędu

Funkcje rozszerzające i funkcje wyższego rzędu to bezpłatna lekcja Android Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Android Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Android Academy zawiera 4 lekcji w sumie.

Funkcje rozszerzające

Funkcja rozszerzająca pozwala dodawać nowe funkcje do istniejących klas bez modyfikowania ich i bez używania dziedziczenia. Można rozszerzać typy String, Int, własne klasy, a nawet View z Androida.

Składnia: fun TypeName.functionName() { }

Pisanie funkcji rozszerzających

Wewnątrz funkcji rozszerzającej this odwołuje się do obiektu odbiorcy:

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
}

Funkcje rozszerzające dla widoków Androida

Popularny wzorzec w Androidzie — ukrywanie i wyświetlanie widoków za pomocą rozszerzenia zamiast powtarzania kodu pomocniczego:

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()

Funkcje wyższego rzędu

Funkcja wyższego rzędu przyjmuje funkcję jako parametr lub ją zwraca. Używał(a) już Pan/Pani takich funkcji: filter, map i forEach to funkcje wyższego rzędu.

Składnia typu funkcji: (ParamType) -> ReturnType

Przekazywanie funkcji jako parametrów

Zdefiniuj funkcję, która przyjmuje inną funkcję:

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
}

Zwracanie funkcji

Funkcje mogą również zwracać inne funkcje — jest to przydatne przy tworzeniu konfigurowalnego zachowania:

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

Funkcje zakresu: let

Funkcje zakresu w języku Kotlin wykonują blok kodu dla obiektu i zwracają wynik. let służy do sprawdzania wartości null i przekształceń:

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
}

Funkcje zakresu: apply i also

apply konfiguruje obiekt i zwraca obiekt. also wykonuje efekt uboczny i zwraca obiekt:

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

Funkcje zakresu: run i with

run wykonuje blok kodu dla obiektu i zwraca wynik tego bloku. with działa podobnie, ale nie jest funkcją rozszerzającą:

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
}

Ściągawka dotycząca funkcji zakresu

Krótka instrukcja wyboru właściwej funkcji zakresu:

let — blok bezpieczny dla null, przekształca obiekt i zwraca wynik lambdy
apply — konfiguruje obiekt i zwraca obiekt (this)
also — efekty uboczne (na przykład rejestrowanie), zwraca obiekt (it)
run — oblicza wynik na podstawie obiektu i zwraca wynik lambdy
with — grupuje wywołania dla obiektu, nie jest funkcją rozszerzającą

Funkcje inline i reified

Oznacz funkcję wyższego rzędu jako inline, aby uniknąć tworzenia obiektu lambdy w czasie działania programu. reified pozwala używać generycznego typu T w czasie działania programu (który zwykle jest usuwany):

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
}

Szybki test

Która funkcja zakresu najlepiej nadaje się do skonfigurowania nowo utworzonego obiektu i zwrócenia tego samego obiektu?

Podsumowanie: rozszerzenia i funkcje wyższego rzędu

Narzędzia funkcyjne języka Kotlin są już do Państwa dyspozycji:

Funkcje rozszerzające — dodają zachowanie do dowolnego typu bez dziedziczenia
Funkcje wyższego rzędu — przekazują i zwracają funkcje, umożliwiając tworzenie elastycznych interfejsów API
Funkcje zakresu: let (sprawdzanie null), apply (konfiguracja), also (efekt uboczny), run/with (obliczenia)
inline + reified — lambdy bez dodatkowego kosztu i z informacjami o typie w czasie działania

Następnie: tworzenie aplikacji z wieloma ekranami za pomocą fragmentów.

Często zadawane pytania

Czy lekcja „Funkcje rozszerzające i funkcje wyższego rzędu” jest bezpłatna?

Tak — pełny tekst „Funkcje rozszerzające i funkcje wyższego rzędu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Android Academy, przejdź na CoddyKit PRO. Kurs Android Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Funkcje rozszerzające i funkcje wyższego rzędu”?

Proszę dodawać zachowanie do istniejących typów za pomocą funkcji rozszerzających oraz używać funkcji wyższego rzędu i funkcji zakresu (let, apply, also, run, with) do tworzenia wyrazistego kodu w Ko… Ćwiczysz Android Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Android Academy?

Nie wymagamy żadnego doświadczenia. Android Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Funkcje rozszerzające i funkcje wyższego rzędu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Android Academy?

Tak. Każda lekcja Android Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Bezpieczeństwo wartości null
Klasy i obiekty
Klasy danych i klasy zapieczętowane
Funkcje rozszerzające i funkcje wyższego rzędu

← Powrót do Android Academy