Lesson ini membahas function overloading, yaitu kemampuan Kotlin untuk memiliki beberapa function dengan nama yang sama, tetapi dengan parameter yang berbeda.

Lesson ini sebenarnya melanjutkan langsung dari yang sebelumnya:

function
   ↓
parameter
   ↓
return value
   ↓
sekarang: function overloading

Konsep utamanya sangat sederhana:

Satu nama function dapat memiliki beberapa versi, selama daftar parameternya berbeda.

Mari kita bahas perlahan.

1. Masalah yang Ingin Diselesaikan

Instruktur mulai dengan contoh function:

fun displayNumber(value: Int) {
    println("You entered $value")
}

Function ini hanya menerima:

Int

Jadi:

displayNumber(6)

valid.

Output:

You entered 6

Tetapi bagaimana kalau user memberikan:

displayNumber("6")

?

"6" adalah String, bukan Int.

Maka akan terjadi type mismatch.

Ingat:

6   → Int
"6" → String

Ini sama seperti yang sudah kamu pelajari sebelumnya tentang type system Kotlin.

2. Mengapa Tidak Membuat Function Berbeda?

Kita mungkin berpikir:

fun displayNumber(value: Int) {
    println("You entered $value")
}

fun displayLetters(value: String) {
    println("You entered $value")
}

Ini bisa bekerja.

Untuk:

displayNumber(6)

kita memanggil function pertama.

Untuk:

displayLetters("6")

kita memanggil function kedua.

Tetapi ada masalah dari sisi desain API.

Kita sekarang punya dua nama:

displayNumber
displayLetters

Padahal sebenarnya tugas keduanya sama:

menampilkan nilai yang diberikan user.

Kita tidak ingin caller harus tahu apakah inputnya Int atau String lalu memilih nama function yang berbeda secara manual.

Di sinilah overloading berguna.

3. Apa Itu Function Overloading?

Function overloading berarti:

membuat beberapa function dengan nama yang sama tetapi parameter list yang berbeda.

Contoh:

fun displayNumber(value: Int) {
    println("You entered $value")
}

fun displayNumber(value: String) {
    println("You entered $value")
}

Perhatikan.

Nama function keduanya sama:

displayNumber

Tetapi parameternya berbeda:

value: Int

dan:

value: String

Inilah yang disebut function overloading.

4. Kenapa Kotlin Tidak Bingung?

Mungkin kamu bertanya:

“Kalau namanya sama, bagaimana compiler tahu saya memanggil yang mana?”

Jawabannya:

Kotlin melihat argument yang kita kirim dan mencocokkannya dengan parameter function yang tersedia.

Contoh:

displayNumber(6)

Kotlin melihat:

6 = Int

Maka yang dipilih:

fun displayNumber(value: Int)

Sedangkan:

displayNumber("6")

Kotlin melihat:

"6" = String

Maka yang dipilih:

fun displayNumber(value: String)

Jadi kira-kira:

displayNumber(6)
       ↓
argument = Int
       ↓
displayNumber(Int)


displayNumber("6")
       ↓
argument = String
       ↓
displayNumber(String)

5. Analogi Sederhana: Loket

Bayangkan ada satu loket bernama:

DISPLAY

Tetapi loket tersebut punya dua jalur.

DISPLAY
 ├── menerima angka
 └── menerima teks

Kalau kamu datang membawa:

25

petugas memilih jalur angka.

Kalau kamu membawa:

"Hello"

petugas memilih jalur teks.

Kamu tetap datang ke loket yang sama:

DISPLAY

Itulah gambaran sederhana dari overloading.

6. Contoh Pertama

fun displayNumber(value: Int) {
    println("You entered number: $value")
}

fun displayNumber(value: String) {
    println("You entered text: $value")
}

Sekarang:

fun main() {
    displayNumber(6)
    displayNumber("6")
}

Output:

You entered number: 6
You entered text: 6

Meskipun:

displayNumber

ditulis dua kali, Kotlin tahu function mana yang digunakan.

7. Parameter Itu Kunci Overloading

Sebelumnya kamu sudah belajar:

fun greet(name: String)

Sekarang kita punya:

fun greet(name: String)
fun greet(age: Int)

Keduanya mempunyai nama:

greet

tetapi parameter berbeda.

Jadi:

Nama sama
+
Parameter berbeda
=
Function overloading

8. Overloading Bisa Berdasarkan Tipe Parameter

Contoh:

fun display(value: Int) {
    println("Int: $value")
}

fun display(value: String) {
    println("String: $value")
}

Maka:

display(10)

memilih:

fun display(value: Int)

Sedangkan:

display("Hello")

memilih:

fun display(value: String)

Jadi salah satu cara overloading adalah:

tipe parameter berbeda.

9. Overloading Juga Bisa Berdasarkan Jumlah Parameter

