Belajar OOP dengan Java - Constructor & Method

#Pendahuluan

Setelah di episode 4 kita paham class, object, dan reference, episode ini menjawab pertanyaan yang pasti muncul: bagaimana object diinisialisasi dengan benar? Jawabannya ada di constructor. Lalu kita bedah juga method secara penuh — return type, overloading, varargs, dan aturan parameter passing yang paling sering disalahpahami pemula Java.

Mengapa ini penting? Karena constructor dan method adalah "permukaan" dari object — apa yang kalian lihat dan panggil setiap hari. Kesalahan kecil di sini (misal salah paham pass-by-value) bisa menghasilkan bug yang halus dan sulit dilacak.

#Constructor

#Apa itu Constructor?

Constructor adalah method khusus yang dipanggil saat object dibuat dengan new. Namanya wajib sama persis dengan nama class dan tidak punya return type.

Constructor dasar

public class Akun {
    String username;
 
    Akun(String namaUser) {
        username = namaUser;
    }
 
    void tampilkan() {
        System.out.println("Akun: " + username);
    }
}

Pemakaiannya:

Akun akun = new Akun("alya95");

Sebelum ada constructor, di episode 4 kita harus menulis objek.field = nilai satu per satu setelah new. Constructor menghilangkan pekerjaan itu: object lahir langsung dalam keadaan yang benar. Ini prinsip penting yang akan kembali ke episode 18 (immutability) — object seharusnya tidak pernah eksis dalam keadaan "setengah jadi".

#Default Constructor

Jika kalian tidak menulis constructor apa pun, Java menyediakan default constructor — tanpa parameter, tidak melakukan apa-apa selain mengalokasikan object. Itulah kenapa kode di episode 4 (new Mobil() tanpa constructor) tetap bisa jalan.

Aturan penting: begitu kalian mendefinisikan satu constructor sendiri, default constructor hilang. new Mobil() pun error kalau satu-satunya constructor butuh parameter.

#Overloading Constructor

Sama seperti method, constructor bisa di-overload — beberapa constructor dengan parameter berbeda:

Overloading constructor

public class Produk {
    String nama;
    double harga;
 
    Produk(String nama) {
        this.nama = nama;
        this.harga = 0.0;
    }
 
    Produk(String nama, double harga) {
        this.nama = nama;
        this.harga = harga;
    }
}

Pemanggil bisa memilih: new Produk("Kopi") atau new Produk("Kopi", 25000). Overloading adalah salah satu bentuk polymorphism compile-time yang akan kita bedah penuh di episode 8.

#Keyword this

Di contoh di atas muncul this.nama = nama. this merujuk ke object yang sedang diinisialisasi — dipakai untuk membedakan parameter dan field yang namanya sama. Tanpa this, nama = nama hanya meng-assign parameter ke dirinya sendiri (tidak melakukan apa-apa), bug halus yang sangat umum.

#Compact Constructor (Preview JDK 25)

Untuk record (episode 10), Java modern menawarkan compact constructor — versi constructor yang tidak menuliskan parameter secara eksplisit:

Compact constructor record

public record Koordinat(int x, int y) {
    public Koordinat {
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException("Koordinat tidak boleh negatif");
        }
    }
}

Perhatikan: tanpa parameter (int x, int y) — compact constructor otomatis menerima semua field komponen record. Ini validasi "laik hidup" (canonical constructor) yang akan kita pakai lagi di episode 10.

#Method

#Return Type dan Parameter

Method di Java wajib menyatakan tipe yang dikembalikan, atau void jika tidak mengembalikan apa pun:

Method dengan return type

public class Kalkulator {
    int tambah(int a, int b) {
        return a + b;
    }
 
    void cetakHasil(int hasil) {
        System.out.println("Hasil: " + hasil);
    }
}

#Method Overloading

Method dengan nama sama boleh eksis berkali-kali selama signature-nya (jumlah/tipe parameter) berbeda:

