Konstruktor dan Inisialisasi Objek

Kelas pada Java memiliki sifat yang sama sekali berbeda dengan tipe data primitif lainnya, seperti int atau boolean. Seperti disebutkan pada bagian sebelumnya, mendeklarasikan suatu variabel dengan tipe suatu kelas tidak berarti membuat objek dari kelas tersebut. Objek tersebut harus dibuat (constructed). Pada saat objek dibuat, komputer akan mencari tempat yang tidak dipakai pada memori heap untuk menempatkan objek tersebut, kemudian mengisi objek itu dengan variabel instansi. Sebagai programmer, kita tidak peduli dengan bagaimana suatu objek disimpan, akan tetapi kita ingin mengatur supaya nilai yang disimpan pada saat objek tersebut dibuat sesuai dengan keinginan kita. Dalam beberapa kasus, kita bahkan ingin suatu objek melakukan tugas tertentu untuk pertama kali begitu ia diciptakan.

Variabel instansi dapat diisi dengan nilai awal pada saat ia dideklarasikan, seperti variabel lainnya. Misalnya, kelas berikut yang bernama PasanganDadu, yang melambangkan sepasang dadu. Kelas ini memiliki dua variabel instansi yang melambangkan nilai yang ditunjukkan oleh masing-masing dadu dan metode instansi untuk mengocok dadu, yaitu :

class PasanganDadu {
    public int dadu1 = 3; // Angka pada dadu pertama
    public int dadu2 = 4; // Angka pada dadu kedua
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int)(Math.random()*6) + 1;
        dadu2 = (int)(Math.random()*6) + 1;
    }
} // akhir kelas PasanganDadu

Variabel instansi dadu1 dan dadu2 diisi dengan nilai awal 3 dan 4. Inisialisasi ini dilakukan setiap kali objek PasanganDadu dibuat. Ingat bahwa kelas PasanganDadu hanya 1, akan tetapi kita bisa membuat banyak objek dari kelas ini. Setiap kali objek dibuat, objek tersebut memiliki tempat di memori sendiri, yang disebut dengan instansi objek tersebut. Perintah "dadu1 = 3" dan "dadu2 = 4" akan dieksekusi setiap kali objek dibuat.
Kita bisa memodifikasi kelas PasanganDadu dengan nilai awal acak, bukan 3 dan 4 misalnya, dengan potongan kode berikut :

class PasanganDadu {
    public int dadu1 = (int)(Math.random()*6) + 1; // Angka pada dadu pertama
    public int dadu2 = (int)(Math.random()*6) + 1; // Angka pada dadu kedua
 
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int)(Math.random()*6) + 1;
        dadu2 = (int)(Math.random()*6) + 1;
    }
} // akhir kelas PasanganDadu

Karena inisialisasi dilakukan setiap kali objek dibuat, maka setiap objek akan memiliki nilai yang berbeda-beda hasil dari instruksi Math.random() pada inisialisasi variabel instansi. Untuk inisialisasi variabel static, hal ini tidak mungkin dilakukan, karena hanya ada 1 variabel statik untuk 1 kelas, tidak peduli berapa pun banyaknya objek yang dibuat.

Jika variabel instansi tidak kita beri nilai awal, maka nilai bawaan akan diberikan secara otomatis. Tipe data numerik (int, double, dll) memiliki nilai bawaan 0; boolean bernilai awal false; dan char bernilai awal karakter dengan kode Unicode 0. Variabel instansi juga bisa bertipe suatu objek. Dalam hal ini, variabel tersebut bernilai awal null. (Ingat bahwa String adalah objek, sehingga nilai awalnya adalah null).

Objek dibuat dengan operator new, misalnya program yang ingin menggunakan objek PasanganDadu dapat menggunakan perintah berikut :

// deklarasi variabel dan pembuatan objek dilakukan sekaligus
PasanganDadu dadu = new PasanganDadu();

Pada contoh di atas, new PasanganDadu() adalah perintah untuk membuat objek, meletakkannya di memori dan menyimpan alamat objek ini di memori pada variabel dadu. Bagian ekspresi PasanganDadu() mirip seperti memanggil subrutin. Sebetulnya itulah yang terjadi, yaitu program memanggil subrutin spesial yang dinamakan konstruktor (constructor). Mungkin Anda heran karena kita tidak melihat adanya subrutin bernama PasanganDadu(). Akan tetapi semua kelas memiliki konstruktor, yang jika kita tidak buat secara khusus, Java akan menambahkannya secara otomatis, yang disebut konstruktor bawaan.

Konstruktor bawaan melakukan hal-hal umum seperti mengalokasi memori, mengisi nilai variabel instansi dengan nilai bawaannya, dan mengembalikan alamat objek yang dibuat di memori. Jika kita menginginkan hal lain yang ikut dilaksanakan ketika suatu objek dibuat, maka kita harus membuat konstruktor sendiri.

