Objek, Metode Instansi dan Variable Instansi

Pemrograman berorientasi objek bermaksud untuk memecahkan masalah programming mirip dengan cara berfikir manusia dan bagaimana manusia berinteraksi dengan dunia. Kita telah melihat bagaimana masalah programming dipecahkan dengan membaginya menjadi instruksi-instruksi kecil yang dirangkai menjadi suatu kesatuan tugas. Cara ini disebut juga dengan pemrograman berdasarkan prosedur.

Pada pemrograman berorientasi objek, kita membagi masalah pemrograman berdasarkan objek atau "sesuatu" benda. Objek ini diibaratkan seperti makhluk hidup, yaitu memiliki ciri-ciri fisik dan juga perilaku. Dalam pemrograman berorientasi objek, ciri-ciri fisik ini disebut juga sebagai atribut, pada dasarnya berisi informasi tentang objek tersebut. Sedangkan perilaku disebut sebagai metode, yaitu bagaimana suatu objek bertindak atau melakukan sesuatu.

Dengan cara ini diharapkan pemrograman berorientasi objek merupakan pemrograman yang lebih alami dibandingkan dengan pemrograman berorientasi prosedur, karena cara fikir kita sudah terbiasa dengan bagaimana kita berinteraksi dengan dunia.

Sampai tingkat tertentu, PBO hanya merubah cara pandang programmer. Objek dalam kaitannya dengan dasar pemrograman adalah gabungan dari variabel (dalam hal ini atribut) dan subrutin (yaitu metode) yang berinteraksi dengan variabel pada objek.

Banyak bahasa pemrograman lain yang juga mendukung konsep PBO, akan tetapi Java merupakan bahasa yang mendukung penuh PBO, di antaranya karena Java memiliki beberapa fitur penting yang berbeda dari bahasa standar. Untuk menggunakan fitur ini, kita harus mengubah cara pandang kita terlebih dahulu.

Objek terkait erat dengan kelas. Kita telah bahas dan mencoba beberapa contoh kelas pada bab-bab sebelumnya. Seperti kita lihat pula bahwa kelas memiliki variabel dan subrutin.

Jika objek juga memiliki variabel dan subrutin, lalu apa bedanya dengan kelas? Lalu mengapa kita harus memiliki cara pandang berbeda dengan cara kita melihat kelas? Sepertinya apabila kita lihat contoh-contohnya sebelumnya, perbedaannya hanya menghilangkan kata "static" dari deklarasi variabel dan subrutinnya, khan?

Seperti disebutkan sebelumnya bahwa kelas mendeskripsikan suatu objek, atau lebih tepatnya, bagian non "static" mendeskripsikan suatu objek. Mungkin bahasa biologi, kelas adalah species, sedangkan objek merupakan individu. Human sapiens (nama biologi manusia) adalah kelas, sedangkan Anda, saya, ibu, bapak, pak hansip adalah objek. Masing-masing dari kita memiliki "blueprint" atau cetak biru yang sama, tetapi kita memiliki ciri-ciri yang berbeda, rambut, mata, telinga, tinggi badan, berat badan, dan juga perilaku kita saat makan, minum, belajar, dan lain-lain.

Dalam sudut pandang pemrograman, kelas digunakan untuk menciptakan suatu objek. Atau dengan kata lain, kelas adalah pabrik pembuat objek. Bagian non-statik dari suatu kelas adalah bagian yang memuat detail suatu objek, yaitu apa isi variabel dan metodenya. Perbedaan kelas dan objek adalah : Objek diciptakan dan dihancurkan ketika program berjalan, sehingga kita bisa memiliki beberapa objek sekaligus.

Kita lihat contoh sederhana, dimana kelas sederhana digunakan untuk menggabungkan beberapa variabel statik. Misalnya

class DataPenduduk {
   static String nama;
   static int umur;
}

Pada program yang menggunakan kelas ini, hanya ada satu kopi dari setiap variabel DataPenduduk.nama dan DataPenduduk.umur. Hanya akan ada satu penduduk, karena kita menyimpan data tersebut sebagai data statik, yang artinya hanya satu tempat di memori di mana data tersebut disimpan. Kelas DataPenduduk dan variabel isinya akan ada selama program tersebut berjalan.

