Jika Anda adalah seorang Java developer dan ingin mempelajari Kotlin, Anda sudah memiliki fondasi yang kuat. Kotlin berjalan di atas JVM, dapat digunakan bersama Java dengan lancar, dan menggunakan banyak konsep yang akan terasa familiar bagi developer Java berpengalaman.

Namun, Kotlin juga memperkenalkan sintaks yang lebih ringkas, null safety, extension function, data class, smart cast, serta berbagai fitur bahasa modern lainnya yang dapat membuat pengembangan aplikasi menjadi lebih sederhana dan ekspresif.

Panduan ini membahas Kotlin untuk Java developer dengan membandingkan sintaks Java dan Kotlin yang umum digunakan secara berdampingan. Daripada mempelajari Kotlin dari nol, Anda dapat menggunakan pengetahuan Java yang sudah dimiliki sebagai jembatan untuk memahami Kotlin.

Mengapa Java Developer Perlu Mempelajari Kotlin?

Kotlin dirancang agar sepenuhnya kompatibel dengan Java. Artinya, Anda dapat menggunakan Kotlin dan Java secara bersamaan dalam satu proyek.

Bagi Java developer, hal ini merupakan salah satu keunggulan terbesar Kotlin.

Anda tidak perlu melupakan semua hal yang sudah dipelajari dari Java. Konsep seperti class, interface, inheritance, generic, collection, exception, dan pemrograman berorientasi objek tetap penting.

Perbedaan utamanya adalah Kotlin memungkinkan Anda mengekspresikan banyak konsep tersebut dengan kode yang jauh lebih sedikit.

Sebagai contoh, class sederhana dalam Java mungkin terlihat seperti berikut:

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Kode Kotlin yang setara dapat ditulis jauh lebih singkat:

class User(
    val name: String,
    val age: Int
)

Perilakunya serupa, tetapi Kotlin menghilangkan banyak boilerplate yang biasanya harus ditulis oleh Java developer.

---

Perbandingan Sintaks Kotlin dan Java

Cara termudah bagi Java developer untuk mempelajari Kotlin adalah dengan membandingkan sintaks Java yang sudah familiar dengan padanannya di Kotlin.

1. Variabel: var dan val

Java biasanya menggunakan deklarasi variabel secara eksplisit:

String name = "Ajy";
int age = 32;

Dalam Kotlin, Anda dapat menulis:

var name = "Ajy"
var age = 32

Kotlin menyediakan dua keyword untuk variabel:

• var — variabel yang nilainya dapat diubah
• val — variabel yang hanya dapat diisi sekali

Contoh:

var age = 32
age = 33

Sementara itu:

val name = "Ajy"

tidak dapat diisi ulang:

name = "Budi" // Error

Java developer dapat menganggap val secara konsep mirip dengan penggunaan final pada variabel lokal.

Daripada menulis:

final String name = "Ajy";

Kotlin menggunakan:

val name = "Ajy"

Sebagai aturan umum, gunakan val jika suatu nilai tidak perlu diubah.

---

2. Type Inference

Java developer sering menuliskan tipe variabel secara eksplisit:

String name = "Ajy";
int age = 32;
boolean active = true;

Kotlin mendukung type inference:

val name = "Ajy"
val age = 32
val active = true

Kotlin secara otomatis menentukan tipe berdasarkan nilai yang diberikan.

Anda tetap dapat menuliskan tipe secara eksplisit:

val name: String = "Ajy"
val age: Int = 32

Perhatikan sintaks berikut:

name: String

bukan seperti sintaks Java:

String name

Sintaks ini digunakan di berbagai bagian Kotlin.

---

3. Tipe Data Dasar

Java:

String name = "Ajy";
int age = 32;
double height = 172.5;
boolean active = true;

Kotlin:

val name: String = "Ajy"
val age: Int = 32
val height: Double = 172.5
val active: Boolean = true

Beberapa tipe data dasar yang umum digunakan di Kotlin antara lain:

• String
• Int
• Long
• Double
• Float
• Boolean
• Char
• Byte
• Short

Bagi Java developer, tipe-tipe tersebut seharusnya sudah cukup familiar.

---

4. Penggabungan String dan String Template

Java biasanya menggunakan penggabungan string:

String name = "Ajy";
int age = 32;

String message = "My name is " + name + " and I am " + age + " years old.";

Kotlin menyediakan string template:

val name = "Ajy"
val age = 32

val message = "My name is $name and I am $age years old."

