Pada bagian ini, materi mulai masuk ke konsep yang sangat penting dalam Kotlin, yaitu variable (var), perbedaannya dengan val, serta cara memberi nama variable yang baik.

Saya akan jelaskan dari dasar, termasuk beberapa bagian subtitle yang kurang tepat secara teknis.

1. Apa yang dimaksud dengan Variable?

Bayangkan kita sedang membuat program untuk rekening bank.

Saldo rekening bisa berubah:

Saldo awal  : 1.000.000
Tarik uang  :   200.000
Saldo baru  :   800.000

Karena nilainya bisa berubah, kita membutuhkan variable.

Di Kotlin, variable dibuat menggunakan keyword:

var

Contoh:

var balance: Int = 1000000

Artinya:

Buat sebuah variable bernama balance, bertipe Int, dan nilai awalnya 1000000.

Kemudian nilainya bisa diubah:

balance = 800000

Dan bisa diubah lagi:

balance = 1200000

Selama nilai barunya masih sesuai dengan tipe Int.

2. var vs val

Ini bagian paling penting dari video.

Kotlin memiliki dua keyword yang sering digunakan untuk membuat variable:

val
var

Perbedaannya:

Contoh val:

val age = 20

Setelah itu kita tidak bisa:

age = 21

❌ Error.

Sedangkan dengan var:

var age = 20

Kita bisa:

age = 21

Kemudian:

age = 22

Dan seterusnya.

Cara mudah mengingat

Anggap:

val = “nilai ini tidak boleh saya assign ulang.”

var = “nilai ini boleh saya assign ulang.”

3. Contoh menggunakan rekening bank

Misalnya:

var balance: Int = 1000000

Awalnya saldo:

balance
   ↓
1.000.000

Kemudian kita melakukan penarikan:

balance = 800000

Sekarang:

balance
   ↓
800.000

Kemudian mendapat transfer:

balance = 1500000

Sekarang:

balance
   ↓
1.500.000

Inilah kegunaan var.

Data yang disimpan oleh variable tersebut bisa berubah selama program berjalan.

4. Bagaimana cara membuat var?

Bentuk umum:

var namaVariable: TipeData = nilai

Contoh:

var age: Int = 20

Mari kita pecah:

var age: Int = 20
│   │    │     │
│   │    │     └── nilai awal
│   │    └──────── tipe data
│   └───────────── nama variable
└───────────────── keyword variable

Jadi:

• var → kita membuat variable yang bisa diubah
• age → nama variable
• Int → tipe datanya
• 20 → nilai awal

5. Variable boleh diubah, tetapi tipe datanya harus sesuai

Misalnya kita punya:

var variableNumber: Int = 99

Kita boleh mengubahnya menjadi:

variableNumber = 100

Boleh:

variableNumber = 55

Boleh:

variableNumber = 1000

Karena semuanya adalah bilangan bulat (Int).

Tetapi kita tidak boleh melakukan:

variableNumber = "Hello"

❌ Error.

Kenapa?

Karena variableNumber sudah dideklarasikan sebagai:

Int

sedangkan "Hello" adalah:

String

Kotlin akan mengatakan kira-kira:

Type mismatch: required Int, found String.

Artinya:

“Saya membutuhkan Int, tetapi kamu memberikan String.”

6. Analogi sederhana

Bayangkan variable adalah kotak.

Kita membuat:

var age: Int = 20

Anggap:

┌──────────────────┐
│ age              │
│                  │
│       20         │
└──────────────────┘

Karena kotak age dibuat untuk menyimpan Int, kita boleh mengganti:

20 → 25 → 30 → 40

Tetapi tidak boleh:

20 → "John"

Karena "John" adalah String, bukan Int.

Jadi var berarti:

Isi kotaknya boleh diganti, tetapi jenis barang yang boleh dimasukkan tetap mengikuti tipe datanya.

7. var bukan berarti tipe datanya bisa berubah

Ini kesalahan pemahaman yang cukup umum bagi pemula.

Misalnya:

var number: Int = 10

Banyak pemula mungkin berpikir:

“var berarti saya bisa memasukkan apa saja.”