Sekarang kita lihat kode berikut yang memiliki variabel non-statik:

class DataPenduduk {
   String nama;
   int umur;
}

Dalam hal ini tidak ada lagi yang variabel DataPenduduk.nama dan DataPenduduk.umur, karena nama dan umur bukan anggota statik kelas DataPenduduk. Jadi, tidak ada yang bisa kita lakukan dengan kelas ini sama sekali, kecuali membuat objek dari kelas ini.

Setiap objek akan memiliki variable sendiri yang dinamakan "nama" dan "umur". Kita bisa membuat banyak "penduduk" karena kita bisa membuat objek untuk setiap penduduk. Misalnya setiap kali seseorang dilahirkan, kita bisa membuat objek penduduk baru. Atau jika seseorang meninggal dunia, kita bisa hapus objek tersebut.

Suatu sistem yang terdiri dari kumpulan objek digunakan untuk memodelkan apa yang terjadi di alam nyata. Kita tidak bisa membuat beberapa objek dengan menggunakan variabel statik.

Contoh lainnya adalah pada GUI. Bayangkan kita memiliki beberapa tombol, misalnya tombol OK, Cancel dan Apply. Masing-masing tombol ini memiliki kelas yang sama akan tetapi apa yang dilakukan tombol ini berbeda-beda. Teks yang ditampilkan (OK, Cancel atau Apply) merupakan variabel masing-masing objek.

Suatu objek yang diciptakan dari suatu kelas disebut instansi dari kelas tersebut. Variabel yang dimiliki oleh objek disebut variabel instansi. Sedangkan subrutinnya disebut . (Dalam PBO subrutin disebut metode)

Misalnya dalam kelas DataPenduduk di atas, kemudian kita buat suatu objek dari kelas ini, maka objek yang diciptakan disebut instansi dari kelas DataPenduduk, "nama" dan "umur" adalah variabel instansi di dalam objek tersebut.

Penting untuk diingat bahwa kelas suatu objek menentukan tipe data dari variabel instansi, akan tetapi isi datanya sendiri tidak disimpan di dalam kelas, akan tetapi di dalam objek yang diciptakan, sehingga setiap objek akan memiliki data masing-masing.

Begitu juga dengan metode instansi, misalnya pada kelas tombol, kita memiliki metode yang dinamakan klik(). Masing-masing tombol akan melakukan tugas berbeda-beda tergantung dari objeknya.

Seperti kita lihat di sini bahwa bagian statik dan non-statik dari suatu kelas merupakan hal yang sama sekali berbeda. Banyak kelas yang hanya memiliki anggota statik, atau hanya memiliki anggota non-statik. Akan tetapi kita juga bisa mencampur keduanya dalam suatu kelas. Variabel anggota statik suatu kelas juga bisa disebut variabel kelas dan metode anggota statik suatu kelas juga bisa disebut metode kelas, karena mereka adalah milik kelas dan bukan milik objek yang diciptakan dari suatu kelas.

Sekarang kita gunakan contoh yang lebih real. Kita akan buat versi sederhana dari kelas Murid, dimana kita akan menyimpan informasi tentang murid yang terdaftar pada suatu sekolah.

class Murid {
   String nama ;    // nama murid
   double nilai1, nilai2, nilai3;    // nilai ulangan murid tersebut
   double hitungRataRata() {    // hitung rata-rata nilai ulangan
       return (nilai1 + nilai2 + nilai3) / 3;
   }
}

Kita lihat bahwa semua anggota kelas tersebut bukan anggota statik, artinya kelas ini hanya bisa digunakan untuk membuat objek. Definisi kelas ini artinya bahwa di dalam objek yang akan diciptakan, akan ada variabel instansi yang bernama nama, nilai1, nilai2, dan nilai3, dan juga metode instansi yang bernama hitungRataRata(). Setiap murid memiliki nilai rata-rata yang berbeda-beda. (Makanya ini disebut perilaku suatu objek berbeda-beda).