Anda juga dapat mengevaluasi ekspresi di dalam ${}:

val age = 32

val message = "Next year I will be ${age + 1} years old."

Ini merupakan salah satu peningkatan sintaks sederhana yang biasanya cepat diapresiasi oleh Java developer.

---

5. Titik Koma Bersifat Opsional

Java:

String name = "Ajy";
int age = 32;

Kotlin:

val name = "Ajy"
val age = 32

Kotlin tidak mewajibkan titik koma di akhir statement.

Anda secara teknis tetap dapat menggunakannya di Kotlin, tetapi biasanya tidak diperlukan.

---

6. Statement if

Java:

if (age >= 18) {
    System.out.println("Adult");
} else {
    System.out.println("Minor");
}

Kotlin:

if (age >= 18) {
    println("Adult")
} else {
    println("Minor")
}

Sintaksnya sangat mirip.

Namun, if di Kotlin merupakan expression, sehingga dapat menghasilkan sebuah nilai.

Java developer mungkin menulis:

String status;

if (age >= 18) {
    status = "Adult";
} else {
    status = "Minor";
}

Kotlin dapat menyederhanakannya menjadi:

val status = if (age >= 18) {
    "Adult"
} else {
    "Minor"
}

Konsep ini penting ketika berpindah dari Java ke Kotlin.

---

7. when vs switch pada Java

Java menggunakan switch:

switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Unknown");
}

Kotlin menggantikan switch dengan when:

when (day) {
    1 -> println("Monday")
    2 -> println("Tuesday")
    else -> println("Unknown")
}

when juga dapat menghasilkan sebuah nilai:

val dayName = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    else -> "Unknown"
}

Hal ini membuat when berguna untuk percabangan maupun assignment nilai.

---

8. Function vs Method pada Java

Java:

public int add(int a, int b) {
    return a + b;
}

Kotlin:

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

Keyword fun digunakan untuk mendeklarasikan function.

Kotlin dapat membuatnya lebih singkat jika function hanya berisi satu expression:

fun add(a: Int, b: Int) = a + b

Tipe return dapat ditentukan secara otomatis.

Java developer mungkin merasa sintaks ini tidak biasa pada awalnya, tetapi biasanya akan cepat terbiasa.

---

9. Class dan Constructor

Java:

public class User {

    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Kotlin:

class User(
    val name: String,
    val age: Int
)

Primary constructor Kotlin dideklarasikan langsung setelah nama class.

Jika property harus dapat diubah:

class User(
    var name: String,
    var age: Int
)

Sintaks ini menghilangkan kebutuhan untuk mendeklarasikan field dan constructor secara manual dalam banyak kasus.

---

10. Getter dan Setter

Dalam Java, sebuah property biasanya membutuhkan getter dan setter:

public class User {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Kotlin menyediakan property:

class User {
    var name: String = ""
}

Anda dapat mengakses property tersebut secara langsung:

val user = User()

user.name = "Ajy"

println(user.name)

Kotlin akan membuat getter dan setter yang sesuai di balik layar.

Anda juga dapat mendefinisikan accessor khusus jika diperlukan.

---

11. Null Safety

Penanganan null merupakan salah satu perbedaan terpenting antara Java dan Kotlin.

Java developer tentu familiar dengan masalah yang disebabkan oleh null:

String name = null;

System.out.println(name.length());

Kode tersebut dapat menghasilkan NullPointerException.

Kotlin memperkenalkan sistem tipe yang dirancang agar kemungkinan nilai null dapat dinyatakan secara eksplisit.

Variabel yang tidak boleh bernilai null:

var name: String = "Ajy"

secara normal tidak dapat berisi null.

Jika sebuah variabel dapat bernilai null, Anda harus menandainya dengan ?:

var name: String? = null

Kotlin kemudian mengharuskan Anda menangani kemungkinan null tersebut.

Contohnya:

println(name?.length)

Operator ?. disebut safe-call operator.

Jika name bernilai null, Kotlin akan mengembalikan null tanpa melempar NullPointerException.

---

12. Null Check: Java vs Kotlin

Java:

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

Kotlin:

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

Kotlin juga mendukung Elvis operator:

val length = name?.length ?: 0

Artinya:

Gunakan name.length jika name tidak bernilai null; jika tidak, gunakan 0.

Kode Java yang setara biasanya lebih panjang:

int length;

if (name != null) {
    length = name.length();
} else {
    length = 0;
}

---

13. Data Class

Salah satu fitur Kotlin yang berguna bagi Java developer adalah data class.

Misalnya, Anda memiliki model Java berikut:

public class User {
    private String name;
    private int age;

