Video ini melanjutkan materi nullability Kotlin, tetapi sekarang fokusnya pada cara yang lebih aman untuk menangani null, yaitu null check + smart cast.

Kalau video sebelumnya membahas !!, video ini pada dasarnya mengajarkan:

Daripada memaksa Kotlin percaya bahwa nilai tidak null dengan !!, lebih baik kita periksa dulu apakah nilainya null atau tidak.

1. Masalah yang ingin diselesaikan

Bayangkan kita meminta user memasukkan nama:

Masukkan nama:

User mengetik:

Jack

Maka kita mendapatkan:

name = "Jack"

Tetapi bagaimana kalau user tidak memasukkan apa pun?

Dalam program tertentu, hasilnya bisa dianggap:

name = null

Nah, kalau kita langsung menampilkan:

println(name)

bisa saja yang muncul:

null

Tentu kita mungkin tidak ingin menampilkan:

Hello, null

Kita ingin melakukan sesuatu seperti:

Kalau ada nama → gunakan nama tersebut.
Kalau tidak ada nama → gunakan nama lain/default.

Di sinilah null check digunakan.

2. Ingat lagi arti String?

Misalnya:

var enteredName: String? = null

Karena ada:

?

maka enteredName bisa memiliki dua kemungkinan:

"Jack"

atau:

null

Kita bisa menggambarkannya:

enteredName
     │
     ├── "Jack"
     │
     └── null

Jadi ketika menggunakan variabel String?, kita harus siap menghadapi kedua kondisi tersebut.

3. Kita melakukan pengecekan null

Caranya:

if (enteredName != null) {
    // lakukan sesuatu
}

Perhatikan:

enteredName != null

Artinya:

“Apakah enteredName TIDAK sama dengan null?”

Kalau jawabannya ya, berarti enteredName mempunyai nilai.

Misalnya:

enteredName = "Jack"

Maka:

"Jack" != null

hasilnya:

true

Sehingga kode di dalam if dijalankan.

4. Bagaimana kalau enteredName == null?

Misalnya:

enteredName = null

Kemudian:

if (enteredName != null) {
    println(enteredName)
}

Kondisinya:

null != null

hasilnya:

false

Jadi kode di dalam if tidak dijalankan.

Kita bisa menyediakan alternatif menggunakan else:

if (enteredName != null) {
    println(enteredName)
} else {
    println("Nama tidak tersedia")
}

Hasilnya akan tergantung kondisi.

Jika:

enteredName = "Jack"

hasil:

Jack

Jika:

enteredName = null

hasil:

Nama tidak tersedia

5. Inilah yang disebut Null Check

Secara sederhana:

if (enteredName != null) {
    // aman menggunakan enteredName
} else {
    // enteredName adalah null
}

Alurnya:

              enteredName
                   │
                   ▼
          ┌─────────────────┐
          │ != null ?       │
          └────────┬────────┘
                   │
             ┌─────┴─────┐
             │           │
            YES          NO
             │           │
             ▼           ▼
        gunakan nilai   null

6. Bagian paling penting: Smart Cast

Sekarang kita masuk ke konsep utama video:

Smart cast

Misalnya:

var enteredName: String? = "Jack"

if (enteredName != null) {
    println(enteredName.length)
}

Perhatikan bahwa enteredName awalnya:

String?

Secara teori, kita tidak boleh melakukan:

enteredName.length

karena mungkin null.

Tetapi di dalam:

if (enteredName != null)

Kotlin mengetahui bahwa:

enteredName ≠ null

Jadi Kotlin secara otomatis memperlakukannya sebagai:

String

bukan lagi:

String?

Inilah smart cast.

7. Smart cast dengan analogi

Bayangkan ada sebuah kotak:

┌──────────────────┐
│  enteredName     │
│                  │
│      "Jack"      │
└──────────────────┘

Awalnya kita tidak tahu apakah kotak tersebut berisi sesuatu.

Maka tipenya:

String?

Kemudian kita memeriksa:

if (enteredName != null)

Kita membuka kotak dan memastikan:

“Oh, ternyata ada isinya.”

Kotlin kemudian berkata:

“Oke, selama berada di bagian kode ini, saya tahu bahwa nilainya bukan null.”

Maka:

String?
   ↓
null check
   ↓
String

Itulah inti smart cast.

8. Contoh lengkap

Misalnya:

var enteredName: String? = "Jack"

if (enteredName != null) {
    println("Nama: $enteredName")
} else {
    println("Nama tidak tersedia")
}

Karena:

enteredName = "Jack"

maka:

enteredName != null

bernilai true.

Hasil:

Nama: Jack

Kalau:

var enteredName: String? = null

maka:

enteredName != null

bernilai false.

Hasil:

Nama tidak tersedia

9. Kenapa tidak perlu !!?

Ini perbedaan penting dengan video sebelumnya.

Cara berbahaya:

var enteredName: String? = null

println(enteredName!!.length)

Kita mengatakan:

“Saya yakin enteredName tidak null.”

Padahal ternyata:

enteredName = null

Akibatnya:

💥 NullPointerException

Sedangkan cara yang lebih aman:

var enteredName: String? = null

if (enteredName != null) {
    println(enteredName.length)
}

Kalau null:

if = false

dan kode di dalam tidak dijalankan.

Tidak terjadi NullPointerException.

10. Perbandingan !! dan Smart Cast

Contoh:

!!

println(enteredName!!.length)

Artinya:

“Saya yakin enteredName tidak null.”

Smart cast

if (enteredName != null) {
    println(enteredName.length)
}

Artinya:

“Saya akan memastikan dulu enteredName tidak null.”

Yang kedua biasanya lebih aman.

11. Bagian yang agak membingungkan di transcript: var dan val

Di akhir video ada pembahasan mengenai variabel yang tidak berubah setelah pengecekan.

Ini penting untuk memahami kapan Kotlin bisa melakukan smart cast.

Misalnya:

val name: String? = "Jack"

if (name != null) {
    println(name.length)
}

Ini aman.

Kenapa?

Karena name adalah:

val

val tidak bisa diubah setelah diberikan nilai.

Jadi setelah Kotlin mengetahui:

name != null

Kotlin bisa yakin bahwa nilai tersebut masih sama.

12. Kenapa val lebih mudah untuk smart cast?

Contoh:

val name: String? = "Jack"

if (name != null) {
    println(name.length)
}

Urutannya:

name = "Jack"
       ↓
cek name != null
       ↓
true
       ↓
name.length

Kotlin bisa percaya bahwa name tidak tiba-tiba berubah menjadi null.

13. Bagaimana dengan var?

var bisa diubah:

var name: String? = "Jack"

Secara teori kita bisa melakukan:

if (name != null) {
    // name mungkin saja diubah di tempat lain
}

Kalau nilai name bisa berubah antara pengecekan dan penggunaannya, Kotlin tidak selalu bisa melakukan smart cast dengan aman.

Inilah alasan video mengatakan bahwa nullable yang diperiksa sebaiknya tidak berubah setelah null check.

14. Kenapa Kotlin peduli dengan perubahan variabel?

Bayangkan:

var name: String? = "Jack"

if (name != null) {
    // misalnya name berubah menjadi null
    name = null

    println(name.length)
}

Awalnya:

name = "Jack"

Pengecekan:

name != null

benar.

Tetapi kemudian:

name = null

Sekarang name.length tidak aman.

Itulah sebabnya Kotlin harus berhati-hati ketika melakukan smart cast terhadap var.

15. Hubungannya dengan val

Karena:

val

tidak bisa diubah, Kotlin lebih mudah memastikan bahwa hasil null check masih valid.

Contoh:

val name: String? = "Jack"

if (name != null) {
    println(name.length)
}

Kotlin bisa berpikir:

Saya sudah cek name ≠ null.

name adalah val,
jadi nilainya tidak berubah.

Maka name.length aman.

Ini salah satu alasan val sangat sering digunakan dalam kode Kotlin.

