Belajar OOP dengan Java - Class & Object

#Pendahuluan

Setelah di episode 3 kalian menjalankan Hello World, sekarang saatnya membedah jantung OOP: class dan object. Di episode 2 kita mengenal keduanya secara konseptual — blueprint vs instance. Episode ini mengubah konsep itu menjadi detail teknis Java: bagaimana mendeklarasikan class, apa itu field instance dan static, bagaimana new bekerja, dan — yang sering membingungkan pemula — apa sebenarnya yang disimpan ketika kalian menulis Mobil mobilA = new Mobil().

Mengapa detail teknis ini penting? Karena banyak bug Java yang aneh berakar pada salah memahami reference. Ketika kalian melempar object ke method, yang dipindahkan adalah reference-nya, bukan salinannya. Paham konsep ini di episode 4 akan menyelamatkan kalian dari sakit kepala di episode 5, 12, dan 18.

#Deklarasi Class

#Anatomi Class

Class adalah wadah state dan behavior. Struktur lengkapnya:

Anatomi class Java

public class Mahasiswa {
    String nama;
    int angkatan;
    static int jumlahMahasiswa;
 
    void perkenalkan() {
        System.out.println("Saya " + nama + ", angkatan " + angkatan);
    }
}

Tiga komponen:

1. Field — state yang disimpan. nama dan angkatan adalah instance field: nilainya berbeda untuk setiap object.
2. Static field — jumlahMahasiswa milik class, bukan object. Satu nilai dibagi oleh semua object.
3. Method — behavior. perkenalkan() bisa mengakses field object miliknya lewat nama langsung.

#Field Instance vs Static

Perbedaan ini fundamental:

Instance vs static field

public class Main {
    public static void main(String[] args) {
        Mahasiswa a = new Mahasiswa();
        Mahasiswa b = new Mahasiswa();
 
        a.nama = "Alya";
        b.nama = "Bima";
 
        Mahasiswa.jumlahMahasiswa = 2;
 
        System.out.println(a.nama);  // Alya
        System.out.println(b.nama);  // Bima
        System.out.println(Mahasiswa.jumlahMahasiswa); // 2
    }
}

a.nama dan b.nama berbeda, tetapi Mahasiswa.jumlahMahasiswa hanya satu — apapun object yang kalian pakai untuk mengaksesnya, nilainya sama. Inilah alasan main di episode 3 dideklarasikan static: ia milik class, bukan object tertentu.

#Membuat Object dengan new

#Keyword new

new adalah cara Java membuat object:

Mobil mobilA = new Mobil();

Apa yang terjadi dalam satu baris ini? Tiga langkah:

1. Alokasi memori — Java menyediakan ruang di heap untuk object baru.
2. Inisialisasi — field diisi nilai default (misal null untuk reference, 0 untuk angka).
3. Constructor dipanggil — jika ada constructor (episode 5), ia menjalankan setup tambahan.

Setelah itu, reference ke object disimpan di variabel mobilA. Perhatikan kata "reference": mobilA bukan object itu sendiri — ia hanyalah alamat yang menunjuk ke object di heap.

#Heap dan Stack

Java membagi memori utama menjadi dua area:

• Heap — tempat object hidup. Ukuran bisa besar, dikelola garbage collector.
• Stack — tempat variabel lokal dan reference. Kecil, cepat, dan dibersihkan saat method selesai.

Konsekuensi penting: saat method selesai, reference di stack hilang, tetapi object di heap tetap ada sampai garbage collector membersihkannya (saat tidak ada reference lagi). Inilah kenapa object bisa "hidup lebih lama" dari method yang menciptakannya.

#Reference Semantics

#Dua Variabel, Satu Object

Dua reference ke satu object

Mobil mobilA = new Mobil();
mobilA.warna = "merah";
 
Mobil mobilB = mobilA;
mobilB.warna = "biru";
 
System.out.println(mobilA.warna); // biru!

mobilB = mobilA tidak menyalin object — ia menyalin reference. Keduanya menunjuk ke object yang sama di heap. Mengubah lewat mobilB terlihat lewat mobilA. Ini sering mengejutkan pemula, tetapi justru menjadi kekuatan Java: object tidak disalin sembarangan, sehingga memory footprint tetap terkendali.

#Membandingkan Object

Karena variabel menyimpan reference, == membandingkan alamat, bukan isi:

Membandingkan reference

Mobil a = new Mobil();
Mobil b = new Mobil();
 
System.out.println(a == b);   // false, object berbeda
System.out.println(a == a);   // true, reference sama

Untuk membandingkan isi, kalian perlu method equals() — yang akan dibahas saat kita memahami inheritance dan Object di episode 7.

#Object Sebagai Parameter

Reference semantics juga berlaku saat object masuk ke method:

Object sebagai parameter

public class Main {
    public static void main(String[] args) {
        Mobil m = new Mobil();
        m.warna = "merah";
        ubahWarna(m, "hitam");
        System.out.println(m.warna); // hitam
    }
 
    static void ubahWarna(Mobil mobil, String warna) {
        mobil.warna = warna;
    }
}

Method menerima salinan reference, bukan salinan object. Karena reference menunjuk object yang sama, perubahan di dalam method terlihat dari luar. (Catatan: perilaku ini berbeda untuk tipe primitif seperti int — detailnya kita bedah di episode 5.)

#Class dengan Dua Object: Latihan Terpadu

Mari rangkum semua konsep dalam satu contoh:

Latihan terpadu class & object

public class Kucing {
    String nama;
    static int jumlahKucing;
 
    void meong() {
        System.out.println(nama + ": meong!");
    }
 
    public static void main(String[] args) {
        Kucing k1 = new Kucing();
        k1.nama = "Momo";
        jumlahKucing++;
 
        Kucing k2 = new Kucing();
        k2.nama = "Luna";
        jumlahKucing++;
 
        k1.meong();
        k2.meong();
        System.out.println("Total kucing: " + jumlahKucing);
    }
}

Output yang diharapkan:

Momo: meong!
Luna: meong!
Total kucing: 2

Perhatikan: k1.meong() dan k2.meong() memakai method yang sama, tetapi mencetak nama masing-masing. Method membaca field object yang memanggilnya — inilah wujud nyata message passing dari episode 2.

#Penutup

Inti yang harus dibawa pulang:

• Class mendefinisikan field (instance/static) dan method; object adalah instance nyatanya.
• new mengalokasikan object di heap, sementara reference disimpan di stack.
• Assign object = menyalin reference, bukan object — dua variabel bisa menunjuk object yang sama.
• == membandingkan reference; equals() dibutuhkan untuk membandingkan isi.
• Object yang lewat ke method bisa dimodifikasi dari dalam method karena reference-nya sama.

Di episode 5 selanjutnya kita akan membedah constructor & method — bagaimana object diinisialisasi, overload constructor, keyword this, varargs, dan mengapa Java melempar nilai primitif "by value" tetapi reference object "by reference". Sampai jumpa di episode 5!