Bootcamp Kotlin untuk Pemrogram 6: Manipulasi fungsional

Codelab ini adalah bagian dari kursus Kotlin Bootcamp for Programmers. Anda akan mendapatkan manfaat maksimal dari kursus ini jika menyelesaikan codelab secara berurutan. Anda mungkin dapat membaca cepat beberapa bagian, bergantung pada pengetahuan Anda. Kursus ini ditujukan bagi programer yang menguasai bahasa berorientasi objek, dan ingin mempelajari Kotlin.

Pengantar

Ini adalah codelab terakhir di Kotlin Bootcamp. Dalam codelab ini, Anda akan mempelajari anotasi dan jeda berlabel. Anda dapat meninjau lambda dan fungsi urutan yang lebih tinggi, yang merupakan bagian penting dari Kotlin. Anda juga akan mempelajari lebih lanjut fungsi inline, dan antarmuka Single Abstract Method (SAM). Terakhir, Anda mempelajari lebih lanjut Library Standar Kotlin.

Daripada membuat satu aplikasi contoh, pelajaran dalam kursus ini dirancang untuk membangun pengetahuan Anda, tetapi bersifat semi-independen satu sama lain sehingga Anda dapat membaca sekilas bagian yang sudah Anda kuasai. Untuk mengaitkannya, banyak contoh yang menggunakan tema akuarium. Jika Anda ingin melihat kisah akuarium selengkapnya, lihat kursus Kotlin Bootcamp for Programmers di Udacity.

Yang harus sudah Anda ketahui

  • Sintaksis fungsi, class, dan metode Kotlin
  • Cara membuat class baru di IntelliJ IDEA dan menjalankan program
  • Dasar-dasar lambda dan fungsi tingkat tinggi

Yang akan Anda pelajari

  • Dasar-dasar anotasi
  • Cara menggunakan jeda berlabel
  • Selengkapnya tentang fungsi urutan yang lebih tinggi
  • Tentang antarmuka Single Abstract Method (SAM)
  • Tentang Library Standar Kotlin

Yang akan Anda lakukan

  • Buat anotasi sederhana.
  • Gunakan jeda berlabel.
  • Tinjau fungsi lambda di Kotlin.
  • Menggunakan dan membuat fungsi urutan yang lebih tinggi.
  • Panggil beberapa antarmuka Metode Abstrak Tunggal.
  • Gunakan beberapa fungsi dari Kotlin Standard Library.

Anotasi adalah cara untuk melampirkan metadata ke kode, dan bukan sesuatu yang khusus untuk Kotlin. Anotasi dibaca oleh compiler dan digunakan untuk membuat kode atau logika. Banyak framework, seperti Ktor dan Kotlinx, serta Room, menggunakan anotasi untuk mengonfigurasi cara menjalankan dan berinteraksi dengan kode Anda. Anda kemungkinan tidak akan menemukan anotasi apa pun hingga Anda mulai menggunakan framework, tetapi akan berguna untuk mengetahui cara membaca anotasi.

Ada juga anotasi yang tersedia melalui library standar Kotlin yang mengontrol cara kode dikompilasi. Class ini sangat berguna jika Anda mengekspor kode Kotlin ke Java, tetapi jika tidak, Anda tidak terlalu sering memerlukannya.

Anotasi berada tepat sebelum hal yang dianotasi, dan sebagian besar hal dapat dianotasi—class, fungsi, metode, dan bahkan struktur kontrol. Beberapa anotasi dapat mengambil argumen.

Berikut adalah contoh beberapa anotasi.

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

Hal ini menunjukkan bahwa nama file yang diekspor adalah InteropFish dengan anotasi JvmName; anotasi JvmName mengambil argumen "InteropFish". Dalam objek pendamping, @JvmStatic memberi tahu Kotlin untuk menjadikan interop() sebagai fungsi statis di InteropFish.

Anda juga dapat membuat anotasi sendiri, tetapi hal ini sebagian besar berguna jika Anda menulis library yang memerlukan informasi tertentu tentang class saat runtime, yaitu refleksi.

Langkah 1: Buat paket dan file baru

  1. Di bagian src, buat paket baru, example.
  2. Di example, buat file Kotlin baru, Annotations.kt.