Bagaimana cara mendefinisikan konstruktor? Konstruktor dideklarasikan mirip dengan deklarasi subrutin, dengan 3 perkecualian. Konstruktor tidak memiliki tipe keluaran (void pun tidak dibolehkan. Namanya harus sama dengan nama kelas di mana ia dideklarasikan. Sifat yang bisa digunakan hanya sifat akses, yaitu public, private, dan protected (static tidak diperbolehkan).

Di lain pihak, konstruktor memiliki blok yang terdiri dari kumpulan perintah seperti pada subrutin. Kita bisa menggunakan perintah apapun seperti pada subrutin biasa, termasuk memiliki satu atau lebih parameter formal. Sebetulnya salah satu alasan untuk menggunakan parameter adalah kita bisa membuat beberapa konstruktor yang menerima data dalam berbagai bentuk, sehingga objek yang kita buat bisa dinisialisasi dengan cara yang berbeda-beda sesuai dengan kondisi dan kebutuhan dari program yang akan kita buat.

Misalnya, kelas PasanganDadu di atas kita ubah sehingga kita bisa memberi nilai awal sendiri. Dalam hal ini kita buat konstruktor yang menerima 2 nilai sebagai nilai awal dadu, yaitu nilai1 dan nilai2.

class PasanganDadu {
    public int dadu1; // Angka pada dadu pertama
    public int dadu2; // Angka pada dadu kedua
 
    public PasanganDadu(int nilai1, int nilai2) {
        // Konstruktor, mengambil nilai1 dan nilai2 sebagai nilai awal untuk dadu1 dan dadu2
        dadu1 = nilai1;
        dadu2 = nilai2;
    }
 
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int)(Math.random()*6) + 1;
        dadu2 = (int)(Math.random()*6) + 1;
    }
} // akhir kelas PasanganDadu

Konstruktor dideklarasikan dalam bentuk "public PasanganDadu(int nilai1, int nilai2) ...", tanpa tipe keluaran dan dengan nama yang sama dengan nama kelas. Ini adalah cara Java mengenal suatu konstruktor dan membedakannya dengan subrutin biasa. Konstruktor ini memiliki 2 parameter yang harus diisi ketika konstruktor dipanggil. Misalnya,

PasanganDadu dadu = new PasanganDadu(1,2);

Membuat objek baru yang variabel intansinya dadu1 dan dadu2 bernilai 1 dan 2.

Karena sekarang kita telah membuat konstruktor, kita tidak bisa lagi membuat objek dengan perintah "new PasanganDadu()". Java akan membuat konstruktor bawaan apabila tidak ada satupun konstruktor yang didefinisikan. Akan tetapi, kita bisa membuat konstruktor lain di kelas tersebut, karena suatu kelas bisa terdiri dari beberapa konstruktor asalkan parameternya berbeda.

Sekarang kita akan modifikasi lagi kelas tersebut dengan 2 konstruktor, yang mana apabila tidak ada parameter yang diberikan, maka objek tersebut akan mengisi nilai dadu1 dan dadu2 dengan bilangan acak.

class PasanganDadu {
    public int dadu1; // Angka pada dadu pertama
    public int dadu2; // Angka pada dadu kedua
 
    public PasanganDadu() {
        // Isi dadu1 dan dadu2 dengan bilangan acak, dengan memanggil metode
        // kocok()
        kocok();
    }
 
    public PasanganDadu(int nilai1, int nilai2) {
        // Konstruktor, mengambil nilai1 dan nilai2 sebagai nilai awal untuk
        // dadu1 dan dadu2
        dadu1 = nilai1;
        dadu2 = nilai2;
    }
 
    public void kocok() {
        // Kocok dadu dengan menggunakan bilangan acak antara 1 dan 6
        dadu1 = (int) (Math.random() * 6) + 1;
        dadu2 = (int) (Math.random() * 6) + 1;
    }
} // akhir kelas PasanganDadu

Sekarang kita bisa memilih bagaimana membuat objek, yaitu dengan "new PasanganDadu()" atau dengan "new PasanganDadu(x,y)", di mana x dan y adalah ekpresi bernilai int.
Kelas ini, bisa digunakan dalam program lain yang membutuhkan sepasang dadu. Program tersebut tidak lagi harus memanggil fungsi.

(int)(Math.random()*6) + 1

karena perintah ini sudah diimplementasikan di dalam kelas PasanganDadu. Bagi programmer, teknik seperti ini mempermudah pemecahan masalah dengan mengelompokkannya menjadi ciri dan perilaku suatu objek.

Berikut ini adalah contoh program lain yang menggunakan objek PasanganDadu() untuk menghitung berapa kali kocok akan menghasilkan jumlah nilai yang sama.

public class KocokDuaPasangDadu {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        PasanganDadu daduPertama = new PasanganDadu(); // pasangan dadu pertama
        PasanganDadu daduKedua = new PasanganDadu(); // pasangan dadu kedua
 
        int jumlahKocokan; // untuk mengitung berapa kali dua pasang dadu
                           // tersebut dikocok
        int total1; // hitung berapa kali dadu pertama muncul
        int total2; // hitung berapa kali dadu kedua muncul
 
