MODUL X,PBO 1

PEWARISAN SIFAT BAGIAN 2
 

TUJUAN:
·         Mahasiswa mampu melakukan pemanggilan konstruktor superclass
·         Mahasiswa mampu meng-Overriding method
TEORI SINGKAT:
Keyword super dipanggil ketika kita akan menciptakan kelas dari subclass maka kelas induk akan dipanggil dengan sebutan super.
Overriding atau overloading dalam subclass degan nama dan parameter yang sama, serta return type yang sama dengan yang ada dalam superclass sehingga akan menimpa method pada superclass. Akan tetapi subclass masih diperkenankan untuk mewarisi sifat dari superclass yang cukup dekat (setipe) untuk kemudian memodifikasi sesuai perilaku yang diinginkan.
PELAKSANAAN PRAKTIKUM:
Listing program 1. Titik.java
public class Titik{
  private int x;
  private int y;
//konstruktor tanpa argumen
  public Titik(){
       System.out.println(“Konstruktor Titik tanpa argumen”);
       x=0;
       y=0;
  }
//Konstruktor dengan argumen x dan y
  public Titik(int x, int y){
  System.out.println(“Konstruktor Titik dengan Argumen”);
       this.x=x;
       this.y=y;
  }
//set kordinator Titik: x dan y
  public void setKoordinat(int xx, int yy){
       x=xx;
       y=yy;
  }
//ambil koordinat x
  public int getX(){
       return x;
  }
//ambil koordinat y
  public int getY(){
       return y;
  }
//Cetak ke layar
  public void cetak(){
       System.out.println(“X = ” + x + “, y = “+ y);
  }
}
Pada kelas titik di atas kita mendefinisikan konstruktor yaitu sebuah perintah untuk mengkonstruksi suatu variabel. Method yang bersifat konstruktor ini berfungsi pada saat pemanggilan untuk mendefinisikan apakah pemanggilan tersebut menggunakan parameter atau tidak. Jika tidak menggunakan parameter maka secara otomatis java akan menggunakan variabel-variabel yang terdifinisi dari konstruktor non parametrik, sedangkan apabila pada saat pemanggilan kita menerakan parameter maka secara otomatis akan menggunakan variabel yang terdifinisi dari konstruktor dengan parameter.
Namun kita juga dapat melakukan perubahan terhadap value dari variabel tersebut tidak dengan konstruktor tetapi menggunakan method setKoordinat dimana method tersebut menggunakan parameter int xx dan int yy untuk mengisikan variabel x dan y sebagaimana terdifinisi pada method getter getX dan getY. Untuk kemudian masing-masing dimasukkan ke variabel x dan y dengan pernyataan return value. Inilah yang kemudian pada saat method cetak dipanggil maka akan mengeluarkan nilai variabel x dan y sebagaimana terdifinisi pada konstruktor atau mungkin setelah dilakukan perubahan pada saat method setKoordinat dipanggil.
Kelas Lingkaran
//Lingkaran mewarisi Titik
public class Lingkaran extends Titik{
protected double radius;
//Konstruktor tanpa argumen
public Lingkaran(){
  super();
  radius=0.0;
  }
//Konstruktor argumen radius
public Lingkaran(int x, int y, double rad){
  super(x,y);
  setRadius(rad);
  }
//set radius dari Lingkaran
  public void setRadius(double rad){
       radius=(rad>=0.0 ? rad :0.0);
  }
//ambil radius dari Lingkaran
  public double getRadius(){
       return radius;
  }
//hitung luas Lingkaran
  public double luas(){
       return Math.PI * radius * radius;
  }
//cetak hasil ke layar
  public void cetakHasil(){
       System.out.println(“Pusat  = [“+getX() +”, “+getY()+”]”);
       System.out.println(“Radius = “+radius);
       System.out.println(“Luas   = “+luas());
  }
      }