    // constructor
    // getters
    // setters
    // equals()
    // hashCode()
    // toString()
}

Kotlin dapat menyederhanakannya secara signifikan:

data class User(
    val name: String,
    val age: Int
)

data class secara otomatis menyediakan fungsi seperti equals(), hashCode(), toString(), dan copy() berdasarkan property yang dimilikinya.

Fitur ini sangat berguna ketika membuat model, DTO, dan object lain yang terutama berisi data.

---

14. Collection

Java:

List<String> names = Arrays.asList("Ajy", "Budi", "Citra");

Kotlin:

val names = listOf("Ajy", "Budi", "Citra")

Untuk membuat list yang dapat diubah:

val names = mutableListOf("Ajy", "Budi")

names.add("Citra")

Kotlin juga menyediakan berbagai fungsi collection yang praktis.

Java:

List<String> result = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());

Kotlin:

val result = names.filter { it.startsWith("A") }

Ini merupakan contoh bagaimana Kotlin dapat membuat kode Java yang umum menjadi lebih ringkas.

---

15. Lambda Expression

Java modern sudah mendukung lambda expression:

names.forEach(name -> System.out.println(name));

Kotlin menggunakan konsep yang serupa:

names.forEach { name ->
    println(name)
}

Jika hanya ada satu parameter, Kotlin menyediakan parameter implisit bernama it:

names.forEach {
    println(it)
}

Sintaks ini banyak digunakan dalam aplikasi Kotlin.

---

16. Extension Function

Extension function merupakan fitur lain yang perlu dipahami oleh Java developer.

Misalnya, Anda ingin menambahkan function helper pada String.

Dalam Java, Anda mungkin membuat utility class:

public class StringUtils {
    public static boolean isLong(String value) {
        return value.length() > 10;
    }
}

Kemudian memanggilnya seperti ini:

StringUtils.isLong(name);

Kotlin memungkinkan Anda mendefinisikan extension function:

fun String.isLong(): Boolean {
    return this.length > 10
}

Anda kemudian dapat memanggilnya secara langsung:

name.isLong()

Fitur ini dapat membuat kode utility lebih mudah ditemukan dan dibaca.

---

17. Default Argument

Java sering membutuhkan overloaded method ketika Anda ingin menyediakan parameter opsional.

Contohnya:

public void greet(String name) {
    greet(name, "Hello");
}

public void greet(String name, String message) {
    System.out.println(message + " " + name);
}

Kotlin mendukung default argument:

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

Anda dapat memanggilnya seperti ini:

greet("Ajy")

atau:

greet("Ajy", "Welcome")

Fitur ini dapat menghilangkan banyak overloaded method sederhana.

---

18. Named Argument

Kotlin juga mendukung named argument.

fun createUser(
    name: String,
    age: Int,
    active: Boolean
) {
    // ...
}

Anda dapat memanggilnya seperti ini:

createUser(
    name = "Ajy",
    age = 32,
    active = true
)

Hal ini dapat membuat pemanggilan function lebih mudah dipahami, terutama ketika beberapa parameter memiliki tipe yang sama.

---

19. Perulangan for

Java:

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

Kotlin:

for (i in 0 until 5) {
    println(i)
}

Anda juga dapat melakukan iterasi pada collection:

for (name in names) {
    println(name)
}

Sintaks Kotlin yang berorientasi pada collection umumnya lebih ringkas dibandingkan perulangan tradisional di Java.

---

20. Interface

Java:

public interface Animal {
    void makeSound();
}

Kotlin:

interface Animal {
    fun makeSound()
}

Implementasi interface:

Java:

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

Kotlin:

class Dog : Animal {
    override fun makeSound() {
        println("Woof")
    }
}

Perhatikan bahwa Kotlin menggunakan : sebagai pengganti keyword implements pada Java.

---

21. Inheritance

Java:

public class Dog extends Animal {
}

Kotlin:

class Dog : Animal()

Namun, terdapat perbedaan penting.

Class di Kotlin secara default bersifat final.

Jika sebuah class dapat diwariskan, Anda harus menandainya dengan open:

open class Animal

class Dog : Animal()

Ini merupakan perbedaan penting yang perlu dipahami oleh Java developer.

---

22. Penanganan Exception

Java:

try {
    // code
} catch (Exception e) {
    e.printStackTrace();
}

Kotlin:

try {
    // code
} catch (e: Exception) {
    e.printStackTrace()
}

Sintaksnya serupa.

Namun, Kotlin tidak memiliki checked exception seperti Java.

Artinya, Anda tidak perlu mendeklarasikan exception menggunakan throws hanya karena sebuah method dapat melempar checked exception.

---

23. Interoperabilitas dengan Java

Salah satu keunggulan terbesar Kotlin adalah interoperabilitasnya dengan Java.

Kotlin dapat memanggil kode Java:

val user = JavaUser()
user.setName("Ajy")

Java juga dapat memanggil kode Kotlin.

Hal ini membuat Kotlin praktis digunakan pada proyek Java yang sudah ada.

Anda dapat melakukan migrasi secara bertahap tanpa harus menulis ulang seluruh codebase.

Sebagai contoh, sebuah proyek dapat memiliki struktur berikut:

src/
├── main/
│   ├── java/
│   │   └── com/example/LegacyService.java
│   └── kotlin/
│       └── com/example/UserService.kt

Java dan Kotlin dapat hidup berdampingan dalam satu aplikasi.

---

Cheat Sheet Sintaks Java vs Kotlin

Bagi Java developer, tabel berikut menyediakan perbandingan singkat.

Konsep	Java	Kotlin
Variabel	String name = "Ajy";	val name = "Ajy"
Variabel mutable	String name = "Ajy";	var name = "Ajy"
Function	int add(int a, int b)	fun add(a: Int, b: Int): Int
Print	System.out.println()	println()
Kondisi	if (...) {}	if (...) {}
Switch	switch	when
Class	class User {}	class User
Constructor	Constructor terpisah	Primary constructor
Inheritance	extends	:
Interface	implements	:
Null check	if (x != null)	if (x != null)
Tipe nullable	String dapat bernilai null	String?
Interpolasi string	"Hello " + name	"Hello $name"
Object data	Class + boilerplate	data class
Filter collection	Stream API	filter {}
Lambda	x -> x * 2	{ x -> x * 2 }

---

Java ke Kotlin: Contoh Praktis

Mari kita lihat contoh sederhana yang menggabungkan beberapa fitur Kotlin.

Implementasi Java mungkin terlihat seperti berikut:

public class UserService {