Langkah 2: Buat anotasi Anda sendiri

  1. Di Annotations.kt, buat class Plant dengan dua metode, trim() dan fertilize().
class Plant {
        fun trim(){}
        fun fertilize(){}
}
  1. Buat fungsi yang mencetak semua metode dalam class. Gunakan ::class untuk mendapatkan informasi tentang class saat runtime. Gunakan declaredMemberFunctions untuk mendapatkan daftar metode suatu class. (Untuk mengaksesnya, Anda perlu mengimpor 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)
    }
}
  1. Buat fungsi main() untuk memanggil rutin pengujian Anda. Jalankan program Anda dan amati output-nya.
fun main() {
    testAnnotations()
}
 
⇒ trim
fertilize
  1. Buat anotasi sederhana, ImAPlant.
annotation class ImAPlant

Hal ini tidak melakukan apa pun selain menyatakan bahwa anotasi telah ditambahkan.

  1. Tambahkan anotasi di depan class Plant Anda.
@ImAPlant class Plant{
    ...
}
  1. Ubah testAnnotations() untuk mencetak semua anotasi kelas. Gunakan annotations untuk mendapatkan semua anotasi kelas. Jalankan program Anda dan amati hasilnya.
fun testAnnotations() {
    val plantObject = Plant::class
    for (a in plantObject.annotations) {
        println(a.annotationClass.simpleName)
    }
}
 
⇒ ImAPlant
  1. Ubah testAnnotations() untuk menemukan anotasi ImAPlant. Gunakan findAnnotation() untuk menemukan anotasi tertentu. Jalankan program Anda dan amati hasilnya.
fun testAnnotations() {
    val plantObject = Plant::class
    val myAnnotationObject = plantObject.findAnnotation<ImAPlant>()
    println(myAnnotationObject)
}

⇒ @example.ImAPlant()

Langkah 3: Buat anotasi yang ditargetkan

Anotasi dapat menargetkan getter atau setter. Jika demikian, Anda dapat menerapkannya dengan awalan @get: atau @set:. Hal ini sering muncul saat menggunakan framework dengan anotasi.

  1. Deklarasikan dua anotasi, OnGet yang hanya dapat diterapkan ke getter properti, dan OnSet yang hanya dapat diterapkan ke setter properti. Gunakan @Target(AnnotationTarger.PROPERTY_GETTER) atau PROPERTY_SETTER di setiap kartu.
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
}

Anotasi sangat efektif untuk membuat library yang memeriksa sesuatu saat runtime dan terkadang saat waktu kompilasi. Namun, kode aplikasi umum hanya menggunakan anotasi yang disediakan oleh framework.

Kotlin memiliki beberapa cara untuk mengontrol alur. Anda sudah terbiasa dengan return, yang menampilkan dari fungsi ke fungsi penutupnya. Menggunakan break sama seperti return, tetapi untuk loop.

Kotlin memberi Anda kontrol tambahan atas loop dengan apa yang disebut break berlabel. break yang memenuhi syarat dengan label melompat ke titik eksekusi tepat setelah loop yang ditandai dengan label tersebut. Hal ini sangat berguna saat menangani loop bertingkat.

Setiap ekspresi di Kotlin dapat ditandai dengan label. Label memiliki bentuk ID yang diikuti dengan tanda @.

  1. Di Annotations.kt, coba hentikan berlabel dengan keluar dari loop dalam.
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()
}
  1. Jalankan program Anda dan amati output-nya.
⇒ 1 2 3 4 5 6 7 8 9 10 11

Demikian pula, Anda dapat menggunakan continue berlabel. Alih-alih keluar dari loop berlabel, continue berlabel akan melanjutkan ke iterasi loop berikutnya.

Lambda adalah fungsi anonim, yaitu fungsi tanpa nama. Anda dapat menetapkannya ke variabel dan meneruskannya sebagai argumen ke fungsi dan metode. Fitur ini sangat berguna.

Langkah 1: Buat lambda sederhana

  1. Mulai REPL di IntelliJ IDEA, Tools > Kotlin > Kotlin REPL.
  2. Buat lambda dengan argumen, dirty: Int yang melakukan penghitungan, membagi dirty dengan 2. Tetapkan lambda ke variabel, waterFilter.