❌ Bukan begitu.

var hanya berarti:

nilai yang disimpan boleh diubah.

Tipe datanya tetap:

Int

Jadi:

number = 20

✅

number = 100

✅

number = "Hello"

❌

8. Bagaimana dengan String?

Variable tidak hanya bisa menyimpan angka.

Misalnya:

var personName: String = "John"

Artinya kita mempunyai variable:

Nama       : personName
Tipe data  : String
Nilai      : "John"

Karena menggunakan var, kita bisa menggantinya:

personName = "Michael"

Kemudian:

personName = "David"

Kemudian:

personName = "Sarah"

Semua valid karena semuanya String.

9. var dan val sebenarnya sangat mirip

Perhatikan dua kode berikut:

val personName: String = "John"

dan:

var personName: String = "John"

Strukturnya hampir sama.

Perbedaannya hanya:

val → tidak bisa di-assign ulang
var → bisa di-assign ulang

Contoh:

Menggunakan val

val personName = "John"

personName = "David" // ❌

Menggunakan var

var personName = "John"

personName = "David" // ✅

10. Kapan harus menggunakan var?

Gunakan var ketika nilai memang perlu berubah.

Contohnya:

Umur

var age = 20

Beberapa tahun kemudian:

age = 21

Saldo

var balance = 1000000

Setelah transaksi:

balance = 750000

Score game

var score = 0

Ketika pemain mendapatkan poin:

score = 100

Kemudian:

score = 250

11. Kapan menggunakan val?

Kalau kita tidak perlu melakukan reassignment, lebih baik gunakan val.

Misalnya:

val name = "John"

Jika nama tersebut tidak perlu diganti selama bagian program tersebut berjalan, gunakan val.

Contoh lain:

val birthYear = 2000

Tidak perlu:

var birthYear = 2000

jika memang tidak pernah akan diubah.

Prinsip sederhana untuk pemula

Biasakan:

Mulai dengan val. Kalau ternyata nilainya memang perlu diubah, gunakan var.

Ini merupakan kebiasaan yang baik dalam Kotlin.

12. Penting: var bukan “variable”, val bukan “constant” secara mutlak

Subtitle video sedikit menyederhanakan istilah ini.

Sering kali materi pemula mengatakan:

val = constant
var = variable

Sebagai konsep awal, ini cukup membantu.

Tetapi secara teknis, val bukan berarti compile-time constant.

Untuk constant yang benar-benar merupakan compile-time constant, Kotlin memiliki:

const val

Contoh:

const val PI = 3.14159

Jadi lebih tepat:

var       → variable yang bisa di-reassign
val       → reference/property yang tidak bisa di-reassign
const val → compile-time constant

Untuk tahap sekarang, cukup ingat:

var → boleh ganti nilai
val → tidak boleh assign ulang
const val → konstanta compile-time

13. Naming variable sangat penting

Video kemudian membahas sesuatu yang sering dianggap sepele oleh pemula:

Nama variable.

Contoh buruk:

var x = 20

Kita mungkin tahu x adalah apa saat baru menulisnya.

Tetapi beberapa bulan kemudian:

var x = 20

Kita bisa bertanya:

“20 ini apa?”

Umur?

Jumlah mahasiswa?

Score?

Tahun lahir?

Jumlah produk?

Tidak jelas.

14. Gunakan nama yang bermakna

Daripada:

var x = 20

lebih baik:

var age = 20

Sekarang langsung terlihat:

age = umur

Atau:

var studentCount = 30

Kita langsung tahu:

studentCount = jumlah mahasiswa

Contoh lainnya:

var grade = 90

Lebih jelas daripada:

var x = 90

15. Kenapa nama variable penting?

Karena kode yang bagus harus mudah dibaca manusia, bukan hanya bisa dijalankan komputer.

Bandingkan:

var x = 25
var y = 80
var z = 100000

dengan:

var age = 25
var studentGrade = 80
var accountBalance = 100000

Versi kedua jauh lebih mudah dipahami.

Kita bahkan tidak perlu komentar tambahan untuk mengetahui maksudnya.