Ini bagian kedua yang ditekankan instruktur.

Misalnya:

fun displayNumber(value: Int) {
    println("You entered $value")
}

fun displayNumber(value1: Int, value2: Int) {
    println("You entered $value1 and $value2")
}

Nama function tetap:

displayNumber

Tetapi jumlah parameternya berbeda.

Versi pertama:

1 parameter

Versi kedua:

2 parameter

10. Cara Memanggilnya

Kalau:

displayNumber(6)

Kotlin memilih function:

fun displayNumber(value: Int)

Karena hanya ada satu argument.

Sedangkan:

displayNumber(14, 7)

Kotlin memilih:

fun displayNumber(value1: Int, value2: Int)

karena ada dua argument.

Visualisasinya:

displayNumber(6)
       ↓
1 argument
       ↓
function dengan 1 parameter


displayNumber(14, 7)
       ↓
2 arguments
       ↓
function dengan 2 parameter

11. Sekarang Ada Tiga Function dengan Nama Sama

Contoh lengkap seperti yang dijelaskan dalam video:

fun displayNumber(value: Int) {
    println("You entered $value")
}

fun displayNumber(value: String) {
    println("You entered $value")
}

fun displayNumber(value1: Int, value2: Int) {
    println("You entered $value1 and $value2")
}

Sekarang kita mempunyai:

Function 1

displayNumber(Int)

Function 2

displayNumber(String)

Function 3

displayNumber(Int, Int)

Nama semuanya sama:

displayNumber

Tetapi signature/parameter list berbeda.

12. Contoh Pemanggilan

fun main() {
    displayNumber(6)
    displayNumber("6")
    displayNumber(14, 7)
}

Kotlin akan memilih:

displayNumber(6)
     ↓
displayNumber(Int)

displayNumber("6")
     ↓
displayNumber(String)

displayNumber(14, 7)
     ↓
displayNumber(Int, Int)

Output:

You entered 6
You entered 6
You entered 14 and 7

13. Ini Bukan Function yang Sama Persis

Meskipun namanya sama, secara teknis ini bukan satu function yang identik.

Kita bisa membayangkannya sebagai:

displayNumber(Int)

displayNumber(String)

displayNumber(Int, Int)

Jadi nama displayNumber saja belum cukup untuk mengidentifikasi function.

Kombinasi:

nama + parameter

membantu menentukan function mana yang dimaksud.

14. Apa yang Dimaksud “Parameter List”?

Parameter list adalah daftar parameter dalam deklarasi function.

Contoh:

fun test(a: Int)

parameter list:

(Int)

Sedangkan:

fun test(a: Int, b: Int)

parameter list:

(Int, Int)

Dan:

fun test(a: String)

parameter list:

(String)

Ketiganya berbeda.

15. Contoh yang Valid untuk Overloading

Berdasarkan tipe

fun printValue(value: Int)
fun printValue(value: String)
fun printValue(value: Double)

Valid.

Karena tipe parameternya berbeda.

Berdasarkan jumlah

fun printValue(value: Int)
fun printValue(value1: Int, value2: Int)

Valid.

Karena jumlah parameter berbeda.

Kombinasi keduanya

fun printValue(value: Int)
fun printValue(value: String)
fun printValue(value1: Int, value2: Int)
fun printValue(value1: Int, value2: String)

Juga bisa valid karena parameter list berbeda.

16. Contoh yang Tidak Valid

Ini tidak boleh:

fun display(value: Int) {
    println("A")
}

fun display(value: Int) {
    println("B")
}

Kenapa?

Karena bagi compiler kedua function terlihat seperti:

display(Int)
display(Int)

Tidak ada pembeda.

Ketika kita menulis:

display(10)

compiler tidak tahu harus memilih yang mana.

Maka deklarasi seperti ini konflik.

17. Nama Parameter Tidak Menjadi Pembeda

Misalnya:

fun display(age: Int) {
}

fun display(number: Int) {
}

Ini tetap tidak bisa.

Karena:

display(Int)
display(Int)

Bagi compiler, parameter name age vs number tidak membuat signature overload menjadi berbeda.

Jadi ini bukan pembeda:

age vs number

Yang penting adalah struktur parameter yang relevan untuk menentukan overload, terutama jumlah dan tipe parameter.

18. Return Type Saja Tidak Cukup untuk Overloading

Ini juga penting.

Kamu tidak bisa membuat overload hanya dengan mengubah return type.

Misalnya:

fun getValue(): Int {
    return 10
}

fun getValue(): String {
    return "10"
}

Ini tidak dapat dibedakan hanya berdasarkan return type.

Jadi bukan:

nama + return type

yang menjadi dasar overload.

Melainkan parameter list.

19. Hubungan dengan Lesson Sebelumnya