val waterFilter = { dirty: Int -> dirty / 2 }
  1. Panggil waterFilter, dengan meneruskan nilai 30.
waterFilter(30)
 
⇒ res0: kotlin.Int = 15

Langkah 2: Buat lambda filter

  1. Masih di REPL, buat class data, Fish, dengan satu properti, name.
data class Fish(val name: String)
  1. Buat daftar 3 Fish, dengan nama Flipper, Moby Dick, dan Dory.
val myFish = listOf(Fish("Flipper"), Fish("Moby Dick"), Fish("Dory"))
  1. Tambahkan filter untuk memeriksa nama yang berisi huruf 'i'.
myFish.filter { it.name.contains("i")}

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

Dalam ekspresi lambda, it merujuk ke elemen daftar saat ini, dan filter diterapkan ke setiap elemen daftar secara bergiliran.

  1. Terapkan joinString() ke hasil, menggunakan ", " sebagai pemisah.
myFish.filter { it.name.contains("i")}.joinToString(", ") { it.name }

⇒ res4: kotlin.String = Flipper, Moby Dick

Fungsi joinToString() membuat string dengan menggabungkan nama yang difilter, yang dipisahkan oleh string yang ditentukan. Ini adalah salah satu dari banyak fungsi berguna yang dibuat ke dalam library standar Kotlin.

Meneruskan lambda atau fungsi lain sebagai argumen ke fungsi akan membuat fungsi tingkat tinggi. Filter di atas adalah contoh sederhana dari hal ini. filter() adalah fungsi, dan Anda meneruskan lambda yang menentukan cara memproses setiap elemen daftar.

Menulis fungsi tingkat tinggi dengan lambda ekstensi adalah salah satu bagian paling canggih dari bahasa Kotlin. Membutuhkan waktu beberapa saat untuk mempelajari cara menulisnya, tetapi sangat mudah digunakan.

Langkah 1: Buat kelas baru

  1. Dalam paket example, buat file Kotlin baru, Fish.kt.
  2. Di Fish.kt, buat class data Fish, dengan satu properti, name.
data class Fish (var name: String)
  1. Buat fungsi fishExamples(). Di fishExamples(), buat ikan bernama "splashy", semuanya huruf kecil.
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
}
  1. Buat fungsi main() yang memanggil fishExamples().
fun main () {
    fishExamples()
}
  1. Kompilasi dan jalankan program dengan mengklik segitiga hijau di sebelah kiri main(). Belum ada output.

Langkah 2: Gunakan fungsi urutan yang lebih tinggi

Fungsi with() memungkinkan Anda membuat satu atau beberapa referensi ke objek atau properti dengan cara yang lebih ringkas. Menggunakan this. with() sebenarnya adalah fungsi tingkat tinggi, dan dalam lambda Anda menentukan apa yang harus dilakukan dengan objek yang diberikan.

  1. Gunakan with() untuk menulis nama ikan dengan huruf kapital di fishExamples(). Dalam tanda kurung kurawal, this merujuk ke objek yang diteruskan ke with(). 
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        this.capitalize()
    }
}
  1. Tidak ada output, jadi tambahkan println() di sekitarnya. Selain itu, this bersifat implisit dan tidak diperlukan, sehingga Anda dapat menghapusnya.
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        println(capitalize())
    }
}
 
⇒ Splashy

Langkah 3: Buat fungsi urutan yang lebih tinggi

Di balik layar, with() adalah fungsi tingkat tinggi. Untuk melihat cara kerjanya, Anda dapat membuat versi with() yang sangat disederhanakan dan hanya berfungsi untuk string.

  1. Di Fish.kt, tentukan fungsi, myWith() yang menggunakan dua argumen. Argumennya adalah objek yang akan dioperasikan, dan fungsi yang menentukan operasi. Konvensi untuk nama argumen dengan fungsi adalah block. Dalam hal ini, fungsi tersebut tidak menampilkan apa pun, yang ditentukan dengan Unit.
fun myWith(name: String, block: String.() -> Unit) {}

Di dalam myWith(), block() kini menjadi fungsi ekstensi String. Class yang diperluas sering disebut objek penerima. Jadi, name adalah objek penerima dalam kasus ini.

  1. Dalam isi myWith(), terapkan fungsi yang diteruskan, block(), ke objek penerima, name.