        jumlahKocokan = 0;
        do {
            daduPertama.kocok(); // kocok dadu pertama
            total1 = daduPertama.dadu1 + daduPertama.dadu2; // hitung jumlahnya
            System.out.println("Pasangan dadu pertama berjumlah " + total1);
 
            daduKedua.kocok(); // kocok dadu pertama
            total2 = daduKedua.dadu1 + daduKedua.dadu2; // hitung jumlahnya
            System.out.println("Pasangan dadu pertama berjumlah " + total2);
 
            jumlahKocokan++;
            System.out.println(); // cetak baris kosong
 
        } while (total1 != total2);
 
        System.out.println("Butuh " + jumlahKocokan
                + " kocokan hingga pasangan "
                + " dadu pertama dan kedua berjumlah sama");
 
    }
}

Keluarannya adalah sebagai berikut

Konstruktor adalah subrutin, tetapi bukan subrutin biasa, dan bukan metode instansi, karena konstruktor tidak dimiliki oleh suatu objek. Karena tugasnya membuat objek, maka konstruktor dijalankan sebelum objek dibuat. Konstruktor mirip dengan subrutin anggota statik, tetapi dia tidak bisa dideklarasikan "static". Bahkan menurut spesifikasi Java, konstruktor bukan anggota suatu kelas sama sekali.

Tidak seperti subrutin lain, konstruktor hanya bisa dipanggil melalui operator "new", dalam bentuk

new nama_kelas(parameter);

di sini "parameter" boleh kosong. Hasil keluarannya adalah alamat memori di mana objek yang baru dibuat tersebut disimpan. Seringkali, kita akan simpan hasil keluarannya di dalam suatu variabel, atau bisa juga hasil keluarannya diberikan ke dalam suatu fungsi sebagai parameter.

Memanggil konstruktor lebih rumit daripada memanggil subrutin atau fungsi biasa. Hal-hal berikut sangat membantu untuk lebih memahami apa yang dilakukan oleh konstruktor ketika ia dipanggil untuk membuat suatu objek:

1. Pertama, komputer memberi daerah pada memori yang tidak digunakan, cukup untuk dipakai oleh objek yang akan dibuat
2. Komputer akan mengisi variabel instansi objek tersebut dengan nilai bawaannya. Jika deklarasi variabel instansi pada kelas memiliki nilai awal tertentu, maka nilai tersebut akan dimasukkan sebagai nilai awalnya.
3. Parameter aktual pada konstruktor (jika ada) akan dievaluasi dan nilainya diberikan kepada parameter formal konstruktor tersebut.
4. Perintah pada konstruktor (jika ada) akan dilaksanakan.
5. Referensi objek akan dikembalikan kepada si pemanggil.

Hasil keluarannya adalah referensi ke objek yang baru saja dibuat. Kita bisa gunakan referensi ini untuk mengambil data pada variabel instansi objek tersebut atau memanggil metode instansinya.

Contoh lain, mari kita ganti kelas Murid pada bagian sebelumnya. Kita akan tambahkan konstruktor dan juga kita ganti variabel instansi "nama" menjadi bersifat privat.

class Murid {
    private String nama;    // Nama murid
    public double nilai1, nilai2, nilai3;   // Nilai-nilai ujian
 
    Murid(String namaMurid) {
        // Konstruktor objek Murid
        nama = namaMurid;
    }
 
    public String getNama() {
        // Metode untuk mengambil variabel anggota yang bersifat private
        // misalnya variabel instansi nama
        return nama;
    }
 
    public double hitungRataRata() {
        // Hitung rata-rata ulangan
        return (nilai1 + nilai2 + nilai3) / 3;
    }
 
}  // akhir kelas Murid

Objek bertipe Murid berisi informasi tentang murid tertentu. Konstruktor kelas ini memiliki parameter bertipe String yaitu nama murid yang akan kita buat. Objek bertipe Murid ini bisa dibuat dengan pernyataan seperti:

mrd1 = new Murid("Ahmad Surahmat");
mrd2 = new Murid("Hamid Samsudin")

Pada versi aslinya, isi variabel nama harus diisi dengan perintah terpisah setelah objek dibuat. Masalahnya programmer tidak selalu ingat untuk mengisi nilai nama. Pada versi baru di atas, setiap kali kita membuat objek, parameter namaMurid harus disertakan, karena ini dideklarasikan pada konstruktornya. Dengan demikian potensi bug karena kelalaian programmer dapat dihilangkan dengan mudah.

Contoh keamanan lainnya adalah dengan membuat variabel instansi nama bersifat private. Ini berarti variabel ini tidak bisa diakses oleh dunia luar secara langsung. Variabel ini hanya bisa diambil nilainya dengan metode instansi getNama, dan karena tidak bisa diakses langsung dari luar, maka isi variabel ini tidak bisa diganti dari luar kelas. Sekali objek Murid dibuat, maka namanya tidak bisa diganti selama murid tersebut ada.