Ta strona została przetłumaczona przez Cloud Translation API.

Kotlin Bootcamp for Programmers 6: Functional manipulation

Te warsztaty są częścią kursu Kotlin Bootcamp for Programmers. Najwięcej korzyści przyniesie Ci ukończenie wszystkich ćwiczeń w kolejności. W zależności od swojej wiedzy możesz pominąć niektóre sekcje. Ten kurs jest przeznaczony dla programistów, którzy znają język obiektowy i chcą nauczyć się Kotlin.

Wprowadzenie

To ostatni codelab w ramach kursu Kotlin Bootcamp. Z tego przewodnika dowiesz się więcej o adnotacjach i oznaczonych przerwach. Poznasz wyrażenia lambda i funkcje wyższego rzędu, które są kluczowymi elementami języka Kotlin. Dowiesz się też więcej o funkcjach wstawianych i interfejsach Single Abstract Method (SAM). Na koniec dowiesz się więcej o bibliotece standardowej języka Kotlin.

Lekcje w tym kursie nie są powiązane z jedną przykładową aplikacją. Zostały zaprojektowane tak, aby poszerzać Twoją wiedzę, ale jednocześnie były od siebie częściowo niezależne. Dzięki temu możesz przeglądać sekcje, które już znasz. Aby je ze sobą powiązać, w wielu przykładach użyto motywu akwarium. Jeśli chcesz poznać pełną historię akwarium, zapoznaj się z kursem Kotlin Bootcamp for Programmers na platformie Udacity.

Co warto wiedzieć

Składnia funkcji, klas i metod w języku Kotlin
Jak utworzyć nową klasę w IntelliJ IDEA i uruchomić program
Podstawy wyrażeń lambda i funkcji wyższego rzędu

Czego się nauczysz

Podstawowe informacje o adnotacjach
Jak korzystać z oznaczonych przerw
Więcej informacji o funkcjach wyższego rzędu
Informacje o interfejsach SAM
Informacje o bibliotece standardowej języka Kotlin

Jakie zadania wykonasz

Utwórz prostą adnotację.
Użyj podziału z etykietą.
Sprawdź funkcje lambda w Kotlinie.
używać i tworzyć funkcje wyższego rzędu;
Wywołaj niektóre interfejsy metody pojedynczej abstrakcji.
używać niektórych funkcji z biblioteki standardowej języka Kotlin;

Adnotacje to sposób dołączania metadanych do kodu. Nie są one specyficzne dla języka Kotlin. Adnotacje są odczytywane przez kompilator i używane do generowania kodu lub logiki. Wiele platform, takich jak Ktor i Kotlinx, a także Room, używa adnotacji do konfigurowania sposobu działania i interakcji z Twoim kodem. Zanim zaczniesz korzystać z frameworków, prawdopodobnie nie spotkasz się z adnotacjami, ale warto wiedzieć, jak je odczytywać.

Dostępne są też adnotacje w standardowej bibliotece języka Kotlin, które kontrolują sposób kompilowania kodu. Są one bardzo przydatne, jeśli eksportujesz kod Kotlin do kodu Java, ale w innych przypadkach nie są tak często potrzebne.

Adnotacje umieszcza się bezpośrednio przed elementem, do którego się odnoszą. Można dodawać adnotacje do większości elementów, takich jak klasy, funkcje, metody, a nawet struktury sterujące. Niektóre adnotacje mogą przyjmować argumenty.

Oto przykład adnotacji.

@file:JvmName("InteropFish")
class InteropFish {
   companion object {
       @JvmStatic fun interop()
   }
}

Oznacza to, że wyeksportowana nazwa tego pliku to InteropFish z adnotacją JvmName, która przyjmuje argument "InteropFish".JvmName W obiekcie towarzyszącym słowo @JvmStatic informuje Kotlin, że interop() ma być funkcją statyczną w InteropFish.