16. Nama variable bisa menjadi “dokumentasi”

Misalnya:

var accountBalance = 500000

Dari nama tersebut kita sudah mengetahui:

Ini kemungkinan adalah saldo rekening.

Bandingkan:

var x = 500000

Kita tidak tahu x itu apa.

Karena itu, video mengatakan:

Good names can act as documentation.

Artinya:

Nama yang baik dapat membantu menjelaskan kode itu sendiri.

17. Aturan penamaan yang digunakan Kotlin

Video menyebut istilah “Pascal writing”, tetapi ada sedikit kekeliruan istilah.

Untuk variable Kotlin, biasanya kita menggunakan camelCase.

Contoh:

var personAge = 20

Bukan:

var personage = 20

dan bukan:

var PersonAge = 20

Camel case

Kata pertama menggunakan huruf kecil:

person

Kata berikutnya diawali huruf kapital:

Age

Digabung:

personAge

Contoh lainnya:

studentCount
accountBalance
firstName
lastName
birthYear
totalPrice
phoneNumber

18. Jangan tertukar dengan PascalCase

camelCase:

personAge
studentCount
accountBalance

Biasanya digunakan untuk:

• variable
• property
• function

Sedangkan PascalCase:

Person
Student
BankAccount
UserProfile

Biasanya digunakan untuk:

• class
• interface
• object tertentu

Contoh:

class BankAccount

Tetapi:

var accountBalance = 100000

Jadi:

BankAccount       → PascalCase
accountBalance    → camelCase

19. Contoh variable yang bagus dan buruk

❌ Kurang bagus

var x = 20
var a = 10
var n = 100
var v1 = "John"

Masalahnya kita tidak tahu maksudnya.

✅ Lebih bagus

var age = 20
var studentCount = 10
var score = 100
var personName = "John"

Lebih mudah dibaca.

20. Contoh dengan berbagai tipe data

Kita bisa membuat variable dengan berbagai tipe.

Int

var age: Int = 20

String

var personName: String = "John"

Float

var temperature: Float = 3.45f

Perhatikan f di belakang:

3.45f

Ini menunjukkan bahwa literal tersebut adalah Float.

21. Ada kesalahan pada contoh “boiling point”

Video memberikan:

var boilingPoint: Float = 3.45

Untuk Kotlin, ini perlu diperhatikan.

Jika tipenya Float, biasanya harus ditulis:

var boilingPoint: Float = 3.45f

Sedangkan:

3.45

secara default merupakan Double.

Jadi:

var boilingPoint: Float = 3.45

dapat menghasilkan type mismatch.

Yang benar:

var boilingPoint: Float = 3.45f

atau jika ingin menggunakan Double:

var boilingPoint: Double = 3.45

22. Kotlin juga punya Type Inference

Kita sebenarnya tidak selalu harus menulis tipe data secara manual.

Misalnya:

var age: Int = 20

Kita bisa menulis:

var age = 20

Kotlin akan mengetahui bahwa 20 adalah Int.

Begitu juga:

var name = "John"

Kotlin tahu:

name → String

Dan:

var price = 99.5

Kotlin akan menginfer tipe yang sesuai, umumnya Double.

Jadi dua bentuk berikut sama-sama valid:

var age: Int = 20

dan:

var age = 20

Untuk kode sehari-hari, type inference sering membuat kode Kotlin lebih ringkas.

23. Gambaran besar konsepnya

Sekarang kita bisa melihat hubungan semuanya:

                    DATA
                     │
                     ▼
                VARIABLE
                     │
             ┌───────┴───────┐
             │               │
            val             var
             │               │
       tidak bisa        bisa diubah
       assign ulang      assign ulang
             │               │
             ▼               ▼
        val age = 20    var age = 20
                            │
                            ▼
                         age = 21

24. Contoh program lengkap

Misalnya kita membuat program sederhana tentang mahasiswa:

fun main() {
    var studentName = "John"
    var studentAge = 20
    var studentGrade = 80

    println(studentName)
    println(studentAge)
    println(studentGrade)

    studentAge = 21
    studentGrade = 90

    println(studentAge)
    println(studentGrade)
}