fun myWith(name: String, block: String.() -> Unit) {
    name.block()
}
  1. Di fishExamples(), ganti with() dengan myWith().
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    myWith (fish.name) {
        println(capitalize())
    }
}

fish.name adalah argumen nama, dan println(capitalize()) adalah fungsi blok.

  1. Jalankan program, dan program akan beroperasi seperti sebelumnya.
⇒ Splashy

Langkah 4: Jelajahi ekstensi bawaan lainnya

Lambda ekstensi with() sangat berguna, dan merupakan bagian dari Kotlin Standard Library. Berikut beberapa opsi lainnya yang mungkin berguna bagi Anda: run(), apply(), dan let().

Fungsi run() adalah ekstensi yang berfungsi dengan semua jenis. Fungsi ini menggunakan satu lambda sebagai argumennya dan menampilkan hasil eksekusi lambda.

  1. Di fishExamples(), panggil run() di fish untuk mendapatkan nama.
fish.run {
   name
}

Tindakan ini hanya menampilkan properti name. Anda dapat menetapkannya ke variabel atau mencetaknya. Contoh ini sebenarnya tidak berguna, karena Anda hanya dapat mengakses properti, tetapi run() dapat berguna untuk ekspresi yang lebih rumit.

Fungsi apply() serupa dengan run(), tetapi menampilkan objek yang diubah yang diterapkan padanya, bukan hasil lambda. Hal ini dapat berguna untuk memanggil metode pada objek yang baru dibuat.

  1. Buat salinan fish dan panggil apply() untuk menetapkan nama salinan baru.
val fish2 = Fish(name = "splashy").apply {
     name = "sharky"
}
println(fish2.name)

⇒ sharky

Fungsi let() mirip dengan apply(), tetapi menampilkan salinan objek dengan perubahan. Hal ini dapat berguna untuk merangkai manipulasi.

  1. Gunakan let() untuk mendapatkan nama fish, ubah menjadi huruf kapital, gabungkan string lain ke string tersebut, dapatkan panjang hasil tersebut, tambahkan 31 ke panjangnya, lalu cetak hasilnya.
println(fish.let { it.name.capitalize()}
.let{it + "fish"}
.let{it.length}
.let{it + 31})
 
⇒ 42

Dalam contoh ini, jenis objek yang dirujuk oleh it adalah Fish, lalu String, lalu String lagi, dan terakhir Int.

  1. Cetak fish setelah memanggil let(), dan Anda akan melihat bahwa nilainya tidak berubah.
println(fish.let { it.name.capitalize()}
    .let{it + "fish"}
    .let{it.length}
    .let{it + 31})
println(fish)
 
⇒ 42
Fish(name=splashy)

Lambda dan fungsi urutan yang lebih tinggi sangat berguna, tetapi ada sesuatu yang harus Anda ketahui: lambda adalah objek. Ekspresi lambda adalah instance antarmuka Function, yang merupakan subjenis Object. Perhatikan contoh myWith() sebelumnya.

myWith(fish.name) {
    capitalize()
}

Antarmuka Function memiliki metode, invoke(), yang diganti untuk memanggil ekspresi lambda. Jika ditulis secara panjang, tampilannya akan terlihat seperti kode di bawah.

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

Biasanya, hal ini tidak menjadi masalah karena pembuatan objek dan pemanggilan fungsi tidak menimbulkan banyak overhead, yaitu waktu CPU dan memori. Namun, jika Anda menentukan sesuatu seperti myWith() yang Anda gunakan di mana saja, overhead dapat bertambah.

Kotlin menyediakan inline sebagai cara untuk menangani kasus ini guna mengurangi overhead selama runtime dengan menambahkan sedikit lebih banyak pekerjaan untuk compiler. (Anda telah mempelajari sedikit tentang inline dalam pelajaran sebelumnya yang membahas jenis yang direifikasi.) Menandai fungsi sebagai inline berarti bahwa setiap kali fungsi dipanggil, compiler akan benar-benar mengubah kode sumber untuk "meng-inline" fungsi. Artinya, compiler akan mengubah kode untuk mengganti lambda dengan petunjuk di dalam lambda.

