Video ini melanjutkan pembahasan nullability Kotlin, khususnya tentang bagaimana cara menggunakan nilai yang berada di dalam nullable variable dan memperkenalkan Not-Null Assertion Operator (!!).

Ada satu ide utama yang perlu kamu pahami:

Kalau sebuah variabel bertipe nullable (Int?, String?, dll.), Kotlin tidak mengizinkan kita langsung memperlakukannya sebagai nilai biasa karena variabel tersebut mungkin berisi null.

Mari kita bedah perlahan.

1. Mengingat kembali nullable

Misalnya:

var result: Int? = 30

Perhatikan:

Int?

Ada tanda ?.

Artinya result boleh berisi:

30

atau:

null

Jadi secara konsep:

┌─────────────┐
│   result    │
│             │
│     30      │
└─────────────┘

Tetapi kotak tersebut juga bisa:

┌─────────────┐
│   result    │
│             │
│    null     │
└─────────────┘

Kotlin harus mempertimbangkan dua kemungkinan tersebut.

2. Kenapa println(result) bisa?

Kalau kita punya:

var result: Int? = 30

println(result)

Ini diperbolehkan.

Hasilnya:

30

Kenapa?

Karena println() memang bisa menerima nilai nullable untuk dicetak.

Kalau:

var result: Int? = null

println(result)

hasilnya:

null

Tidak terjadi error.

Karena kita hanya meminta Kotlin:

“Cetak apa pun yang ada di result.”

3. Masalah muncul ketika kita melakukan operasi

Sekarang kita coba:

var result: Int? = 30

println(result + 1)

Kotlin akan memberikan error.

Kenapa?

Karena result bertipe:

Int?

bukan:

Int

Kotlin berpikir:

“Tunggu dulu. result memang sekarang berisi 30, tetapi bukankah tadi kamu mendeklarasikannya sebagai Int?? Berarti dia bisa saja menjadi null.”

Misalnya ternyata:

result = null

Lalu kita melakukan:

result + 1

Secara logika menjadi:

null + 1

Pertanyaannya:

Berapa hasil null + 1?

Tidak ada hasil yang masuk akal.

Itulah alasan Kotlin mencegah kita melakukan operasi tersebut.

4. Analogi kotak

Ini berkaitan dengan analogi yang kita bahas di video sebelumnya.

Misalnya:

var result: Int? = 30

Bayangkan result adalah sebuah kotak:

┌──────────────┐
│    result    │
│              │
│      30      │
└──────────────┘

Ketika kamu menulis:

result + 1

secara konsep kamu seperti mengatakan:

[KOTAK] + 1

Padahal yang ingin kamu lakukan adalah:

[ISI KOTAK] + 1

yaitu:

30 + 1

Masalahnya, Kotlin belum yakin bahwa isi kotak tersebut benar-benar ada.

5. Di sinilah !! digunakan

Kotlin menyediakan operator:

!!

yang disebut:

Not-Null Assertion Operator

Contoh:

var result: Int? = 30

println(result!! + 1)

Hasil:

31

Apa yang dilakukan !!?

Ketika kita menulis:

result!!

kita mengatakan kepada Kotlin:

“Saya yakin result tidak null. Perlakukan dia sebagai nilai yang tidak nullable.”

Jadi:

result
  ↓
Int?
  ↓
result!!
  ↓
Int

Kemudian:

result!! + 1

menjadi:

30 + 1

hasilnya:

31

6. Apa arti “assertion”?

Kata assertion kurang lebih berarti kita membuat sebuah pernyataan/penegasan.

Ketika menulis:

result!!

kita sedang menegaskan:

“Saya menjamin bahwa result tidak null.”

Kotlin kemudian memperlakukan result sebagai non-null.

Misalnya:

var result: Int? = 30

val resultPlusOne: Int = result!! + 1

Sekarang resultPlusOne adalah:

Int

bukan:

Int?

Karena !! sudah mengatakan bahwa result dianggap tidak null.

7. Tetapi !! berbahaya

Nah, ini bagian sangat penting dari video.

!! bukan berarti:

“Ubah null menjadi nilai.”

Bukan.

!! berarti:

“Saya yakin nilai ini tidak null.”

Kalau ternyata keyakinan kita salah, program akan crash.

Contohnya:

var result: Int? = null

println(result!! + 1)

Kita mengatakan:

“Kotlin, saya yakin result tidak null.”

Padahal kenyataannya:

result = null

Maka Kotlin akan menghasilkan:

NullPointerException

atau sering disingkat:

NPE

8. Apa itu NullPointerException?

Ini adalah error yang sangat umum dalam pemrograman.

Secara sederhana:

Kita mencoba menggunakan sesuatu yang ternyata null.

Contohnya:

var result: Int? = null

println(result!! + 1)

Kotlin menjalankan:

result!!

Tetapi:

result = null

Jadi Kotlin berkata kira-kira:

“Kamu bilang nilainya pasti ada, ternyata tidak ada.”

Akhirnya:

NullPointerException

9. Compile time vs Runtime

Video juga membahas perbedaan penting antara compile time dan runtime.

Compile time

Ketika kita menulis:

var result: Int? = 30

println(result + 1)

IDE seperti IntelliJ akan langsung menunjukkan error.

Program bahkan belum dijalankan.

Ini disebut masalah pada:

compile time

Kotlin berkata:

❌ Tidak boleh.
result adalah Int?, bukan Int.

Ini sebenarnya bagus karena Kotlin membantu kita menemukan kesalahan lebih awal.

Runtime

Sekarang kita menggunakan:

var result: Int? = null

println(result!! + 1)

Kode tersebut bisa lolos dari pemeriksaan compiler karena kita sudah mengatakan:

!!

Tetapi ketika program dijalankan, ternyata result adalah null.

Maka:

💥 NullPointerException

Ini terjadi pada:

runtime

10. Jadi !! seperti membuat janji kepada Kotlin

Cara mudah mengingatnya:

result!!

seolah-olah kita berkata:

“Kotlin, percaya saya. Ini pasti tidak null.”

Kalau ternyata benar:

result = 30

aman.

Kalau ternyata:

result = null

💥 NullPointerException

Karena itulah penggunaan !! harus hati-hati.

11. Contoh perbandingan

Tanpa !!

var result: Int? = 30

println(result + 1)

❌ Error saat compile.

Karena Kotlin tidak tahu apakah result null atau tidak.

Dengan !!

var result: Int? = 30

println(result!! + 1)

✅ Bisa dijalankan.

Hasil:

31

Tetapi kalau ternyata null

var result: Int? = null

println(result!! + 1)

💥 Runtime error:

NullPointerException

12. Kenapa video menyarankan jangan terlalu sering menggunakan !!?

Karena !! pada dasarnya mengatakan:

“Saya tahu lebih baik daripada compiler.”

Misalnya:

var age: Int? = null

println(age!! + 1)

Kita memaksa Kotlin menganggap age tidak null.

Tetapi kenyataannya null.

Akibatnya program crash.

Padahal ada cara yang lebih aman untuk menangani nullable.

13. Cara yang lebih aman: cek null terlebih dahulu

Misalnya:

var result: Int? = 30

if (result != null) {
    println(result + 1)
}

Di sini kita mengatakan:

“Kalau result tidak null, baru tambahkan 1.”

Kalau:

result = 30

hasil:

31

Kalau:

result = null

blok if tidak dijalankan.

Tidak terjadi NullPointerException.

Ini jauh lebih aman.

Dan Kotlin mempunyai kemampuan yang disebut smart cast untuk membantu kita dalam kondisi seperti ini.

14. Apa itu smart cast?

Misalnya:

var result: Int? = 30

if (result != null) {
    println(result + 1)
}

Sebelum if:

result → Int?

Di dalam:

if (result != null)

Kotlin mengetahui:

result ≠ null

Maka di dalam blok tersebut Kotlin bisa memperlakukan result sebagai:

Int

bukan lagi:

Int?

Inilah yang disebut smart cast.

Secara sederhana:

Sebelum pengecekan
       ↓
   Int?

       ↓
  if (result != null)

       ↓

Kotlin tahu result
tidak null

       ↓

   Int

15. Analogi sederhana

Bayangkan kamu mempunyai sebuah kotak:

┌─────────────┐
│             │
│     30      │
│             │
└─────────────┘

Kamu belum tahu apakah kotak tersebut kosong.

Kamu bertanya:

“Apakah kotak ini kosong?”

Kalau jawabannya:

“Tidak.”

Barulah kamu mengambil isinya dan menggunakannya.

Dalam Kotlin:

if (result != null) {
    println(result + 1)
}

Sedangkan !! seperti mengatakan:

“Saya tidak mau mengecek. Saya yakin kotaknya tidak kosong.”

Kemudian ternyata kosong.

💥 Masalah.

16. Ringkasan operator yang sudah kita temui

Untuk saat ini, ingat tiga hal berikut:

? → nullable

var result: Int? = null

Artinya:

result boleh Int atau null.

!! → paksa dianggap tidak null

result!!

Artinya:

“Saya yakin result tidak null.”

Jika ternyata null:

💥 NullPointerException

!= null → cek apakah tidak null

if (result != null) {
    println(result + 1)
}

Artinya:

“Kalau result tidak null, gunakan nilainya.”

Ini lebih aman daripada langsung menggunakan !!.

17. Gambaran keseluruhan

Kalau dibuat menjadi alur:

var result: Int? = 30
             │
             ▼
        result adalah
        nullable Int
             │
             ▼
      Bisa berisi 30
        atau null
             │
       ┌─────┴─────┐
       │           │
     30           null
       │           │
       ▼           ▼
   bisa dipakai   harus
   sebagai Int    ditangani

Kalau kita menggunakan:

result!!

kita berkata:

"Anggap saja ini pasti tidak null."

Kalau benar:

30 → aman

Kalau salah:

null → 💥 NullPointerException

Sedangkan:

if (result != null)

lebih aman:

30 → gunakan
null → jangan gunakan

18. Kesimpulan paling penting

Materi video ini sebenarnya ingin kamu memahami mengapa Kotlin tidak membolehkan nullable digunakan sembarangan.

Misalnya:

var result: Int? = 30

Kotlin tahu bahwa suatu saat:

result = null

Karena itu:

result + 1

❌ tidak diperbolehkan.

Kita bisa menggunakan:

result!! + 1

tetapi kita mengambil risiko NullPointerException.

Cara yang lebih aman adalah:

if (result != null) {
    println(result + 1)
}

Dan Kotlin akan menggunakan smart cast sehingga di dalam if, result diperlakukan sebagai Int.

Hafalkan pola ini:

?   → boleh null

!!  → "Saya yakin tidak null"
      ⚠️ bisa menyebabkan NPE

!= null
    → cek dulu
      ✅ lebih aman

Jadi, !! bukan alat untuk menghilangkan null. Ia hanya memberi tahu compiler bahwa kita menjamin nilai tersebut tidak null. Kalau ternyata null, program akan gagal saat runtime.