5. Pengantar Kelas Bagian 2

Menambahkan Metode Pada Kelas Kotak

Adalah legal untuk menciptakan sebuah kelas yang hanya memuat data, namun hal itu jarang terjadi. Pada hampir semua kasus, Anda memerlukan metode untuk mengakses variabel yang didefinisikan oleh kelas. Pada dasarnya, metode mendefinisikan antarmuka ke kelas. Ini membuat perancang kelas dapat menyembunyikan struktur data internal. Di samping mendefinisikan metode yang mengakses data kelas, Anda juga bisa mendefinisikan metode yang dipakai secara internal di dalam kelas.

Anda akan menambahkan sebuah metode pada kelas Kotak. Anda dapat memperhatikan bahwa, pada program-program sebelumnya, penghitungan volume kotak lebih baik ditangani oleh kelas Kotak daripada oleh kelas DemoKotak. Karena volume kotak bergantung pada ukuran kotak, maka masuk akal bila kelas Kotak yang menghitungnya. Untuk melakukannya, Anda perlu menambahkan sebuah metode pada kelas Kotak, seperti ditunjukkan di sini:

class Kotak {
   double lebar;
   double tinggi;
   double dalam;
    
   // menampilkan volume kotak
   void volume() {
      System.out.print("Volume kotak = ");
      System.out.println(lebar * tinggi * dalam);
   }
}

public class DemoKotak3 {
   public static void main(String args[]) {
      Kotak kotakKu1 = new Kotak();
      Kotak kotakKu2 = new Kotak();
  
      // menugaskan nilai pada tiap variabel objek kotakKu1
      kotakKu1.lebar = 10;
      kotakKu1.tinggi = 20;
      kotakKu1.dalam = 15;
   
      // menugaskan nilai pada tiap variabel objek kotakKu2
      kotakKu2.lebar = 3;
      kotakKu2.tinggi = 6;
      kotakKu2.dalam = 9;
   
      // Menghitung volume kotak pertama
      kotakKu1.volume();
  
      // Menghitung volume kotak kedua
      kotakKu2.volume();
   }
}

Program ini menghasilkan keluaran berikut, yang sama dengan versi program sebelumnya:

Volume kotak = 3000.0
Volume kotak = 162.0

Lihat lebih dekat dua baris kode berikut:

kotakKu1.volume();
kotakKu2.volume();

Baris pertama di sini memanggil metode volume() pada objek kotakKu1. Jadi, ia memanggil metode volume() yang menjadi milik dari objek kotakKu1, menggunakan nama objek yang diikuti dengan operator dot. Jadi, pemanggilan terhadap kotakKu1.volume() menampilkan volume kotak yang didefinisikan oleh kotakKu1, dan pemanggilan terhadap kotakKu2.volume() menampilkan volume kotak yang didefinisikan oleh kotakKu2. Setiap kali volume() dipanggil, ia menampilkan volume untuk kotak tertentu.

Jika Anda tidak familiar dengan konsep pemanggilan sebuah metode, diskusi berikut akan memperjelasnya. Ketika kotakKu1.volume() dieksekusi, sistem run-time Java akan mengalihkan kendali program ke kode yang ada di dalam volume(). Setelah statemen-statemen pada volume() dieksekusi, kendali program kembali ke pemanggil, dan eksekusi dilanjutkan dengan baris kode yang ada setelah pemanggilan metode tersebut.

Ada satu hal yang paling penting untuk dicatat tentang metode volume(): variabel-variabel kelas lebar, tinggi, dalam diakses secara langsung, tanpa perlu menyebutkan nama objek atau operator dot. Ketika sebuah metode menggunakan variabel kelas yang didefinisikan di dalam kelasnya, metode itu melakukannya secara langsung, tanpa perlu menyebutkan nama objek dan tanpa menggunakan operator dot.

Menghasilkan Nilai Balik
Ketika implementasi dari volume() memang melakukan penghitungan volume kotak di dalam kelas Kotak, hal itu bukanlah cara terbaik dalam melakukannya. Misalnya, bagaimana jika bagian program lain ingin mengetahui volume kotak tersebut, tetapi tidak ingin menampilkan nilainya? Cara terbaik untuk mengimplementasikan volume() adalah dengan menghitung volume kotak dan memberikan nilainya kepada pemanggil. Contoh berikut, sebuah versi terperbaiki dari program sebelumnya, melakukannya:

//Sekarang volume() menghasilkan nilai balik
class Kotak {
   double lebar;
   double tinggi;
   double dalam;
    
   // menampilkan volume kotak
   double volume() {
      return lebar*tinggi*dalam;
   }
}