Jika myWith() dalam contoh di atas ditandai dengan inline:

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

tindakan ini akan diubah menjadi panggilan langsung:

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

Perlu diperhatikan bahwa menyisipkan fungsi besar akan meningkatkan ukuran kode Anda, jadi sebaiknya gunakan untuk fungsi sederhana yang digunakan berkali-kali seperti myWith(). Fungsi ekstensi dari library yang Anda pelajari sebelumnya ditandai inline, sehingga Anda tidak perlu khawatir tentang pembuatan objek tambahan.

Metode Abstrak Tunggal hanya berarti antarmuka dengan satu metode di dalamnya. SAM sangat umum digunakan saat menggunakan API yang ditulis dalam bahasa pemrograman Java, sehingga ada akronim untuknya, yaitu SAM. Beberapa contohnya adalah Runnable, yang memiliki satu metode abstrak, run(), dan Callable, yang memiliki satu metode abstrak, call().

Di Kotlin, Anda harus memanggil fungsi yang menggunakan SAM sebagai parameter setiap saat. Coba contoh di bawah.

  1. Di dalam example, buat class Java, JavaRun, dan tempelkan kode berikut ke dalam file.
package example;

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

Kotlin memungkinkan Anda membuat instance objek yang mengimplementasikan antarmuka dengan menambahkan object: sebelum jenis. Hal ini berguna untuk meneruskan parameter ke SAM.

  1. Kembali di Fish.kt, buat fungsi runExample(), yang membuat Runnable menggunakan object: Objek harus mengimplementasikan run() dengan mencetak "I'm a Runnable".
fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
}
  1. Panggil JavaRun.runNow() dengan objek yang Anda buat.
fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
    JavaRun.runNow(runnable)
}
  1. Panggil runExample() dari main() dan jalankan program.
⇒ I'm a Runnable

Banyak pekerjaan yang harus dilakukan untuk mencetak sesuatu, tetapi ini adalah contoh yang baik tentang cara kerja SAM. Tentu saja, Kotlin menyediakan cara yang lebih sederhana untuk melakukannya—gunakan lambda sebagai pengganti objek untuk membuat kode ini jauh lebih ringkas.

  1. Hapus kode yang ada di runExample, ubah untuk memanggil runNow() dengan lambda, dan jalankan program.
fun runExample() {
    JavaRun.runNow({
        println("Passing a lambda as a Runnable")
    })
}

⇒ Passing a lambda as a Runnable
  1. Anda dapat membuatnya lebih ringkas menggunakan sintaksis panggilan parameter terakhir, dan menghilangkan tanda kurung.
fun runExample() {
    JavaRun.runNow {
        println("Last parameter is a lambda as a Runnable")
    }
}
 
⇒ Last parameter is a lambda as a Runnable

Itulah dasar-dasar SAM, Single Abstract Method. Anda dapat membuat instance, mengganti, dan melakukan panggilan ke SAM dengan satu baris kode, menggunakan pola:
Class.singleAbstractMethod { lambda_of_override }

Pelajaran ini meninjau lambda dan membahas fungsi tingkat tinggi secara lebih mendalam—bagian penting dari Kotlin. Anda juga mempelajari anotasi dan jeda berlabel.

  • Gunakan anotasi untuk menentukan hal-hal yang akan dikompilasi. Contoh:
    @file:JvmName("Foo")
  • Gunakan jeda berlabel agar kode Anda keluar dari dalam loop bertingkat. Contoh:
    if (i > 10) break@outerLoop // breaks to outerLoop label
  • Lambda dapat sangat efektif jika dipadukan dengan fungsi urutan yang lebih tinggi.
  • Lambda adalah objek. Untuk menghindari pembuatan objek, Anda dapat menandai fungsi dengan inline, dan compiler akan langsung menempatkan konten lambda dalam kode.
  • Gunakan inline dengan hati-hati, tetapi dapat membantu mengurangi penggunaan resource oleh program Anda.
  • SAM, Single Abstract Method, adalah pola umum, dan menjadi lebih sederhana dengan lambda. Pola dasarnya adalah:
    Class.singleAbstractMethod { lamba_of_override }
  • Kotlin Standard Library menyediakan banyak fungsi yang berguna, termasuk beberapa SAM, jadi pelajari isinya.