Możesz też tworzyć własne adnotacje, ale jest to przydatne głównie wtedy, gdy piszesz bibliotekę, która w czasie działania potrzebuje określonych informacji o klasach, czyli odbicia.

Krok 1. Utwórz nowy pakiet i plik

W sekcji src utwórz nowy pakiet example.
W przykładzie utwórz nowy plik Kotlin, Annotations.kt.

Krok 2. Tworzenie własnej adnotacji

W Annotations.kt utwórz klasę Plant z 2 metodami: trim() i fertilize().

class Plant {
        fun trim(){}
        fun fertilize(){}
}

Utwórz funkcję, która wyświetla wszystkie metody w klasie. Użyj ::class, aby uzyskać informacje o klasie w czasie działania programu. Użyj declaredMemberFunctions, aby uzyskać listę metod klasy. (Aby uzyskać do niego dostęp, musisz zaimportować kotlin.reflect.full.*)

import kotlin.reflect.full.*    // required import

class Plant {
    fun trim(){}
    fun fertilize(){}
}

fun testAnnotations() {
    val classObj = Plant::class
    for (m in classObj.declaredMemberFunctions) {
        println(m.name)
    }
}

Utwórz funkcję main(), aby wywołać procedurę testową. Uruchom program i obserwuj dane wyjściowe.

fun main() {
    testAnnotations()
}

⇒ trim
fertilize

Utwórz prostą adnotację ImAPlant.

annotation class ImAPlant

Nie robi to niczego poza informowaniem, że jest to adnotacja.

Dodaj adnotację przed klasą Plant.

@ImAPlant class Plant{
    ...
}

Zmień testAnnotations(), aby wydrukować wszystkie adnotacje dotyczące zajęć. Użyj annotations, aby uzyskać wszystkie adnotacje dotyczące klasy. Uruchom program i sprawdź wynik.

fun testAnnotations() {
    val plantObject = Plant::class
    for (a in plantObject.annotations) {
        println(a.annotationClass.simpleName)
    }
}

⇒ ImAPlant

Zmień testAnnotations(), aby znaleźć adnotację ImAPlant. Użyj ikony findAnnotation(), aby znaleźć konkretną adnotację. Uruchom program i sprawdź wynik.

fun testAnnotations() {
    val plantObject = Plant::class
    val myAnnotationObject = plantObject.findAnnotation<ImAPlant>()
    println(myAnnotationObject)
}

⇒ @example.ImAPlant()

Krok 3. Tworzenie adnotacji kierowanej

Adnotacje mogą być kierowane na metody pobierające lub ustawiające. Gdy to zrobisz, możesz zastosować je z prefiksem @get: lub @set:. Często zdarza się to w przypadku korzystania z frameworków z adnotacjami.

Zadeklaruj 2 adnotacje: OnGet, którą można stosować tylko w przypadku funkcji pobierających właściwości, oraz OnSet, którą można stosować tylko w przypadku funkcji ustawiających właściwości. Użyj właściwości @Target(AnnotationTarger.PROPERTY_GETTER) lub PROPERTY_SETTER w każdym z nich.

annotation class ImAPlant

@Target(AnnotationTarget.PROPERTY_GETTER)
annotation class OnGet
@Target(AnnotationTarget.PROPERTY_SETTER)
annotation class OnSet

@ImAPlant class Plant {
    @get:OnGet
    val isGrowing: Boolean = true

    @set:OnSet
    var needsFood: Boolean = false
}

Adnotacje są bardzo przydatne do tworzenia bibliotek, które sprawdzają różne elementy zarówno w czasie działania, jak i czasami w czasie kompilacji. Typowy kod aplikacji korzysta jednak tylko z adnotacji dostarczonych przez frameworki.

Kotlin udostępnia kilka sposobów kontrolowania przepływu. Znasz już instrukcję return, która powoduje powrót z funkcji do funkcji ją zawierającej. Użycie break jest podobne do return, ale w przypadku pętli.