Dalam Java, kelas merupakan tipe data, yaitu mirip dengan tipe data bawaan seperti int atau boolean. Jadi nama kelas bisa digunakan untuk menentukan tipe suatu variabel dalam deklarasi pernyataan, dalam parameter formal dan juga dalam tipe keluaran suatu fungsi. Misalnya, program mendefinisikan seorang murid dengan pernyataan seperti :

Murid amir;

Akan tetapi membuat variabel seperti di atas TIDAK menciptakan objek. Initinya, ini adalah hal Yang Sangat Amat Penting :

Dalam Java, tidak ada variabel yang bisa menyimpan objek. Variabel hanya bisa menyimpan referensi (alamat di memori) suatu objek. Komputer akan menggunakan referensi ini untuk mencari objek di dalam memori.

Objek diciptakan dengan pernyataan new, yang bertugas menciptakan objek kemudian mengembalikan referensi ke objek yang sudah diciptakan. Misalnya amir adalah variabel dengan tipe Murid seperti dideklarasikan di atas, maka pernyataan berikut :

amir = new Murid();

akan membuat objek yang merupakan instansi dari kelas Murid. Variabel amir akan menyimpan referensi ke objek yang baru saja diciptakan.

Sekarang anggap variabel amir merujuk pada objek yang diciptakan dari kelas Murid. Dalam objek tersebut terdapat variabel nama, nilai1, nilai2, dan nilai3. Variabel instansi ini bisa dipanggil dengan amir.nama, amir.nilai1, amir.nilai2, dan amir.nilai3. (Ingat aturan penulisan nama lengkap, akan tetapi karena kelas ini tidak memiliki anggota statik, dan hanya objek yang diciptakan dari kelas ini memiliki variabel atau metode ini, maka nama lengkapnya diturunkan dari nama objek yang memilikinya).

Misalnya, program berikut :

System.out.println("Hai, " + amir.nama + " . Nilai Anda adalah : ");
System.out.println(amir.nilai1);
System.out.println(amir.nilai2);
System.out.println(amir.nilai3);

Program di atas akan mencetak nama dan nilai-nilai yang disimpan oleh objek amir. Begitu juga kita bisa menghitung rata-rata pada suatu objek dengan menggunakan amir.hitungRataRata(). Sehingga untuk menghitung rata-rata murid tersebut, bisa kita perintahkan dengan:

System.out.println("Nilai rata-rata Anda adalah : " + amir.hitungRataRata());

Lebih umum lagi, kita bisa menggunakan amir.nama seperti layaknya variabel bertipe String, artinya kita bisa menghitung jumlah karakter dengan menggunakan amir.nama.length().

Kita juga bisa membuat variabel seperti amir untuk tidak menunjuk atau memiliki referensi ke obek mana pun. Dalam hal ini kita sebut bahwa objek amir berisi referensi kosong (null reference). Referensi kosong ini ditulis dalam Java dengan ekspresi "null". Dan kita bisa menyimpan nilai "null" pada variabel amir dengan perintah :

amir = null;

Dan kita juga bisa uji apakah amir berisi referensi kosong dengan perintah

if (amir == null) . . .

Jika suatu variabel berisi referensi kosong, maka tentu saja, kita tidak bisa mengambil variabel instansi dan menjalankan metode instansi, karena tidak ada objek yang dirujuk pada variabel tersebut. Misalnya jika variabel amir berisi null, maka kita tidak bisa mengambil variabel amir.nilai1.

Jika program kita mencoba mengakses referensi kosong secara ilegal, maka di tengah-tengah jalannya program, program akan menampilkan pesan kesalahan "null pointer exception".

Mari kita lihat beberapa pernyataan yang bisa digunakan dengan objek :

Murid mrd1, mrd2, mrd3, mrd4;    // mendeklarasikan 4 variabel yang bertipe Murid
mrd1 = new Murid();              // membuat objek baru dari kelas Murid, kemudian menyimpan referensinya pada variabel mrd1
mrd2 = new Murid();              // membuat objek baru dari kelas Murid, kemudian menyimpan referensinya pada variabel mrd2
mrd3 = mrd1;                     // menkopi „referensi" yang disimpan pada mrd1 ke mrd3
mrd4 = null;                     // menyimpan referensi kosong ke mrd4