Ada banyak hal tentang Kotlin yang tidak dibahas dalam kursus ini, tetapi sekarang Anda memiliki dasar-dasar untuk mulai mengembangkan program Kotlin Anda sendiri. Semoga Anda tertarik dengan bahasa ekspresif ini, dan ingin membuat lebih banyak fungsi sambil menulis lebih sedikit kode (terutama jika Anda berasal dari bahasa pemrograman Java). Berlatih dan belajar sambil berjalan adalah cara terbaik untuk menjadi pakar Kotlin, jadi teruslah menjelajahi dan mempelajari Kotlin sendiri.

Dokumentasi Kotlin

Jika Anda ingin mendapatkan informasi lebih lanjut tentang topik apa pun dalam kursus ini, atau jika Anda mengalami masalah, https://kotlinlang.org adalah titik awal terbaik Anda.

Tutorial Kotlin

Situs https://try.kotlinlang.org menyertakan tutorial lengkap yang disebut Kotlin Koans, interpreter berbasis web, dan serangkaian lengkap dokumentasi referensi dengan contoh.

Kursus Udacity

Untuk melihat kursus Udacity tentang topik ini, lihat Kotlin Bootcamp for Programmers.

IntelliJ IDEA

Dokumentasi untuk IntelliJ IDEA dapat ditemukan di situs JetBrains.

Library Standar Kotlin

Kotlin Standard Library menyediakan banyak fungsi yang berguna. Sebelum Anda menulis fungsi atau antarmuka sendiri, selalu periksa Standard Library untuk melihat apakah ada orang yang telah menyimpan beberapa pekerjaan Anda. Periksa kembali dari waktu ke waktu, karena fungsi baru sering ditambahkan.

Tutorial Kotlin

Situs https://try.kotlinlang.org menyertakan tutorial lengkap yang disebut Kotlin Koans, interpreter berbasis web, dan serangkaian lengkap dokumentasi referensi dengan contoh.

Kursus Udacity

Untuk melihat kursus Udacity tentang topik ini, lihat Kotlin Bootcamp for Programmers.

IntelliJ IDEA

Dokumentasi untuk IntelliJ IDEA dapat ditemukan di situs JetBrains.

Bagian ini mencantumkan kemungkinan tugas pekerjaan rumah untuk siswa yang mengerjakan codelab ini sebagai bagian dari kursus yang dipimpin oleh instruktur. Instruktur menentukan hal berikut:

  • Memberikan pekerjaan rumah jika diperlukan.
  • Memberi tahu siswa cara mengirimkan tugas pekerjaan rumah.
  • Memberi nilai tugas pekerjaan rumah.

Instruktur bisa menggunakan saran ini sesuai kebutuhan, dan bebas menugaskan pekerjaan rumah lain yang dirasa cocok.

Jika Anda menyelesaikan codelab ini sendiri, gunakan tugas pekerjaan rumah ini untuk menguji pengetahuan Anda.

Jawab pertanyaan-pertanyaan berikut

Pertanyaan 1

Di Kotlin, SAM adalah singkatan dari:

▢ Pencocokan Argumen Aman

▢ Metode Akses Sederhana

▢ Metode Abstrak Tunggal

▢ Metodologi Akses Strategis

Pertanyaan 2

Manakah dari berikut ini yang bukan merupakan fungsi ekstensi Kotlin Standard Library?

▢ elvis()

▢ apply()

▢ run()

▢ with()

Pertanyaan 3

Manakah dari pernyataan berikut yang tidak benar tentang lambda di Kotlin?

▢ Lambda adalah fungsi anonim.

▢ Lambda adalah objek kecuali jika disisipkan.

▢ Lambda memerlukan banyak resource dan tidak boleh digunakan.

▢ Lambda dapat diteruskan ke fungsi lain.

Pertanyaan 4

Label di Kotlin ditunjukkan dengan ID yang diikuti oleh:

▢ :

▢ ::

▢ @:

▢ @

Selamat! Anda telah menyelesaikan codelab Kotlin Bootcamp for Programmers.

Untuk ringkasan kursus, termasuk link ke codelab lainnya, lihat "Kotlin Bootcamp for Programmers: Welcome to the course".