Sebelumnya kamu belajar:

fun multiply(a: Int, b: Int): Int {
    return a * b
}

Sekarang kita bisa memiliki beberapa versi:

fun multiply(a: Int, b: Int): Int {
    return a * b
}

fun multiply(a: Double, b: Double): Double {
    return a * b
}

Ketika:

multiply(5, 3)

Kotlin memilih versi Int.

Ketika:

multiply(5.0, 3.0)

Kotlin memilih versi Double.

Jadi overloading bisa digunakan bersama return value juga.

20. Function Overloading = Satu Konsep, Beberapa Bentuk Input

Bayangkan:

display()

adalah satu “ide pekerjaan”:

tampilkan nilai.

Tetapi pekerjaan tersebut bisa menerima berbagai bentuk input:

Int
String
dua Int

Daripada membuat nama:

displayInt()
displayString()
displayTwoNumbers()

kita bisa menggunakan:

display()
display()
display()

karena compiler bisa membedakan berdasarkan parameter.

21. Kenapa Overloading Berguna?

Keuntungan utamanya adalah API menjadi lebih natural dan mudah dipahami.

Misalnya tanpa overloading:

printInt(10)
printString("Hello")
printTwoNumbers(10, 20)

Dengan overloading:

print(10)
print("Hello")
print(10, 20)

Semua operasi memiliki konsep yang sama:

print

Caller tidak perlu menghafal banyak nama.

22. Analogi Restoran Lagi

Bayangkan restoran punya satu menu:

order(...)

Versinya:

order(Pizza)
order(Burger)
order(Pizza, 2)

Nama konsepnya tetap:

order

tetapi input berbeda.

Function overloading menggunakan ide yang mirip.

23. Hubungan dengan Type Safety Kotlin

Kotlin sangat memperhatikan type.

Misalnya:

fun display(value: Int)
fun display(value: String)

Ketika kita menulis:

display(100)

compiler tahu:

100 = Int

dan memilih overload Int.

Ketika:

display("100")

compiler tahu:

"100" = String

dan memilih overload String.

Jadi type system Kotlin membantu menentukan overload yang tepat.

24. Bagaimana Compiler Berpikir?

Secara sederhana, jangan bayangkan compiler benar-benar “mencoba function satu per satu” seperti manusia.

Untuk pemahaman beginner, bayangkan prosesnya seperti:

Kita menulis:
displayNumber(6)

        ↓

Compiler melihat semua displayNumber yang tersedia

        ↓

Ada:
displayNumber(Int)
displayNumber(String)
displayNumber(Int, Int)

        ↓

Argument = Int

        ↓

yang cocok:
displayNumber(Int)

        ↓

Function tersebut dipilih

Untuk:

displayNumber(14, 7)

compiler melihat:

2 arguments

dan menemukan:

displayNumber(Int, Int)

25. Named Arguments dan Overloading

Kamu sebelumnya sudah belajar named arguments:

printWelcome(
    name = "Ali",
    rating = 5
)

Dengan overloading, named argument kadang membantu membuat pemanggilan lebih jelas, tetapi nama parameter sendiri bukanlah dasar utama untuk membedakan overload seperti tipe/jumlah parameter.

Contoh:

fun test(value: Int) {}
fun test(value: String) {}

Kotlin tetap melihat argument:

10       → Int
"Hello"  → String

26. Contoh Lebih Realistis

Misalnya kita mempunyai function:

fun greet(name: String) {
    println("Hello $name")
}

fun greet(name: String, age: Int) {
    println("Hello $name, you are $age years old")
}

Sekarang:

greet("Andi")

menggunakan:

greet(String)

Sedangkan:

greet("Andi", 20)

menggunakan:

greet(String, Int)

Ini contoh overloading berdasarkan jumlah parameter.

27. Contoh yang Menggabungkan Berbagai Tipe

fun process(value: Int) {
    println("Integer: $value")
}

fun process(value: String) {
    println("String: $value")
}

fun process(value: Double) {
    println("Double: $value")
}

Pemanggilan:

process(10)
process("10")
process(10.5)

Masing-masing memilih overload yang sesuai.

Perhatikan kembali:

10
→ Int

"10"
→ String

10.5
→ Double

28. Overloading Tidak Berarti Function Harus Punya Implementasi Sama

Ini juga penting.

Misalnya:

fun calculate(value: Int): Int {
    return value * 2
}

fun calculate(value: String): String {
    return value.uppercase()
}

Nama sama:

calculate

Tetapi perilakunya boleh berbeda karena jenis data yang diproses berbeda.

Jadi overloading berarti:

satu nama untuk beberapa bentuk operasi yang secara konsep berkaitan.

Bukan berarti isi function harus identik.

29. Bedakan Overloading dengan Reassignment

Jangan sampai tertukar.

Ini:

fun display(value: Int)
fun display(value: String)

adalah overloading.

Sedangkan:

var value = 10
value = 20

adalah reassignment variable.

Tidak berhubungan.

30. Bedakan Overloading dengan Function Calling

Deklarasi:

fun display(value: Int) {
}

membuat function.

Pemanggilan:

display(10)

menjalankan function.

Kalau ada:

fun display(value: Int) {}
fun display(value: String) {}

lalu:

display(10)

Kotlin melakukan overload resolution untuk menentukan function mana yang dipanggil.

31. Bagian yang Harus Kamu Ingat dari Video

Instruktur menekankan dua hal utama.

1. Perbedaan tipe parameter

Contoh:

fun display(value: Int)
fun display(value: String)

Berbeda karena:

Int ≠ String

2. Perbedaan jumlah parameter

Contoh:

fun display(value: Int)
fun display(value1: Int, value2: Int)

Berbeda karena:

1 parameter ≠ 2 parameter

Jadi mental model lesson ini:

Function overloading
        ↓
Nama sama
        ↓
Parameter harus berbeda
        ↓
Bisa dibedakan berdasarkan
        ├── tipe parameter
        └── jumlah parameter

32. Yang Perlu Diluruskan dari Subtitle

Ada beberapa istilah di subtitle yang perlu diperbaiki.

“method overloading”

Untuk Kotlin, lebih tepat dalam lesson ini kita sebut:

function overloading

Istilah “method overloading” lebih sering muncul ketika membahas function yang menjadi member class/object.

“overloading depends on type and number of parameters”

Untuk level lesson ini, pernyataan tersebut sudah sangat membantu.

Secara lebih tepat, signature dan aturan overload resolution Kotlin lebih kompleks daripada sekadar jumlah dan tipe parameter. Misalnya generic, receiver, nullable/type specificity, dan konteks lain bisa ikut berpengaruh.

Tetapi untuk pemula, pahami dulu:

nama sama
+
daftar parameter berbeda

“IDE knows which function”

Sebenarnya yang menentukan function mana yang dipanggil bukan IntelliJ.

Compiler Kotlin yang melakukan overload resolution.

IntelliJ membantu kita dengan autocomplete, highlighting, dan informasi parameter.

33. Contoh Final Lengkap

fun displayNumber(value: Int) {
    println("You entered number $value")
}

fun displayNumber(value: String) {
    println("You entered text $value")
}

fun displayNumber(value1: Int, value2: Int) {
    println("You entered $value1 and $value2")
}

fun main() {
    displayNumber(6)
    displayNumber("6")
    displayNumber(14, 7)
}

Output:

You entered number 6
You entered text 6
You entered 14 and 7

Kotlin memilih berdasarkan argument:

displayNumber(6)
        ↓
       Int
        ↓
displayNumber(Int)


displayNumber("6")
        ↓
      String
        ↓
displayNumber(String)


displayNumber(14, 7)
        ↓
    Int, Int
        ↓
displayNumber(Int, Int)

34. Hubungkan dengan Semua Materi Function Sampai Sekarang

Sekarang perjalananmu sudah seperti ini:

Function dasar

fun sayHello() {
    println("Hello")
}

Function dengan parameter

fun sayHello(name: String) {
    println("Hello $name")
}

Function dengan return

fun add(a: Int, b: Int): Int {
    return a + b
}

Function overloading

fun display(value: Int) {
}

fun display(value: String) {
}

Jadi kamu mulai membangun konsep function dari yang paling sederhana hingga lebih fleksibel.

35. Cheat Sheet

FUNCTION
↓
fun display(value: Int)

PARAMETER
↓
value: Int

ARGUMENT
↓
display(10)

RETURN TYPE
↓
fun add(a: Int, b: Int): Int

RETURN VALUE
↓
return a + b

OVERLOADING
↓
fun display(value: Int)
fun display(value: String)

Dan yang paling penting:

                    FUNCTION OVERLOADING
                           ↓
                    NAMA FUNCTION SAMA
                           ↓
                PARAMETER LIST BERBEDA
                    ↙               ↘
             tipe berbeda       jumlah berbeda
                    ↓               ↓
              Int vs String     1 vs 2 parameter

Mental model terakhir

Bayangkan ada:

display(...)

Kamu cukup mengingat satu nama pekerjaan: display.

Kotlin akan menentukan versi yang tepat berdasarkan data yang kamu berikan:

display(10)
   → versi Int

display("10")
   → versi String

display(10, 20)
   → versi dua Int

Jadi kalimat paling penting dari lesson ini adalah:

Function overloading memungkinkan kita memiliki beberapa function dengan nama yang sama, selama parameter list-nya berbeda, sehingga Kotlin dapat menentukan function mana yang harus dipanggil berdasarkan argument yang diberikan.