    public String getUserStatus(User user) {
        if (user == null) {
            return "Unknown";
        }

        if (user.getAge() >= 18) {
            return "Adult";
        }

        return "Minor";
    }
}

Padanan Kotlin-nya dapat ditulis seperti ini:

class UserService {

    fun getUserStatus(user: User?): String {
        return when {
            user == null -> "Unknown"
            user.age >= 18 -> "Adult"
            else -> "Minor"
        }
    }
}

Versi Kotlin tersebut menggunakan:

• nullable type dengan ?
• akses property
• when
• sintaks function yang ringkas
• tanpa titik koma
• sintaks class Kotlin yang lebih sederhana

Contoh ini menunjukkan satu hal penting: Kotlin bukan sekadar Java dengan sintaks yang berbeda. Kotlin memperkenalkan fitur bahasa yang dirancang untuk membuat tugas pemrograman umum menjadi lebih aman dan ringkas.

---

Bagaimana Java Developer Sebaiknya Mempelajari Kotlin?

Jika Anda sudah menguasai Java, Anda tidak perlu mempelajari konsep pemrograman dari awal.

Sebaliknya, fokuslah pada perbedaan antara kedua bahasa tersebut.

Jalur belajar yang praktis adalah sebagai berikut:

1. Pelajari sintaks Kotlin

Mulailah dengan:

• val dan var
• function
• class
• constructor
• property
• if
• when
• loop

2. Pahami null safety

Perhatikan secara khusus:

String?

serta operator seperti:

?.

?: 

dan:

!!

Memahami sistem null safety Kotlin sangat penting.

3. Pelajari collection Kotlin

Biasakan diri dengan:

map()
filter()
forEach()
find()
firstOrNull()
any()
all()

Function-function tersebut sering digunakan dalam aplikasi Kotlin modern.

4. Pelajari Kotlin idiomatik

Setelah sintaks dasar mulai terasa nyaman, pelajari fitur seperti:

• data class
• extension function
• scope function
• higher-order function
• lambda
• sealed class
• object declaration
• coroutine

Tujuannya bukan menulis kode Java menggunakan sintaks Kotlin.

Sebaliknya, pelajarilah cara menulis kode Kotlin yang idiomatik.

---

Kesalahan Umum Java Developer Saat Mempelajari Kotlin

Pengetahuan Java sangat membantu, tetapi juga dapat membuat Anda membawa kebiasaan yang kurang ideal ke Kotlin.

Menulis Terlalu Banyak Boilerplate

Sebagai contoh, daripada membuat getter dan setter secara manual, gunakan property Kotlin.

Daripada menulis:

class User {
    private var name: String = ""