16. Contoh kasus nyata

Misalnya kita mendapatkan data user:

val username: String? = getUsername()

Kita tidak tahu apakah getUsername() menghasilkan nama atau null.

Maka:

if (username != null) {
    println("Welcome, $username")
} else {
    println("Welcome, Guest")
}

Logikanya:

getUsername()
      │
      ▼
┌───────────────┐
│ Ada username? │
└───────┬───────┘
        │
    ┌───┴───┐
   YES      NO
    │        │
    ▼        ▼
 username   Guest

Ini pola yang sangat umum dalam aplikasi.

17. Kesalahan pemahaman yang harus dihindari

❌ String? berarti String kosong

Salah.

String?

berarti:

String atau null.

❌ null sama dengan ""

Salah.

""

adalah String kosong.

null

berarti tidak ada nilai.

❌ !! mengubah null menjadi nilai

Salah.

!! tidak mengubah:

null

menjadi sesuatu.

Ia hanya mengatakan:

“Anggap ini tidak null.”

Kalau ternyata null:

💥 NullPointerException

❌ Smart cast berarti mengubah nilai

Bukan.

Smart cast tidak mengubah nilai yang sebenarnya.

Misalnya:

val name: String? = "Jack"

tetap memiliki nilai:

"Jack"

Kotlin hanya memperlakukan tipe tersebut sebagai non-null dalam konteks yang aman setelah pengecekan.

18. Pola yang perlu kamu hafalkan

Untuk sekarang, hafalkan pola dasar ini:

val name: String? = ...

if (name != null) {
    // name aman digunakan sebagai String
    println(name.length)
} else {
    // name adalah null
    println("Nama tidak tersedia")
}

Cara membacanya:

“Saya punya name yang mungkin null. Kalau ternyata tidak null, gunakan name sebagai String. Kalau null, lakukan alternatif.”

19. Hubungkan dengan materi sebelumnya

Sekarang kita sudah mempunyai tiga konsep:

Pertama — ?

var name: String? = null

Artinya:

name boleh null.

Kedua — !!

name!!

Artinya:

“Saya menjamin name tidak null.”

⚠️ Kalau salah, bisa NPE.

Ketiga — Smart Cast

if (name != null) {
    println(name.length)
}

Artinya:

“Saya cek dulu apakah name tidak null.”

✅ Lebih aman.

20. Gambaran besarnya

Materi nullability Kotlin sejauh ini bisa kamu pahami seperti ini:

                 NULLABILITY
                      │
                      ▼
                 String?
                      │
             ┌────────┴────────┐
             │                 │
          ada nilai           null
             │                 │
             ▼                 ▼
          "Jack"           tidak ada
             │                 │
             └────────┬────────┘
                      │
              perlu ditangani
                      │
          ┌───────────┴───────────┐
          │                       │
        !!                      null check
          │                       │
   "Saya yakin                 if (x != null)
    tidak null"                     │
          │                         ▼
      ⚠️ NPE bisa              Smart Cast
        terjadi                    │
                                   ▼
                              lebih aman

Kesimpulan

Inti video ini adalah:

Ketika kita mempunyai nullable (String?), jangan langsung menganggap nilainya ada. Periksa terlebih dahulu dengan if (variable != null). Setelah pengecekan tersebut, Kotlin dapat melakukan smart cast sehingga variabel dapat digunakan sebagai tipe non-null di bagian kode yang aman.

Contoh paling penting:

val name: String? = "Jack"

if (name != null) {
    println(name.length)
}

Di sini:

name
 ↓
String?
 ↓
cek != null
 ↓
Kotlin tahu name tidak null
 ↓
Smart Cast
 ↓
String
 ↓
name.length ✅

Sedangkan:

println(name!!.length)

lebih berisiko karena kita memaksa Kotlin percaya bahwa name tidak null.

Jadi untuk prinsip sederhana:

!! = “percaya saya.” if (x != null) = “saya cek dulu.”

Dan dalam kode sehari-hari, “cek dulu” biasanya merupakan pilihan yang lebih aman.