Kotlin daje Ci dodatkową kontrolę nad pętlami dzięki tzw. przerwaniu z etykietą. Instrukcja break z etykietą powoduje przejście do punktu wykonania bezpośrednio po pętli oznaczonej tą etykietą. Jest to szczególnie przydatne w przypadku zagnieżdżonych pętli.

Każde wyrażenie w Kotlinie można oznaczyć etykietą. Etykiety mają postać identyfikatora, po którym następuje znak @.

W Annotations.kt wypróbuj przerwanie z etykietą, przerywając pętlę wewnętrzną.

fun labels() {
    outerLoop@ for (i in 1..100) {
         print("$i ")
         for (j in 1..100) {
             if (i > 10) break@outerLoop  // breaks to outer loop
        }
    }
}

fun main() {
    labels()
}

Uruchom program i obserwuj dane wyjściowe.

⇒ 1 2 3 4 5 6 7 8 9 10 11

Podobnie możesz użyć etykiety continue. Zamiast przerywać pętlę z etykietą, instrukcja continue z etykietą przechodzi do następnej iteracji pętli.

Lambdy to funkcje anonimowe, czyli funkcje bez nazwy. Możesz przypisywać je do zmiennych i przekazywać jako argumenty do funkcji i metod. Są niezwykle przydatne.

Krok 1. Utwórz prostą funkcję lambda

Uruchom REPL w IntelliJ IDEA: Tools > Kotlin > Kotlin REPL.
Utwórz funkcję lambda z argumentem dirty: Int, która wykonuje obliczenia, dzieląc dirty przez 2. Przypisz lambdę do zmiennej waterFilter.

val waterFilter = { dirty: Int -> dirty / 2 }

Wywołaj funkcję waterFilter, przekazując wartość 30.

waterFilter(30)

⇒ res0: kotlin.Int = 15

Krok 2. Utwórz funkcję lambda filtra

W REPL utwórz klasę danych Fish z jedną właściwością name.

data class Fish(val name: String)

Utwórz listę 3 Fish o imionach Flipper, Moby Dick i Dory.

val myFish = listOf(Fish("Flipper"), Fish("Moby Dick"), Fish("Dory"))

Dodaj filtr, aby sprawdzić, czy nazwy zawierają literę „i”.

myFish.filter { it.name.contains("i")}

⇒ res3: kotlin.collections.List<Line_1.Fish> = [Fish(name=Flipper), Fish(name=Moby Dick)]

W wyrażeniu lambda it odnosi się do bieżącego elementu listy, a filtr jest stosowany do każdego elementu listy po kolei.

Zastosuj joinString() do wyniku, używając ", " jako separatora.

myFish.filter { it.name.contains("i")}.joinToString(", ") { it.name }

⇒ res4: kotlin.String = Flipper, Moby Dick

Funkcja joinToString() tworzy ciąg tekstowy, łącząc przefiltrowane nazwy rozdzielone określonym ciągiem tekstowym. Jest to jedna z wielu przydatnych funkcji wbudowanych w standardową bibliotekę Kotlina.

Przekazywanie lambdy lub innej funkcji jako argumentu do funkcji tworzy funkcję wyższego rzędu. Powyższy filtr jest prostym przykładem takiego działania. filter() to funkcja, której przekazujesz lambdę określającą sposób przetwarzania każdego elementu listy.

Pisanie funkcji wyższego rzędu za pomocą lambd rozszerzających to jedna z najbardziej zaawansowanych części języka Kotlin. Nauczenie się ich pisania zajmuje trochę czasu, ale są bardzo wygodne w użyciu.

Krok 1. Tworzenie nowych zajęć

W pakiecie example utwórz nowy plik Kotlin o nazwie Fish.kt.
W Fish.kt utwórz klasę danych Fish z jedną właściwością name.

data class Fish (var name: String)

Utwórz funkcję fishExamples(). W fishExamples() utwórz rybę o nazwie "splashy" (wszystkie litery małe).

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
}

Utwórz funkcję main(), która wywołuje funkcję fishExamples().