mrd1.nama = "Ahmad Surahmat";    // mengisi nilai variabel instansi
mrd2.nama = "Hamid Samsudin";

Setelah komputer menjalankan program tersebut, maka kira-kira memori komputer akan tampak seperti gambar berikut :

Gambar tersebut menunjukkan variabel dalam kotak-kotak kecil dengan nama variabelnya. Objek ditunjukkan dalam kotak dengan pojok bulat. Ketika suatu variabel berisi referensi ke suatu objek, maka nilainya adalah seperti panah yang menunjuk pada objek tersebut.

Variabel mrd4 bernilai null, sehingga tidak menunjuk ke mana-mana. Panah dari mrd1 dan mrd3 menjunjuk pada objek ang sama. Ini merupakan Hal Yang Sangat Penting :

Jika isi variabel suatu objek diberikan kepada variabel yang lain, maka yang dikopi hanya referensinya saja. Isi objek tidak pernah dikopi.

Ketika pernyataan "mrd3 = mrd1;" dieksekusi, tidak ada objek baru yang dibuat. Akan tetapi mrd3 akan merujuk pada alamat yang sama seperti mrd1. Konsekuensinya mungkin sedikit mengejutkan. Misalnya variabel mrd1.nama dan mrd3.nama menunjuk pada variabel yang persis sama, maka apabila mrd1.nama disi dengan "Juju Juminten", maka mrd3.nama juga berisi "Juju Juminten".

Sekali lagi, variabel tidak berisi objek, akan tetapi berisi referensi ke suatu objek.

Kita bisa menguji beberapa objek dengan operator == dan != untuk menguji kesamaan dan ketidaksamaan. Akan tetapi yang dicek lagi-lagi bukan isi objek, melainkan alamat memori dimana objek tersebut dijadikan referensi. Jika alamat referensi di memori sama, artinya kedua objek tersebut merujuk pada alamat memori yang sama. Ini berarti perubahan yang dilakukan pada variabel yang satu akan ikut mempengaruhi variabel yang lain.

Untuk menguji isinya, maka isinya harus dibandingkan satu per satu, yaitu misalnya dengan "mrd3.nilai1 == mrd1.nilai1 && mrd3.nilai2 == mrd1.nilai2 && mrd3.nilai3 == mrd1.nilai3 && mrd3.nama.equals(mrd1.nama)"

Seperti telah disebutkan sebelumnya bahwa String juga merupakan objek. Sehingga membandingkan String yang satu dengan String yang lain dengan menggunakan tanda == adalah membandingkan apakah alamat memori yang ditunjuk oleh String yang satu sama dengan alamat memori yang ditunjuk oleh String yang lain. Ingat == pada objek bukan membandingkan isi objek, tetapi membandingkan alamat memori yang ditunjuk oleh variabel tersebut. Untuk membandingkan isi String, kita dapat menggunakan String.equals() di mana parameternya adalah objek String yang akan dibandingkan. Metode ini akan membandingkan karakter per karakter dari kedua String.

Misalnya, variabel salam berisi String "Selamat". Untuk menguji apakah variabel salam berisi "Selamat", bisa kita gunakan perintah

salam.equals("Selamat")

Konsekuensi lainnya adalah apabila suatu variabel merujuk pada objek yang dideklarasikan sebagai final. Ini berarti nilai variabel itu tidak bisa berubah setelah diinisialisasi, sedangkan isi variabel itu adalah rujukan ke alamat memori tempat objek berada. Dengan demikian variabel tersebut akan selalu menunjuk pada alamat memori yang sama. Akan tetapi hal ini tidak berlaku untuk objek itu sendiri. Apabila ada variabel lain yang tidak "final" tetapi menunjuk pada alamat memori yang sama, kemudian variabel ini mengubah isi objek tersebut, maka isi objek tersebut bisa berubah.

Kita boleh saja untuk menulis perintah sebagai berikut.

final Murid mrd = new Murid();
murid.nama = "Ahmad Basir";

Perhatikan pada kode di atas bahwa isi objek bisa diubah. Akan tetapi jika kita mencoba menulis seperti ini

