Belajar Groovy - Object-Oriented Groovy

#Pendahuluan

Kontrol alur dan function membentuk logika program, tetapi aplikasi nyata dibangun dari objek. Episode 5 membawa kalian ke paradigma inti Groovy: object-oriented programming yang lebih ringkas dari Java.

Kalian akan belajar kelas, objek, property, constructor, inheritance, trait, interface, serta pengenalan AST transformations. Di akhir episode, kalian bisa merancang model domain yang bersih tanpa boilerplate Java.

#Kelas dan Property

#Groovy Beans

Groovy menyederhanakan konsep JavaBean. Mendeklarasikan property tanpa modifier visibility otomatis menghasilkan getter dan setter:

class Pengguna {
    String nama
    int umur
}
 
def user = new Pengguna(nama: "Arman", umur: 25)
println user.nama
user.umur = 26
println user.umur

def user = new Pengguna(nama: "Arman", umur: 25) memakai named-argument constructor yang otomatis dibuat Groovy. Akses user.nama memanggil getter di balik layar, dan assignment user.umur = 26 memanggil setter.

#Constructor dan Method

Groovy tetap mendukung constructor eksplisit dan method seperti biasa, tetapi menambahkan kemudahan: method dipanggil dengan atau tanpa tanda kurung, dan nilai balik otomatis.

class Kalkulator {
    int tambah(int a, int b) {
        return a + b
    }
 
    int kalikan(int a, int b) {
        a * b
    }
}
 
def k = new Kalkulator()
println k.tambah(2, 3)
println k.kalikan(4, 5)

Perhatikan bahwa kalikan menghilangkan return karena nilai ekspresi terakhir otomatis dikembalikan. k.kalikan(4, 5) memanggil method instance dengan pola yang sama seperti Java.

#Inheritance dan Interface

#Pewarisan Sederhana

Groovy mendukung inheritance satu kelas dan implementasi banyak interface, persis seperti Java:

interface Menyapa {
    String sapa()
}
 
class Makhluk {
    String nama
}
 
class Manusia extends Makhluk implements Menyapa {
    String sapa() {
        "Halo, saya ${nama}"
    }
}
 
def arman = new Manusia(nama: "Arman")
println arman.sapa()

class Manusia extends Makhluk implements Menyapa menunjukkan hierarki klasik OOP. new Manusia(nama: "Arman") kembali memakai named-argument constructor yang otomatis mengisi property dari kelas induk.

#Trait

#Mengapa Trait

Java interface tidak bisa membawa implementasi default sebelum Java 8, dan multiple inheritance tidak diizinkan. Groovy menyediakan trait — blok kode yang bisa dibagikan ke banyak kelas tanpa pewarisan ganda.

trait Berjalan {
    void jalan() {
        println "${this.getClass().getSimpleName()} sedang berjalan"
    }
}
 
class Kucing implements Berjalan {
}
 
class Anjing implements Berjalan {
}
 
new Kucing().jalan()
new Anjing().jalan()

trait Berjalan mendefinisikan method jalan dengan implementasi, dan kedua kelas memakainya tanpa harus menulis ulang. new Kucing().jalan() membuktikan bahwa method dari trait bisa langsung dipanggil.

#Mixin dan Multiple Traits

Sebuah kelas bisa mengimplementasi beberapa trait sekaligus, menciptakan perilaku mixin:

trait Berenang {
    void berenang() {
        println "Berenang"
    }
}
 
class Ikan implements Berjalan, Berenang {
}

class Ikan implements Berjalan, Berenang menggabungkan dua trait dalam satu kelas. Kombinasi Berjalan, Berenang adalah bentuk komposisi yang tidak bisa dilakukan dengan inheritance tunggal.

#AST Transformations

#Konsep AST Transformations

AST transformations adalah fitur yang mengubah pohon sintaks (Abstract Syntax Tree) saat kompilasi, menghasilkan kode tambahan secara otomatis. Transformasi dipicu oleh anotasi seperti @ToString, @EqualsAndHashCode, dan @TupleConstructor.

#Contoh @ToString dan @Canonical

Dengan anotasi @Canonical, Groovy membuat toString, equals, hashCode, dan named-argument constructor secara otomatis:

import groovy.transform.Canonical
 
@Canonical
class Produk {
    String nama
    BigDecimal harga
}
 
def p = new Produk(nama: "Kopi", harga: 25000)
println p

@Canonical menghasilkan seluruh boilerplate yang di Java harus ditulis manual. new Produk(nama: "Kopi", harga: 25000) membangun objek dengan named constructor, dan println p menampilkan representasi toString yang rapi.

#Transformasi Umum Lainnya

Beberapa AST transformation yang sering dipakai di project nyata:

• @Builder untuk fluent builder.
• @TupleConstructor untuk constructor berbasis posisi.
• @Immutable untuk objek tak berubah.
• @CompileStatic untuk mengaktifkan type checking saat kompilasi.

Kalian akan memakai @CompileStatic secara mendalam di episode 16 untuk performa, dan transformasi lain tersebar di seluruh series.

#Penutup

Episode 5 membawa kalian ke paradigma object-oriented Groovy: Groovy Beans dengan getter dan setter otomatis, inheritance dan interface standar, trait untuk komposisi perilaku, serta AST transformations yang menghapus boilerplate.

Inti yang harus dibawa pulang:

• Property Groovy otomatis menghasilkan getter dan setter.
• Named-argument constructor mempermudah pembuatan objek.
• Trait memungkinkan berbagi implementasi tanpa multiple inheritance.
• Satu kelas bisa menggabungkan banyak trait sebagai mixin.
• @Canonical menghasilkan toString, equals, dan hashCode otomatis.
• AST transformations adalah sumber utama kehematan kode Groovy.

Di episode 6 selanjutnya kita akan membahas collections dan Groovy JDK — Collection API untuk List, Map, dan Set, iterasi berbasis closure dengan each, collect, dan findAll, serta berbagai enhancement Groovy untuk String, File, I/O, dan Date.