fun main () {
    fishExamples()
}

Skompiluj i uruchom program, klikając zielony trójkąt po lewej stronie main(). Brak danych wyjściowych.

Krok 2. Użyj funkcji wyższego rzędu

Funkcja with() umożliwia tworzenie co najmniej 1 odwołania do obiektu lub właściwości w bardziej zwięzły sposób. Mod wykorzystuje: this. with() to funkcja wyższego rzędu, a w funkcji lambda określasz, co zrobić z dostarczonym obiektem.

Użyj znaku with(), aby zapisać nazwę ryby wielką literą w polu fishExamples(). W nawiasach klamrowych this odnosi się do obiektu przekazanego do with().

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        this.capitalize()
    }
}

Nie ma danych wyjściowych, więc dodaj wokół niego znak println(). Symbol this jest domyślny i nie jest potrzebny, więc możesz go usunąć.

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        println(capitalize())
    }
}

⇒ Splashy

Krok 3. Utwórz funkcję wyższego rzędu

W tle with() jest funkcją wyższego rzędu. Aby zobaczyć, jak to działa, możesz utworzyć własną, znacznie uproszczoną wersję with(), która działa tylko w przypadku ciągów znaków.

W sekcji Fish.kt zdefiniuj funkcję myWith(), która przyjmuje 2 argumenty. Argumentami są obiekt, na którym ma zostać wykonana operacja, oraz funkcja definiująca tę operację. Konwencja nazewnictwa argumentu funkcji to block. W tym przypadku funkcja nie zwraca niczego, co jest oznaczone symbolem Unit.

fun myWith(name: String, block: String.() -> Unit) {}

W myWith() funkcja block() jest teraz funkcją rozszerzenia String. Klasa, która jest rozszerzana, jest często nazywana obiektem odbiorcy. W tym przypadku obiektem odbierającym jest name.

W treści funkcji myWith() zastosuj przekazaną funkcję block() do obiektu odbiorcy name.

fun myWith(name: String, block: String.() -> Unit) {
    name.block()
}

W sekcji fishExamples() zastąp with() tekstem myWith().

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    myWith (fish.name) {
        println(capitalize())
    }
}

fish.name to argument nazwy, a println(capitalize()) to funkcja bloku.

Uruchom program, a będzie działać jak wcześniej.

⇒ Splashy

Krok 4. Sprawdź więcej wbudowanych rozszerzeń

Funkcja lambda rozszerzenia with() jest bardzo przydatna i stanowi część standardowej biblioteki języka Kotlin. Oto kilka innych, które mogą Ci się przydać: run(), apply() i let().

Funkcja run() to rozszerzenie, które działa ze wszystkimi typami. Pobiera jedną lambdę jako argument i zwraca wynik jej wykonania.

W funkcji fishExamples() wywołaj funkcję run() w dniu fish, aby uzyskać nazwę.

fish.run {
   name
}

Zwraca tylko właściwość name. Możesz przypisać go do zmiennej lub wydrukować. Nie jest to zbyt przydatny przykład, ponieważ możesz po prostu uzyskać dostęp do właściwości, ale run() może być przydatne w przypadku bardziej skomplikowanych wyrażeń.

Funkcja apply() jest podobna do funkcji run(), ale zwraca zmieniony obiekt, do którego została zastosowana, zamiast wyniku funkcji lambda. Może to być przydatne do wywoływania metod na nowo utworzonym obiekcie.

Utwórz kopię fish i nadaj jej nazwę apply().

val fish2 = Fish(name = "splashy").apply {
     name = "sharky"
}
println(fish2.name)

⇒ sharky

Funkcja let() jest podobna do funkcji apply(), ale zwraca kopię obiektu ze zmianami. Może to być przydatne do łączenia manipulacji.

Użyj funkcji let(), aby pobrać nazwę fish, napisać ją wielkimi literami, połączyć z innym ciągiem znaków, uzyskać długość tego wyniku, dodać do niej 31, a następnie wydrukować wynik.