Awalnya:

studentName  = John
studentAge   = 20
studentGrade = 80

Kemudian:

studentAge = 21
studentGrade = 90

Nilainya berubah menjadi:

studentName  = John
studentAge   = 21
studentGrade = 90

Karena studentAge dan studentGrade dibuat menggunakan var, keduanya boleh diubah.

25. Contoh penggunaan val dan `var bersamaan

Dalam program nyata, kita sering menggunakan keduanya.

fun main() {
    val studentName = "John"
    val birthYear = 2005

    var age = 20
    var score = 80

    age = 21
    score = 95

    println(studentName)
    println(birthYear)
    println(age)
    println(score)
}

Kenapa studentName menggunakan val?

Karena kita tidak ingin melakukan:

studentName = "David"

Kenapa age menggunakan var?

Karena umur bisa berubah:

20 → 21 → 22 → 23

Kenapa score menggunakan var?

Karena nilai mahasiswa bisa berubah:

80 → 85 → 95

26. Hal penting: “data berubah” tidak selalu berarti harus var

Ada satu konsep yang perlu kamu pahami perlahan.

val berarti variable/reference-nya tidak bisa di-assign ulang.

Misalnya:

val numbers = mutableListOf(1, 2, 3)

Kita tidak bisa:

numbers = mutableListOf(4, 5, 6)

❌

Tetapi kita masih bisa mengubah isi list:

numbers.add(4)

✅

Jadi val tidak otomatis berarti seluruh objek di dalamnya “tidak bisa berubah”.

Untuk materi dasar sekarang, cukup pegang aturan sederhana:

val mencegah reassignment nama tersebut, sedangkan var mengizinkan reassignment.

Nanti ketika belajar List, Object, Class, dan Mutable Collections, konsep ini akan menjadi lebih jelas.

27. Koreksi beberapa bagian subtitle

Ada beberapa bagian subtitle/video yang sebaiknya kamu catat.

❌ “don’t use val when you change data”

Untuk pemula, maksudnya bisa dipahami sebagai:

Kalau variable perlu di-assign ulang, gunakan var.

Lebih tepat secara teknis:

Gunakan var jika referensinya perlu di-assign ulang.

❌ “Pascal writing” untuk personAge

personAge bukan PascalCase.

Itu adalah:

camelCase.

camelCase    → personAge
PascalCase   → PersonAge

Untuk variable Kotlin, gunakan:

personAge

❌ Float 3.45

Sebaiknya:

var boilingPoint: Float = 3.45f

bukan:

var boilingPoint: Float = 3.45

Karena 3.45 biasanya diperlakukan sebagai Double.

28. Ringkasan super penting

Kalau kamu baru belajar Kotlin, hafalkan bagian ini dulu:

var

var age = 20

age = 21
age = 22

Boleh diubah.

val

val age = 20

age = 21 // ❌

Tidak boleh di-assign ulang.

Tipe harus sesuai

var age: Int = 20

age = 25       // ✅
age = "John"   // ❌

Gunakan nama yang jelas

❌

var x = 20

✅

var studentAge = 20

Gunakan camelCase untuk variable

✅

var personAge = 20
var studentCount = 30
var accountBalance = 100000

Untuk Float

var number: Float = 3.14f

Perhatikan f.

🧠 Cara paling mudah mengingat materi ini

Bayangkan kamu punya kotak bernama age.

var age = 20

Kotaknya boleh diganti isinya:

20 → 21 → 22 → 23

Karena menggunakan var.

Sedangkan:

val birthYear = 2000

anggap nama/referensinya tidak boleh kamu assign ulang:

birthYear → 2000

Tidak boleh:

birthYear → 2001

Jadi inti video ini sebenarnya hanya tiga hal besar:

1. var digunakan ketika nilai perlu di-assign ulang. 2. Nilai baru harus sesuai dengan tipe datanya. 3. Berikan nama variable yang jelas dan gunakan camelCase.

Setelah memahami ini, fondasi untuk materi berikutnya seperti String, Boolean, operator, input, conditional (if), dan loop akan jauh lebih mudah.