public class DemoKotak4 {
   public static void main(String args[]) {
      Kotak kotakKu1 = new Kotak();
   Kotak kotakKu2 = new Kotak();
   double vol;
  
      // menugaskan nilai pada tiap variabel objek kotakKu1
      kotakKu1.lebar = 10;
      kotakKu1.tinggi = 20;
      kotakKu1.dalam = 15;
   
      // menugaskan nilai pada tiap variabel objek kotakKu2
      kotakKu2.lebar = 3;
      kotakKu2.tinggi = 6;
      kotakKu2.dalam = 9;
   
      // Menghitung volume kotak pertama
      vol=kotakKu1.volume();
      System.out.println("Volume Kotak 1 = " + vol);
  
      // Menghitung volume kotak kedua
      vol = kotakKu2.volume();
      System.out.println("Volume Kotak 2 = " + vol);
   }
}

Seperti yang dapat Anda lihat, ketika volume() dipanggil, ia berada di sisi kanan dari sebuah statemen penugasan. Di sisi kiri adalah sebuah variabel, pada kasus ini vol, yang akan menerima nilai yang dihasilkan oleh volume(). Jadi, setelah

vol = kotakKu1.volume();

dieksekusi, nilai dari kotakKu1.volume() adalah 3000 dan nilai ini kemudian disimpan ke dalam vol. Ada dua hal penting untuk dipahami tentang nilai balik dari metode:

• Tipe data yang dihasilkan sebuah metode harus kompatibel dengan tipe data nilai balik yang ditetapkan pada metode. 
• Variabel yang menerima nilai balik dari sebuah metode (seperti vol, pada kasus ini) harus kompatibel dengan tipe data nilai balik metode.

Satu hal penting lain: Program sebelumnya dapat ditulis dengan lebih efisien karena sebenarnya variabel vol tidak diperlukan program. Pemanggilan terhadap metode volume() dapat langsung dipakai pada statemen println(), seperti ditunjukkan di sini:

System.out.println(“Volume Kotak 1 = “ + kotakKu1.volume());

Pada kasus ini, ketika println() dieksekusi, kotakKu1.volume() akan dipanggil secara otomatis dan nilainya akan dilewatkan kepada println().


Menambahkan Metode Yang Mengambil Parameter
Beberapa metode memang tidak memerlukan parameter, tapi kebanyakan metode memerlukannya. Metode terparameterisasi atau metode yang memiliki parameter dapat beroperasi dapat beroperasi pada data. Untuk mengilustrasikan hal ini, lihat contoh sangat sederhana berikut, dimana sebuah metode menghasilkan nilai balik berupa kuadrat dari 10:

int kuadrat()
{
   return 10 * 10;
}

Memang metode ini menghasilkan nilai berupa 10 yang dikuadratkan, tetapi kegunaannya sangat terbatas. Jika Anda memodifikasi metode tersebut sehingga ia dapat menerima parameter, seperti ditunjukkan berikut, maka Anda dapat membuat kuadrat() lebih berguna:

int kuadrat(int i)
{
   return i * i;
}

Sekarang, kuadrat() akan menghasilkan kuadrat dari nilai yang diberikan kepadanya. Jadi, kuadrat() sekarang merupakan sebuah metode umum yang dapat menghitung kuadrat dari setiap nilai integer, bukan hanya 10.

Berikut adalah sebuah contoh:

int x, y;
x = kuadrat(5);  // x bernilai 25
x = kuadrat(9);  // x bernilai 81
y = 2;
x = kuadrat(y);  // x bernilai 4

Pada pemanggilan pertama terhadap kuadrat(), nilai 5 akan dilewatkan kepada parameter i. Pada pemanggilan kedua, i akan menerima nilai 9. Pemanggilan ketiga melewatkan nilai dari y, pada kasus ini 2. Seperti ditunjukkan pada contoh-contoh ini, kuadrat() menghasilkan kuadrat dari apapun data yang dilewatkan kepadanya.

Adalah penting untuk memperjelas apa itu parameter dan argumen. Parameter adalah sebuah variabel yang didefinisikan oleh sebuah metode yang menerima nilai ketika metode dipanggil. Sebagai contoh pada kuadrat(), i adalah parameter. Argumen adalah sebuah nilai yang dilewatkan kepada metode ketika metode itu dipanggil. Sebagai contoh, kuadrat(100) melewatkan 100 sebagai argumen. Di dalam kuadrat(), parameter i menerima nilai tersebut.

Anda bisa menggunakan metode terparameterisasi untuk memperbaiki kelas Kotak. Pada contoh-contoh sebelumnya, dimensi dari tiap kotak ditetapkan secara terpisah menggunakan runtun statemen semacam ini:

kotakKu1.lebar = 10;
kotakKu1.tinggi = 20;
kotakKu1.dalam = 15;

Memang kode ini bisa dipakai, tetapi cukup bermasalah. Pertama, hal itu berantakan dan bisa berpotensi error. Sebagai contoh, Anda akan lebih muda lupa untuk menetapkan dimensi. Kedua, dalam program-program Java yang dirancang dengan baik, variabel kelas seharusnya hanya bisa diakses oleh metode yang didefinisikan oleh kelasnya.