println(fish.let { it.name.capitalize()}
.let{it + "fish"}
.let{it.length}
.let{it + 31})

⇒ 42

W tym przykładzie typ obiektu, do którego odnosi się it, to Fish, potem String, potem znowu String i na końcu Int.

Wydrukuj fish po wywołaniu let(), a zobaczysz, że się nie zmieniło.

println(fish.let { it.name.capitalize()}
    .let{it + "fish"}
    .let{it.length}
    .let{it + 31})
println(fish)

⇒ 42
Fish(name=splashy)

Funkcje lambda i funkcje wyższego rzędu są bardzo przydatne, ale warto wiedzieć, że funkcje lambda to obiekty. Wyrażenie lambda jest instancją interfejsu Function, który sam jest podtypem interfejsu Object. Weźmy pod uwagę wcześniejszy przykład myWith().

myWith(fish.name) {
    capitalize()
}

Interfejs Function ma metodę invoke(), która jest zastępowana w celu wywołania wyrażenia lambda. W formie rozwiniętej wyglądałby on mniej więcej tak:

// actually creates an object that looks like this
myWith(fish.name, object : Function1<String, Unit> {
    override fun invoke(name: String) {
        name.capitalize()
    }
})

Zwykle nie stanowi to problemu, ponieważ tworzenie obiektów i wywoływanie funkcji nie wiąże się z dużym obciążeniem, czyli zużyciem pamięci i czasu procesora. Jeśli jednak definiujesz coś takiego jak myWith(), co jest używane wszędzie, narzut może się zwiększyć.

Kotlin udostępnia inline jako sposób obsługi tego przypadku, aby zmniejszyć obciążenie w czasie działania programu, dodając nieco więcej pracy dla kompilatora. (W poprzedniej lekcji, w której mówiliśmy o typach konkretnych, dowiedzieliśmy się nieco o inline). Oznaczenie funkcji jako inline oznacza, że za każdym razem, gdy funkcja jest wywoływana, kompilator przekształca kod źródłowy, aby „wstawić” funkcję. Oznacza to, że kompilator zmieni kod, zastępując wyrażenie lambda instrukcjami w nim zawartymi.

Jeśli w powyższym przykładzie myWith() jest oznaczone symbolem inline:

inline myWith(fish.name) {
    capitalize()
}

zostanie przekształcone w połączenie bezpośrednie:

// with myWith() inline, this becomes
fish.name.capitalize()

Warto zauważyć, że wstawianie dużych funkcji zwiększa rozmiar kodu, dlatego najlepiej używać go w przypadku prostych funkcji, które są używane wiele razy, np. myWith(). Funkcje rozszerzenia z bibliotek, o których pisaliśmy wcześniej, są oznaczone symbolem inline, więc nie musisz się martwić o tworzenie dodatkowych obiektów.

Single Abstract Method to po prostu interfejs z jedną metodą. Są one bardzo powszechne w przypadku interfejsów API napisanych w języku programowania Java, dlatego istnieje akronim SAM. Przykłady to Runnable, która ma jedną metodę abstrakcyjną run(), oraz Callable, która ma jedną metodę abstrakcyjną call().

W Kotlinie musisz cały czas wywoływać funkcje, które przyjmują SAM-y jako parametry. Wypróbuj przykład poniżej.

W folderze example utwórz klasę Java JavaRun i wklej do pliku ten kod:

package example;

public class JavaRun {
    public static void runNow(Runnable runnable) {
        runnable.run();
    }
}

W języku Kotlin możesz utworzyć instancję obiektu, który implementuje interfejs, poprzedzając typ znakiem object:. Jest to przydatne do przekazywania parametrów do SAM-ów.

Wróć do Fish.kt i utwórz funkcję runExample(), która tworzy Runnable za pomocą object:. Obiekt powinien implementować run() przez drukowanie "I'm a Runnable".

fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
}