Murid mrd99 = new Murid();
mrd = mrd99; // ILEGAL, karena mrd adalah variabel final

* Membuat kode, menguji, dan mencari kesalahan (debugging)

Akan sangat sederhana dan indah apabila program yang kita tulis akan berjalan 100% tanpa kesalahan sama sekali. Kita tinggal memencet tombol run, dan semuanya berjalan sesuai rencana.

Nyatanya tidak demikian.

Coba Anda ganti salah satu dari beberapa contoh yang sudah diberikan dengan mengganti salah satu kurung { menjadi (. Kemudian pada Eclipse, jalankan dengan "Run -> Run". Lihat apa yang terjadi.

Eclipse akan menampilkan pesan kesalahan, itu artinya secara sintaks, atau format penulisan program ada memiliki kesalahan, dan Anda harus memperbaikinya sebelum program bisa dijalankan.

Sintaks adalah salah satu cara menentukan bagaimana komputer harus bekerja. Manusia tidak membutuhkan sintaks untuk berbicara karena manusia bisa menentukan mana subjek, predikat, atau objek dengan mudah, bahkan untuk kalimat yang belum pernah dibaca atau didengar sekalipun.

Bagi komputer, sintaks membantu komputer mengelola logika, mana yang merupakan variabel, mana yang berupa subrutin, mana perulangan, mana percabangan dan lain-lain. Dalam bahasa Java, yang merupakan bahasa dengan sintaks ketat, perbedaan sintaks sedikit saja membuat Java tidak mengerti apa yang dimaksud dalam program.

Bagi beberapa programmer, ketidakluwesan Java mungkin menghambat, tetapi perlu diingat bahwa kesalahan hanya datang dari manusia. Ketidakluwesan Java membantu programmer harus menggunakan logika yang benar, dan tidak boleh salah dalam menggunakan variabel. Variabel yang sudah ditentukan tipenya tidak dapat diubah ditengah jalan, kecuali dengan membuat variabel baru dengan tipe yang berbeda.

Debugging

Ketika program Anda tidak menunjukkan kesalahan sintaks, bukan berarti program Anda bebas dari kesalahan. Program harus diuji apakah ia berjalan sesuai dengan yang diharapkan. Idealya apabila program menerima input yang tidak sesuai dengan yang diharapkan, program akan memberikan pesan kepada penggunanya tentang kesalahan tersebut, bukan tiba-tiba keluar tanpa pesan.

Kita mungkin harus melakukan testing secara lebih perlahan-lahan. Apabila jumlah baris dalam program kita kecil, mungkin kesalahan tersebut dengan mudah akan kita temui. Tetapi apabila program tersebut sangat besar, maka mencari kesalahan yang kelihatannya sederhana tidaklah mudah.

Pencarian kesalahan ini dalam bahasa pemrograman disebut dengan "debugging", yang jika diterjemahkan ke dalam bahasa Indonesia berarti membersihkan kutu, karena kesalahan kecil dianggap sebagai kutu yang mengganggu jalannya program.

Eclipse menyediakan peralatan untuk melakukan debugging, yaitu dengan menekan tombol "Run -> Debug". Dalam Eclipse, debugging yang bisa dilakukan antara lain: membuat breakpoint (tempat berhenti program), mengeksekusi satu demi satu perintah, mengeksekusi satu subrutin, melihat isi variabel saat ini, dan bahkan mengganti variabel pada saat program dijalankan.

Untuk mendemonstrasikan debugging ini, mari kita gunakan program menghitung rata-rata pada bagian terdahulu.

Membuat breakpoint

Kita bisa menjalankan program baris demi baris, tetapi sebelum kita melakukannya, kita harus memberhentikan program tersebut di satu tempat terlebih dahulu. Tempat pemberhentian program sementara ini disebut breakpoint. Untuk mengeset breakpoint, double klik bagian paling kiri dari baris di mana Anda ingin program tersebut berhenti.

Misalnya pada tampilan berikut, program berhenti di baris double x=0;. Perhatikan juga bahwa baris yang diberi breakpoint memiliki tanda bulat di sampingnya.

Untuk menghapus breakpoint, double click lagi tanda bulat di baris yang sudah diberi breakpoint tadi.

Menjalankan program hingga breakpoint

Coba tekan tombol F11 atau "Run -> Debug". Pada saat Anda memulai debugging, Eclipse akan memberikan pertanyaan bahwa perspective (atau tampilan Eclipse) Anda akan diubah ke debugging perspective. Tekan Yes untuk mengubah perspective tersebut.

Berikut ini adalah perspektif dalam mode debugging.

Perhatikan bahwa di samping tanda bulat tadi, ada tanda panah (->) yang menunjukkan saat ini komputer telah melaksanakan program hingga pada baris ini. Di samping kanan adalah daftar variabel yang dideklarasikan dalam program ini. Karena baris yang kita pilih adalah baris pertama setelah deklarasi pada subrutin main, maka hanya satu variabel yang tersedia, yaitu yang berasal dari arg.

Menjalankan program langkah per langkah

Apabila Anda sudah berada dalam mode debugging, Anda bisa melakukan navigasi untuk melakukan eksekusi sesuka Anda. Ada beberapa pilhan yang disediakan oleh Eclipse, semuanya terdapat dalam menu Run yaitu :

• Resume melanjutkan eksekusi program yang berhenti.
• Suspend menghentikan sementara program yang sedang jalan.
• Terminate menghentikan sesi debugging saat ini.
• Step Into mengeksekusi SATU perintah atau masuk ke dalam subrutin.
• Step Over mengeksekusi SATU perintah. Jika perintah tersebut merupakan perintah panggilan subrutin, maka subrutin tersebut akan dieksekusi tanpa masuk ke dalam subrutin yang dipanggil tersebut.
• Step Return mengeksekusi seluruh perintah pada subrutin ini kemudian kembali kepada pemanggilnya.
• Run to Line menjalankan program dari baris tempat berhentinya program sekarang hingga baris yang Anda tentukan. Atau jika di antaranya terdapat breakpoint lagi, maka program akan berhenti di breakpoint tersebut.

Mari kita coba untuk menjalankan progam satu langkah dengan menggunakan "Run -> Step Over" atau tombol F6.

Berikut ini adalah screen shot setelah program maju satu langkah. Perhatikan bahwa tanda panah maju satu langkah. Dan juga karena instruksi pada baris ini adalah mendeklarasikan variabel x bertipe double, dan kemudian mengisinya dengan 0, variabel ini akan muncul di kanan atas perspektif Debug.



Lakukan terus Step Over hingga program berakhir, dan Anda akan melihat langkah demi langkah bagaimana program dijalankan secara bertahap. Perlu diingat, pada saat program sampai pada instruksi untuk mengambil input Anda, klik bagian bawah (tab yang bernama Console), dan masukkan angka sebagai input kemudian tekan Enter. Lihat bagaimana variabel di kanan atas berubah sesuai dengan input yang Anda berikan.

Melihat dan mengubah isi variabel
Di sini saya jalankan program setiap baris hingga a = a + 1 seperti pada gambar berikut.



Kemudian, saya ingin memperpanjang perulangan, sehingga bukan melakukan 5 kali perulangan, tetapi 6 kali, yaitu dengan mengubah nilai a menjadi -1. Ini bisa dilakukan yaitu dengan mengklik nilai dari a, yang semula 0, kemudian diganti menjadi -1, seperti pada screen shot berikut.



Setelah diganti coba jalankan program hingga selesai, misalnya dengan "Run -> Resume". Jangan lupa untuk memasukkan inputnya di bagian Console. Lihat sekarang bilangan ke-0 ditanyakan 2 kali, yang artinya user diperintahkan untuk memasukkan 6 bilangan. Tentunya hasil rata-ratanya salah, karena perhitungan rata-rata dilakukan dengan rumus x = x/5, dalam hal ini seharusnya adalah 6.



Setelah selesai melakukan debugging, Anda mungkin ingin mengubah perspektif kembali seperti semula. Caranya, di bagian paling kanan (lihat gambar dibawah), klik tanda >> kemudian pilihan akan muncul. Klik perspektif Java untuk mengubahnya menjadi tampilan semula.