    fun getName(): String {
        return name
    }

    fun setName(name: String) {
        this.name = name
    }
}

Lebih baik gunakan:

class User(
    var name: String
)

Menggunakan !! di Mana-Mana

Java developer terkadang menggunakan:

value!!

untuk melewati pemeriksaan null safety Kotlin.

Meskipun terkadang dapat digunakan, penggunaan berlebihan akan menghilangkan salah satu keunggulan utama Kotlin.

Lebih baik gunakan safe call:

value?.length

atau berikan nilai default:

val length = value?.length ?: 0

Menulis Loop Bergaya Java

Daripada selalu menggunakan loop tradisional, eksplorasi fungsi collection Kotlin.

Contohnya:

val adults = users.filter { it.age >= 18 }

Kode tersebut sering kali lebih jelas daripada membuat list secara manual lalu melakukan loop pada setiap elemen.

---

Apakah Kotlin Sulit Dipelajari oleh Java Developer?

Bagi Java developer berpengalaman, Kotlin umumnya lebih mudah dipelajari dibandingkan bahasa pemrograman yang benar-benar baru.

Konsep pemrograman berorientasi objeknya familiar, Kotlin berjalan di atas JVM, dan interoperabilitas dengan Java memungkinkan kedua bahasa digunakan secara bersamaan.

Tantangan utama berasal dari fitur tambahan Kotlin dan gaya penulisannya yang lebih ringkas.

Konsep terpenting yang perlu dipahami antara lain:

• null safety
• nullable type
• extension function
• lambda
• higher-order function
• operasi collection
• data class
• sealed class
• coroutine
• idiom khusus Kotlin

Setelah konsep-konsep tersebut mulai familiar, kode Kotlin akan jauh lebih mudah dibaca dan ditulis.

---

Kotlin atau Java: Mana yang Sebaiknya Digunakan?

Java tetap menjadi bahasa pemrograman penting dengan ekosistem yang sangat besar dan komunitas developer yang luas.

Sementara itu, Kotlin menawarkan pengalaman bahasa modern dengan tetap memberikan akses ke ekosistem Java.

Bagi developer yang bekerja dengan aplikasi JVM, pengembangan Android, layanan backend, atau codebase Java yang sudah ada, mempelajari Kotlin dapat menjadi keterampilan yang sangat berharga.

Pilihan tersebut tidak selalu harus berupa Java vs Kotlin.

Dalam banyak proyek nyata, Java dan Kotlin dapat digunakan secara bersamaan.

Java developer dapat memulai dengan menulis fitur baru menggunakan Kotlin sambil tetap memelihara kode Java yang sudah ada.

---

Kesimpulan

Bagi Java developer, mempelajari Kotlin bukan berarti harus memulai dari awal. Prosesnya lebih kepada mempelajari cara modern untuk mengekspresikan konsep yang sudah Anda pahami.

Banyak konsep Java yang memiliki padanan langsung di Kotlin, tetapi Kotlin mengurangi boilerplate dan menambahkan fitur seperti null safety, data class, extension function, smart cast, serta operasi collection yang ringkas.

Cara terbaik mempelajari Kotlin sebagai Java developer adalah dengan terus membandingkan kedua bahasa tersebut.

Mulailah dari perbedaan sintaks sederhana seperti:

String name = "Ajy";

dibandingkan dengan:

val name = "Ajy"

Kemudian lanjutkan secara bertahap ke fitur Kotlin yang lebih lanjut seperti:

data class User(...)

users.filter { it.age >= 18 }

dan:

val length = name?.length ?: 0

Setelah memahami perbedaan tersebut, transisi dari Java ke Kotlin akan terasa jauh lebih alami.

Jika Anda sudah memiliki pengalaman dengan Java, Anda tidak memulai dari nol. Pengetahuan yang sudah dimiliki tentang pemrograman berorientasi objek, pengembangan berbasis JVM, class, interface, collection, dan arsitektur aplikasi akan menjadi fondasi yang kuat untuk mempelajari Kotlin.