Wywołaj funkcję JavaRun.runNow() z utworzonym obiektem.

fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
    JavaRun.runNow(runnable)
}

Zadzwoń pod numer runExample() z telefonu main() i uruchom program.

⇒ I'm a Runnable

Wydrukowanie czegoś wymaga sporo pracy, ale to dobry przykład działania systemu SAM. Kotlin oferuje prostszy sposób na to: użyj lambdy zamiast obiektu, aby skrócić kod.

Usuń istniejący kod w runExample, zmień go tak, aby wywoływał runNow() za pomocą funkcji lambda, i uruchom program.

fun runExample() {
    JavaRun.runNow({
        println("Passing a lambda as a Runnable")
    })
}

⇒ Passing a lambda as a Runnable

Możesz to jeszcze bardziej uprościć, używając składni wywołania ostatniego parametru i usuwając nawiasy.

fun runExample() {
    JavaRun.runNow {
        println("Last parameter is a lambda as a Runnable")
    }
}

⇒ Last parameter is a lambda as a Runnable

To podstawy SAM, czyli metody z jedną funkcją abstrakcyjną. Możesz utworzyć instancję, zastąpić i wywołać narzędzie SAM za pomocą jednego wiersza kodu, używając tego wzorca:
Class.singleAbstractMethod { lambda_of_override }

W tej lekcji omówiliśmy wyrażenia lambda i funkcje wyższego rzędu, które są kluczowymi elementami języka Kotlin. Dowiedzieliśmy się też o adnotacjach i oznaczonych przerwach.

Używaj adnotacji, aby określać elementy dla kompilatora. Na przykład:
@file:JvmName("Foo")
Używaj etykietowanych instrukcji break, aby umożliwić kodowi wyjście z zagnieżdżonych pętli. Na przykład:
if (i > 10) break@outerLoop // breaks to outerLoop label
Funkcje lambda mogą być bardzo przydatne w połączeniu z funkcjami wyższego rzędu.
Funkcje lambda są obiektami. Aby uniknąć tworzenia obiektu, możesz oznaczyć funkcję symbolem inline, a kompilator umieści zawartość wyrażenia lambda bezpośrednio w kodzie.
Używaj inline ostrożnie, ale może to pomóc w ograniczeniu wykorzystania zasobów przez program.
SAM (Single Abstract Method) to popularny wzorzec, który jest prostszy w przypadku lambd. Podstawowy wzorzec to:
Class.singleAbstractMethod { lamba_of_override }
Biblioteka standardowa Kotlin zawiera wiele przydatnych funkcji, w tym kilka interfejsów SAM, więc warto się z nią zapoznać.

Kotlin ma o wiele więcej funkcji niż te, które zostały omówione w tym kursie, ale masz już podstawy, aby zacząć tworzyć własne programy w tym języku. Mamy nadzieję, że ten ekspresyjny język Ci się spodoba i że będziesz z niego korzystać, aby tworzyć więcej funkcji, pisząc mniej kodu (zwłaszcza jeśli używasz języka programowania Java). Praktyka i nauka w trakcie pracy to najlepszy sposób na zdobycie biegłości w języku Kotlin, więc kontynuuj samodzielne odkrywanie i poznawanie tego języka.

Dokumentacja języka Kotlin

Jeśli chcesz uzyskać więcej informacji na dowolny temat w tym kursie lub jeśli napotkasz trudności, najlepszym punktem wyjścia będzie strona https://kotlinlang.org.

Samouczki dotyczące języka Kotlin

Witryna https://try.kotlinlang.org zawiera rozbudowane samouczki Kotlin Koans, internetowy interpreter i pełny zestaw dokumentacji z przykładami.

Kurs Udacity

Aby obejrzeć kurs Udacity na ten temat, zobacz Kotlin Bootcamp for Programmers (w języku angielskim).

IntelliJ IDEA

Dokumentację IntelliJ IDEA znajdziesz w witrynie JetBrains.