Listing kelas Lingkaran pada program Lingkaran.java ini merupakan kelas turunan dari kelas Titik. Ciri dari kelas turunan adalah adanya statemen extends (bagian dari) kelas yang disebutnya, yaitu kelas Titik. Dengan mengextends superclass kita dapat mengambil variabel ataupun method yang sudah terdifinisi pada kelas induknya. Suatu yang diperbolehkan dalam kelas adalah memunculkan konstruktor baik dengan parameter maupun tanpa menggunakan parameter. Di dalam konstruktor anak kelas dapat mengambil variabel dari induk kelas dengan kata super. Pada listing di atas kita tidak mendefinisikan variabel x dan y dan hanya memasukkan radius sebagai sebuah variabel. Tetapi variabel x dan variabel y tetap dapat dipanggil karena variabel x dan y tersebut diambilkan dari kelas Titik sebagai kelas induk/superclassnya.
Sebagai contoh dua pernyataan di dalam konstruktor Lingkaran yang menggunakan parameter, disebut super(x,y) artinya pada konstruktor itu java diminta untuk meload variabel x dan y dari superkelasnya yaitu Titik. Hal tersebut juga dilakukan untuk mendevinisikan variabel radius dengan memanggil method setRadius(rad) dari konstruktor Lingkaran. Artinya nilai radius diambilkan dari nilai radius yang berada pada kelas Lingkaran ini sendiri.
Pada method setRadius nilai radius ditentukan oleh besarnya nilai rad yang dimasukkan sebagai parameter, namun apabila nilai rad yang dimasukkan kurang dari nol maka dengan sendirinya nilai radius akan didevinisikan sebagai 0.0. Kalau radius bernilai negatif maka tidak akan mungkin luas lingkaran yang diperoleh dari perkalian radius dan phi bernilai negatif. Oleh karena itu dibuat rumus radius=rad>=0.0 ? rad : 0.0. Arinya radius bernilai sama dengan rad jika nilai rad lebih besar atau sama dengan nol jika nilai rad kurang dari nol maka maka nilai radius tetap 0.0. Setelah itu nilai radius akan dimasukkan ke method getRadius.
Nilai luas diperoleh dari hasil kali konstanta PHI dengan kuadrat nilai radius. Sebagai return valuenya adalah method luas(). Sedangkan untuk mencetak hasil dari nilai-nilai yang didefinisikan dari kelas Lingkaran di atas menggunakan method cetakHasil() yang didalamnya adalah mencetak dengan System.out.println mulai dari titik pusat yang diperoleh dari getX dan getY, kemudian nilai radius dan luas lingkaran yang diperoleh dari perhitungan method luas().
Kelas Pemanggilan TestLingkaran
public class TestLingkaran{
  public static void main(String[]args){
       Lingkaran ling1=new Lingkaran();
       ling1.cetakHasil();
  }
}
Langkah terakhir adalah kelas pemanggilan yang tentu saja mewajibkan kita menggunakan kelas main. Dalam kelas-kelas di atas program ini dimaksudkan untuk melakukan penghitungan terhadap luas suatu lingkaran. Dimana kelas lingkaran tersebut juga mengambil beberapa variabel dari kelas Titik. Ini dapat ditunjukkan pada pemanggilan di kelas main. Bahwa kelas titik betul-betul mempunyai peran serta pada proses di kelas lingkaran. Kita lihat di bawah ini karena method main ini memanggil kelas dengan objek yang diciptakan dari kelas Lingkaran yaitu objek ling1 dengan konstruktor non parametrik (Lingkaran ling1=new Lingkaran();) maka yang dihasilkannya adalah tercetaknya statemen “Konstruktor Titik tanpa argumen”. Dimana statemen tersebut kita tuliskan pada konstruktor tanpa parameter di kelas Titik. Dan hasilnya pun bernilai 0 semua.
Hasil Program:
               
Para pemanggilan kelas dengan konstruktor parametrik / argumen sebagaimana di bawah yang menggunakan argumen 12, 5, 10 yang artinya bahwa nilai variabel x = 12, y = 5 dan radius adalah 10, maka akan menghasilkan nilai-nilai sebagaimana terpampang di bawah ini yaitu perhitungan luas lingkaran yang diperoleh dari perhitungan method luas() pada kelas Lingkaran.
Pemanggilan dengan parameter:
public class TestLingkaran{
     public static void main(String[]args){
       Lingkaran ling1=new Lingkaran(12,5,10);
       ling1.cetakHasil();
     }
}
Hasil Program:
Jika kedua program digabung dengan cara menuliskan semua pemanggilan method
Ketika ditambah method cetakHasil()
@override
     public void cetakHasil(){
       System.out.println(“Pusat  = [“+getX() +”, “+getY()+”]”);
       System.out.println(“Radius = “+radius);
       System.out.println(“Luas   = “+luas());
     }