Method overloading

int tambah(int a, int b) { return a + b; }
int tambah(int a, int b, int c) { return a + b + c; }
double tambah(double a, double b) { return a + b; }

Java memutuskan method mana yang dipanggil saat compile berdasarkan tipe argumen. Inilah polymorphism compile-time — keputusan diambil sebelum program berjalan.

#Varargs

Varargs (...) memungkinkan method menerima jumlah argumen variabel:

Varargs

int jumlah(int... angka) {
    int total = 0;
    for (int n : angka) {
        total += n;
    }
    return total;
}

Pemakaian: jumlah(1, 2, 3) atau jumlah(10, 20, 30, 40, 50). Di dalam method, angka diperlakukan sebagai array. Aturan: varargs harus menjadi parameter terakhir, dan method varargs tidak bisa di-overload dengan method ber-array yang sama — keduanya akan bentrok.

#Parameter Passing: Value Semantics

Ini aturan yang paling penting di episode ini. Java selalu pass by value — tetapi maknanya berbeda tergantung tipe:

• Primitif (int, double, boolean): nilai disalin. Perubahan di method tidak terlihat di luar.
• Reference (object): reference disalin. Karena reference menunjuk object yang sama, perubahan isi object terlihat di luar — tetapi mengganti reference-nya tidak.

Pass by value: primitif vs object

public class Main {
    public static void main(String[] args) {
        int x = 10;
        ubahPrimitif(x);
        System.out.println(x); // 10, tidak berubah
 
        Mobil m = new Mobil();
        m.warna = "merah";
        ubahIsi(m);
        System.out.println(m.warna); // hitam, isi berubah
 
        gantiObject(m);
        System.out.println(m.warna); // tetap hitam, bukan biru
    }
 
    static void ubahPrimitif(int n) { n = 999; }
 
    static void ubahIsi(Mobil mobil) { mobil.warna = "hitam"; }
 
    static void gantiObject(Mobil mobil) { mobil = new Mobil(); mobil.warna = "biru"; }
}

Baris terakhir adalah jebakan favorit: mobil = new Mobil() di dalam method hanya mengubah salinan reference di parameter — reference asli di main tetap menunjuk object lama. Banyak programmer yakin method bisa "mengganti" object pemanggil, padahal tidak bisa.

#Latihan Terpadu

Constructor + method lengkap

public class Rekening {
    String pemilik;
    double saldo;
 
    Rekening(String pemilik) {
        this(pemilik, 0.0);
    }
 
    Rekening(String pemilik, double saldoAwal) {
        this.pemilik = pemilik;
        this.saldo = saldoAwal;
    }
 
    void deposit(double nominal) {
        saldo += nominal;
    }
 
    boolean tarik(double nominal) {
        if (nominal > saldo) {
            return false;
        }
        saldo -= nominal;
        return true;
    }
 
    double cekSaldo() {
        return saldo;
    }
}

Perhatikan this(pemilik, 0.0) — pemanggilan constructor lain dari dalam constructor (constructor chaining). Ini menghindari duplikasi logika inisialisasi. Kita akan lihat bentuk lain dari chaining di episode 7 (chain constructor lewat super).

#Penutup

Inti yang harus dibawa pulang:

• Constructor menginisialisasi object agar lahir dalam keadaan benar; overloading memberi fleksibilitas pembuatan.
• this membedakan field dan parameter; this(...) memanggil constructor lain.
• Overloading method/constructor adalah polymorphism compile-time.
• Varargs (...) menerima argumen variabel sebagai array.
• Java pass by value: primitif tersalin, reference tersalin (isi object bisa berubah, object-nya tidak bisa diganti).

Di episode 6 selanjutnya kita akan membahas encapsulation & access modifiers — mengunci field dengan private, membuka akses aman lewat getter/setter, membuat object immutable dengan final, dan pola JavaBeans. Sampai jumpa di episode 6!