Biblioteka standardowa języka Kotlin

Biblioteka standardowa języka Kotlin zawiera wiele przydatnych funkcji. Zanim napiszesz własną funkcję lub interfejs, zawsze sprawdź Bibliotekę standardową, aby zobaczyć, czy ktoś nie wykonał już za Ciebie części pracy. Zaglądaj tu regularnie, ponieważ często dodajemy nowe funkcje.

Samouczki dotyczące języka Kotlin

Witryna https://try.kotlinlang.org zawiera rozbudowane samouczki Kotlin Koans, internetowy interpreter i pełny zestaw dokumentacji z przykładami.

Kurs Udacity

Aby obejrzeć kurs Udacity na ten temat, zobacz Kotlin Bootcamp for Programmers (w języku angielskim).

IntelliJ IDEA

Dokumentację IntelliJ IDEA znajdziesz w witrynie JetBrains.

W tej sekcji znajdziesz listę możliwych zadań domowych dla uczniów, którzy wykonują ten moduł w ramach kursu prowadzonego przez instruktora. Nauczyciel musi:

W razie potrzeby przypisz pracę domową.
Poinformuj uczniów, jak przesyłać projekty.
Oceń zadania domowe.

Instruktorzy mogą korzystać z tych sugestii w dowolnym zakresie i mogą zadawać inne zadania domowe, które uznają za odpowiednie.

Jeśli wykonujesz ten kurs samodzielnie, możesz użyć tych zadań domowych, aby sprawdzić swoją wiedzę.

Odpowiedz na te pytania

Pytanie 1

W języku Kotlin akronim SAM oznacza:

▢ Bezpieczne dopasowywanie argumentów

▢ Simple Access Method

▢ Single Abstract Method

▢ Metodologia dostępu strategicznego

Pytanie 2

Która z tych funkcji nie jest funkcją rozszerzającą biblioteki standardowej języka Kotlin?

▢ elvis()

▢ apply()

▢ run()

▢ with()

Pytanie 3

Które z tych stwierdzeń dotyczących wyrażeń lambda w Kotlinie jest nieprawdziwe?

▢ Lambdy to funkcje anonimowe.

▢ Funkcje lambda są obiektami, chyba że są wstawione w kodzie.

▢ Funkcje Lambda są zasobożerne i nie należy ich używać.

▢ Funkcje lambda można przekazywać do innych funkcji.

Pytanie 4

Etykiety w Kotlinie są oznaczane identyfikatorem, po którym następuje:

▢ :

▢ ::

▢ @:

▢ @

Gratulacje! Ukończone ćwiczenie z programowania Kotlin Bootcamp for Programmers.

Omówienie kursu, w tym linki do innych ćwiczeń, znajdziesz w artykule „Kotlin Bootcamp for Programmers: Welcome to the course” (w języku angielskim).

Kotlin Bootcamp for Programmers 6: Functional manipulation Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Wprowadzenie

Co warto wiedzieć

Czego się nauczysz

Jakie zadania wykonasz

Krok 1. Utwórz nowy pakiet i plik

Krok 2. Tworzenie własnej adnotacji

Krok 3. Tworzenie adnotacji kierowanej

Krok 1. Utwórz prostą funkcję lambda

Krok 2. Utwórz funkcję lambda filtra

Krok 1. Tworzenie nowych zajęć

Krok 2. Użyj funkcji wyższego rzędu

Krok 3. Utwórz funkcję wyższego rzędu

Krok 4. Sprawdź więcej wbudowanych rozszerzeń

Dokumentacja języka Kotlin

Samouczki dotyczące języka Kotlin

Kurs Udacity

IntelliJ IDEA

Biblioteka standardowa języka Kotlin

Samouczki dotyczące języka Kotlin

Kurs Udacity

IntelliJ IDEA

Odpowiedz na te pytania

Pytanie 1

Pytanie 2

Pytanie 3

Pytanie 4

Kotlin Bootcamp for Programmers 6: Functional manipulation