Dikompilasi akan error sebagaimana keterangan di bawah:
E:\Semester 2\Object Oriented Programming 1\Modul10-Pewarisan\Lingkaran.java:51: cetakHasil() is already defined in Lingkaran
     public void cetakHasil(){
                 ^
E:\Semester 2\Object Oriented Programming 1\Modul10-Pewarisan\Lingkaran.java:43: cannot find symbol
symbol  : class override
location: class Lingkaran
@override
 ^
2 errors
Ketika diganti dengan cetak() saja maka dikompilasi sukses
Membuat kelas Tabung dengan ketentuan:
//kelas tabung turunan kelas lingkaran
public class Tabung extends Lingkaran{
     private double tinggi;
     //Konstruktor dengan argumen x, y, radius dan tinggi
     public Tabung(int x, int y, double radius, double tinggi){
       this.x=x;
       this.y=y;
       this.radius=radius;
       this.tinggi=tinggi;
     }
     //Method luas yang mengoverride method luas() pada kelas Lingkaran
     @Override
     public double luas(){
       return Math.PI * radius * radius;
     }
     public double volume(){
       return Math.PI * radius * radius*tinggi;
     }
     //Method cetak yang mengoverride method cetak() pada kelas Lingkaran
     public void cetak(){
            System.out.println(“Pusat  = [“+getX() +”, “+getY()+”]”);
            System.out.println(“Radius = “+tinggi);
            System.out.println(“Radius = “+radius);
            System.out.println(“Luas   = “+luas());
            System.out.println(“volume = “+volume());
     }
}
Kelas ini ketika kita kompail akan terjadi erro yang menanyakan x has private access in Titik this.x=x; Sehingga kita harus melakukan perubahan pada class Titik variable int x dan y dari private ke public atau ke protected. Karena apa hak akses private tidak memperbolehkan variable ini diakses oleh subkelas hanya dapat diakses oleh kelas yang berangkutan. Setelah kita ganti dengan public atau protected, hak akses dibuka untuk kelas turunan bahkan sampai turunan kedua dan seterusnya.
Ketika kita panggil kelas PersegiPanjang di atas dengan kelas main sebagaimana ditulis dibawah ini akan menghasilkan keluaran berupa penulisan kata Konstruktor Titik tanpa argument yang menandakan bahwa ada proses pengaksesan pada kelas TItik, kemudian penentuan pusat  yang berisi [2, 4] menandakan bahwa pada kelas Tabung diakses method getter dan setter untuk menentukan pusat serta method untuk menentukan radius sebesar 5. Selain itu menunjukkan  bahwa method penghitungan luas serta volume tabung yang diperoleh dari hasil perkalian PHI, radius dikuadratkan dan tinggi tabung. Hal ini diperoleh dari pendefinisian objek dari Kelas Tabung dengan parameter 2, 4, 5, 7 yang berarti 2 untuk x, 4 untuk y, 5 untuk radius dan 7 adalah isian untuk variable tinggi tabung.
public class TestTabung{
     public static void main(String[]args){
       Tabung tabung=new Tabung(2,4,5,7);
       tabung.luas();
       tabung.cetak();
     }
}
Hasil Program:
LATIHAN:
Terlebih dahulu lakukan perubahan pada kelas Titik yaitu untuk mendefinisikan variable int x dan int y menjadi public. Karena kelas Titik ini variabelnya akan digunakan oleh kelas turunan  sebagaimana pada saat kita menggunakan variable ini pada kelas tabung. Jika tidak akan terjadi error yang menanyakan x has private access in Titik this.x=x;
public class Titik{
  private int x;
  private int y;
public class Titik{
  public int x;
  public int y;
Pembuatan Kelas PersegiPanjang
public class PersegiPanjang extends Titik{
     public int x2, y2;
     public void PersegiPanjang(int x, int y, int x2, int y2){
       this.x=x;
       this.y=y;
       this.x2=x2;
       this.y2=y2;
     }
     public void cetakTitik(){
       System.out.println(x+”, “+y);
       System.out.println(x2+”, “+y2);
     }
     //Panjang = x2-x1; Lebar=y2-y
     public double luas(){
       return (x2-x) * (y2-y);
     }
     public void cetakLuas(){
       System.out.println(“Panjang    = “+(x2-x));
       System.out.println(“Lebar      = “+(y2-y));
       System.out.println(“Luas Segi4 = “+luas());
     }
}
Pemanggilan Kelas PersegiPanjang
public class TestSegi4{
     public static void main(String[]args){
       PersegiPanjang segiP=new PersegiPanjang(1,2,5,6);
       segiP.luas();
       segiP.cetakLuas();
     }
}
Hasil Program
TUGAS:
Membuat kelas Balok sebagai turunan dari kelas PersegiPanjang:
public class Balok extends PersegiPanjang{
     public int z;
     public Balok(){
       System.out.print(“Kelas Balok tanpa parameter”);
       this.x=x;
       this.y=y;
       this.x2=x2;
       this.y2=y2;
       this.z=z;
     }
     public Balok(int x, int y, int x2, int y2, int z){
       System.out.print(“Kelas Balok dengan parameter”);
       this.x=x;
       this.y=y;
       this.x2=x2;
       this.y2=y2;
       this.z=z;
     }
     //Panjang = x2-x1; Lebar=y2-y; tinggi=z;
     @Override
     public double luas(){
       return (x2-x) * (y2-y);
     }
     //Panjang = x2-x1; Lebar=y2-y; tinggi=z;
     public double volumeBalok(){
       return luas() * z;
     }
     public void cetakVolume(){
       System.out.println(“Diketahui dengan adanya 2 buah titik, yaitu :”);
       System.out.println(“Pojok Kiri Atas (x1,y1) di titik [“+x+”,”+y+”]”);
       System.out.println(“Pojok Kanan Bawah (x2,y2) di titik [“+x2+”,”+y2+”] Maka :”);
       System.out.println(“Panjang = “+(x2-x));
       System.out.println(“Lebar   = “+(y2-y));
       System.out.println(“Tinggi  = “+z);
       System.out.println(“Volume  = “+volumeBalok());
     }
}
Membuat kelas TestBalok untuk memanggil hasil proses di kelas Titik, PersegiPanjang dan kelas Balok:
public class TestBalok{
     public static void main(String[]args){
       Balok blk1=new Balok();
       blk1.volumeBalok();
       blk1.cetakVolume();
       Balok blk2=new Balok(3,8,4,12,5);
       blk2.volumeBalok();
       blk2.cetakVolume();
     }
}
Hasilnya adalah:
               
KESIMPULAN:
  1. Pada class turunan dimungkinkan juga untuk meredefinisikan atau memodifikasi data dan method dari class induknya di class turunan, proses ini akan mengubah data dan method dari keduanya, kelas induk dan kelas anaknya. Istilah ini sering disebut dengan Overloading/Overriding.
  2. Overriding hanya bisa dilakukan untuk data dan method yang memiliki modifier public, protected maupun default.
  3. Dengan adanya overriding method, object akan langsung menggunakan method yang didefinisikan pada class tersebut
Untuk mengakses method yang sama milik calss induk dibutuhkan keyword super
Contoh :
super.A=10;
super.tampilan();
  1. Beberapa alasan menggunakan overriding :
    • Mendefinisikan kembali method kelas induknya secara total
      Perubahan dilakukan secara menyeluruh, baik jumlah maupun tipe parameter dari argumen inputnya, tipe nilai kembaliannya, maupun behaviour pemrosesan datanya.
    • Menambahkan behaviour tertentu pada method kelas induknya
      Perubahan hanya dilakukan untuk menambahkan behaviour yang secara khusus dimiliki hanya oleh kelas anak tersebut.
o   Pada kelas turunan juga dapat dipastikan memiliki constructor dari class induk.

Ø  Untuk menggunakan constructor milik class induk kita cukup menggunakan keyword super
Ø  Tidak perlu menuliskan nama constructor, tetapi cukup menggunakan keyword super diikuti parameter yang sama dengan class induk.
  1. Penggunaan konstrktor, method setter dan getter ini salah satunya dimaksudkan untuk enkapsulasi, yaitu sebuah penyembunyian di dalam kelas agar tidak mudah diakses oleh orang lain.
Advertisements

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s