Jadi, pendekatan yang lebih baik dalam menetapkan dimensi kotak adalah dengan menciptakan sebuah metode yang mengambil dimensi-dimensi dari sebuah kotak pada parameter-parameternya dan menetapkan nilai untuk tiap variabel kelas dengan tepat. Konsep ini diimplementasikan pada program berikut:

//program ini menggunakan metode terparameterisasi
class Kotak {
   double lebar;
   double tinggi;
   double dalam;
    
   // menampilkan volume kotak
   double volume() {
      return lebar*tinggi*dalam;
   }
   
   // menetapkan dimensi-dimensi kotak
   void setDim(double w, double h, double d) {
      lebar = w;
      tinggi = h;
      dalam = d;
   }
}

public class DemoKotak5 {
   public static void main(String args[]) {
      Kotak kotakKu1 = new Kotak();
   Kotak kotakKu2 = new Kotak();
   double vol;
  
      // menginisialisasi setiap kotak
      kotakKu1.setDim(10, 20, 15);
      kotakKu2.setDim(3, 6, 9);
   
      // Menghitung volume kotak pertama
      vol=kotakKu1.volume();
      System.out.println("Volume Kotak 1 = " + vol);
  
      // Menghitung volume kotak kedua
      vol = kotakKu2.volume();
      System.out.println("Volume Kotak 2 = " + vol);
   }
}

Seperti yang dapat Anda lihat, metode setDim() dipakai untuk menetapkan dimensi-dimensi dari setiap kotak. Sebagai contoh, ketika

kotakKu1.setDim(10, 20, 15);

dieksekusi, 10 disalin ke parameter w, 20 disalin ke parameter h, dan 15 disalin ke parameter d. Di dalam setDim(), nilai dari w, h, dan d kemudian ditugaskan kepada lebar, tinggi, dan dalam.


Konstruktor
Akan cukup merepotkan untuk menginisialisasi semua variabel kelas setiap kali sebuah objek diciptakan. Bahkan ketika Anda menambahkan metode seperti setDim(), akan lebih mudah dan sederhana untuk melakukannya pada saat objek pertama kali diciptakan. Karena persyaratan inisialisasi, Java membolehkan objek-objek untuk diinisialisasi ketika objek-objek itu diciptakan. Inisialisasi otomatis tersebut dilakukan melalui penggunaan konstruktor.

Konstruktor menginisialisasi sebuah objek sesaat setelah objek itu diciptakan. Konstruktor memiliki nama sama dengan nama kelas yang mendefinisikannya dan secara sintaksis sama dengan sebuah metode. Setelah didefinisikan, konstruktor secara otomatis dipanggil ketika objek diciptakan, sebelum operator new selesai dieksekusi. Konstruktor tampak sedikit aneh karena ia tidak memiliki nilai balik apapun, bahkan void sekalipun. Ini karena tipe data implisit dari konstruktor kelas sebenarnya adalah kelas itu sendiri. Adalah tugas konstruktor untuk menginisialisasi keadaan internal dari sebuah objek.

Anda akan menulis ulang contoh kelas Kotak sehingga dimensi-dimensi dari sebuah kotak secara otomatis diinisialisasi ketika sebuah objek diciptakan. Untuk melakukannya, Anda mengganti setDim() dengan sebuah konstruktor.

Anda memulainya dengan mendefinisikan sebuah konstruktor sederhana yang hanya menetapkan dimensi-dimensi dari setiap kotak dengan nilai yang sama:

//program ini menggunakan konstruktor untuk menginisialisasi objek
class Kotak {
   double lebar;
   double tinggi;
   double dalam;
   
   // Ini adalah konstruktor untuk kelas Kotak.
   Kotak() {
      System.out.println("Menciptakan objek Kotak");
      lebar = 10;
      tinggi = 10;
      dalam = 10;
   }    
   // menampilkan volume kotak
   double volume() {
      return lebar*tinggi*dalam;
   }
}

public class DemoKotak6 {
   public static void main(String args[]) {
      Kotak kotakKu1 = new Kotak();
   Kotak kotakKu2 = new Kotak();
   
   double vol;
   
      // Menghitung volume kotak pertama
      vol=kotakKu1.volume();
      System.out.println("Volume Kotak 1 = " + vol);
  
      // Menghitung volume kotak kedua
      vol = kotakKu2.volume();
      System.out.println("Volume Kotak 2 = " + vol);
   }
}

Ketika program tersebut dijalankan, Anda akan melihat keluaran ini:

Menciptakan objek Kotak
Menciptakan objek Kotak
Volume Kotak 1 = 1000.0
Volume Kotak 2 = 1000.0

Selanjutnya  >>>