Seperti yang sudah kita pelajari pada tulisan sebelumnya: sebuah class atau objek bisa saling berhubungan dengan class yang lain.
Salah satu bentuk hubungannya adalah inheritance (pewarisan). Hubungan ini seperti hubungan keluarga antara orang tua dan anak.
Sebuah class di Java, bisa memiliki satu atau lebih keturunan atau class anak. Class anak akan memiliki warisan properti dan method dari class ibu.
Pada tutorial ini kita akan belajar:
- Kenapa kita harus menggunakan inheritance?
- Contoh Program inheritance
- Method Overriding
Mari kita mulai…
Kenapa Kita Harus Menggunakan Inheritance?
Misalkan dalam Game, kita akan membuat class-class musuh dengan perilaku yang berbeda.
Lalu kita membuat kode untuk masing-masing kelas seperti ini:
File:
Zombie.javaclass Zombie {
String name;
int hp;
int attackPoin;
void attack(){
// ...
}
void walk(){
//...
}
}
File:
Pocong.javaclass Pocong {
String name;
int hp;
int attackPoin;
void attack(){
// ...
}
void jump(){
//...
}
}
File:
Burung.javaclass Burung {
String name;
int hp;
int attackPoin;
void attack(){
// ...
}
void walk(){
//...
}
void jump(){
//...
}
void fly(){
//...
}
}
Apakah boleh seperti ini?
Ya, boleh-boleh saja. Akan Tapi tidak efektif, karena kita menulis berulang-ulang properti dan method yang sama.
Bagaimana solusinya?
Kita harus menggunakan inheritance.
Mari kita lihat memeber class yang sama:
Setelah menggunakan inheritance, maka akan menjadi seperti ini:
Oya, inheritance di StarUML digambarkan dengan garis hubung Generalization.
Class
Enemy adalah class induk yang memiliki anak Zombie, Pocong, dan Burung. Apapun properti yang ada di class induk, akan dimiliki juga oleh class anak.
Lalu bagaimana bentuk kodenya dalam Java?
Bentuk kodenya akan seperti ini:
File:
Enemy.javaclass Enemy {
String name;
int hp;
int attackPoin;
void attack(){
System.out.println("Serang!");
}
}
Pada class anak, kita menggunakan kata kunci
extends untuk menyatakan kalau dia adalah class turunan dari Enemy.
File:
Zombie.javaclass Zombie extends Enemy {
void walk(){
System.out.println("Zombie jalan-jalan");
}
}
File:
Pocong.javaclass Pocong extends Enemy {
void jump(){
System.out.println("loncat-loncat!");
}
}
File:
Burung.javaclass Burung extends Enemy {
void walk(){
System.out.println("Burung berjalan");
}
void jump(){
System.out.println("Burung loncat-loncat");
}
void fly(){
System.out.println("Burung Terbang...");
}
}
Lalu, bila kita ingin membuat objek dari class-class tersebut, Kita bisa membuatnya seperti ini:
Enemy monster = new Enemy();
Zombie zumbi = new Zombie();
Pocong hantuPocong = new Pocong();
Burung garuda = new Burung();
Contoh Program Inheritance
Setelah memahami konsep inheritance, sekarang mari kita buat contoh program sederhana.
Program yang akan kita buat untuk berfungsi untuk menghitung luas dan keliling bangun datar.
Bentuk class diagramnya seperti ini:
Baik, mari kita buat semua class-class-nya.
Buka Netbeans, pada Porject yang kemarin, buatlah package baru bernama inheritance di dalam Source Packages.
Isi nama package dengan inheritance.
Berikutnya buatlah class-class baru berdasarkan diagram di atas.
File:
inheritance/BangunDatar.javapackage inheritance;
public class BangunDatar {
float luas(){
System.out.println("Menghitung laus bangun datar");
return 0;
}
float keliling(){
System.out.println("Menghitung keliling bangun datar");
return 0;
}
}
File:
inheritance/Persegi.javapackage inheritance;
public class Persegi extends BangunDatar {
float sisi;
}
File:
inheritance/Lingkaran.javapackage inheritance;
public class Lingkaran extends BangunDatar{
// jari-jari lingkaran
float r;
}
File:
inheritance/PersegiPanjang.javapackage inheritance;
public class PersegiPanjang extends BangunDatar {
float panjang;
float lebar;
}
File:
inheritance/Segitiga.javapackage inheritance;
public class Segitiga extends BangunDatar {
float alas;
float tinggi;
}
File:
inheritance/Main.javapackage inheritance;
public class Main {
public static void main(String[] args) {
// membuat objek bangun datar
BangunDatar bangunDatar = new BangunDatar();
// membuat objek persegi dan mengisi nilai properti
Persegi persegi = new Persegi();
persegi.sisi = 2;
// membuat objek Lingkaran dan mengisi nilai properti
Lingkaran lingkaran = new Lingkaran();
lingkaran.r = 22;
// membuat objek Persegi Panjang dan mengisi nilai properti
PersegiPanjang persegiPanjang = new PersegiPanjang();
persegiPanjang.panjang = 8;
persegiPanjang.lebar = 4;
// membuat objek Segitiga dan mengisi nilai properti
Segitiga mSegitiga = new Segitiga();
mSegitiga.alas = 12;
mSegitiga.tinggi = 8;
// memanggil method luas dan keliling
bangunDatar.luas();
bangunDatar.keliling();
persegi.luas();
persegi.keliling();
lingkaran.luas();
lingkaran.keliling();
persegiPanjang.luas();
persegiPanjang.keliling();
mSegitiga.luas();
mSegitiga.keliling();
}
}
Setelah itu, coba jalankan class
Main, maka hasilnya:
Kenapa hasilnya bisa begitu?
Karena yang kita panggil sebenarnya adalah method
luas() dan keliling() milik si induk (BangunDatar).
Objek anak dari
BangunDatar belum memiliki method luas() dan keliling(), akhirnya mengambil milik induknya.
Lalu bagaimana kalau kita ingin membuat agar semua class anak memiliki method
luas() dan keliling() yang berbeda dari induk?
Jawabanya: menggunakan method overriding.
Method Overriding
Method Overriding dilakukan saat kita ingin membuat ulang sebuah method pada sub-class atau class anak.
Method Overriding dapat dibuat dengan menambahkan anotasi
@Override di atas nama method atau sebelum pembuatan method.
Contoh:
Persegi.javaclass Persegi extends BangunDatar {
float sisi;
@Override
float luas(){
float luas = sisi * sisi;
System.out.println("Luas Persegi: " + luas);
return luas;
}
@Override
float keliling(){
float keliling = 4 * sisi;
System.out.println("Keliling Persegi: " + keliling);
return keliling;
}
}
Artinya kita menulis ulang method
luas() dan keliling() di class anak.
Sekarang mari kita buat method overriding untuk semua class anak.
File:
Lingkaran.javapackage inheritance;
public class Lingkaran extends BangunDatar{
// jari-jari lingkaran
float r;
@Override
float luas(){
float luas = (float) (Math.PI * r * r);
System.out.println("Luas lingkaran: " + luas);
return luas;
}
@Override
float keliling(){
float keliling = (float) (2 * Math.PI * r);
System.out.println("Keliling Lingkaran: " + keliling);
return keliling;
}
}
Dalam rumus luas dan keliling lingkaran, kita bisa memanfaatkan konstanta
Math.PI sebagai nilai PI. Konstanta ini sudah ada di Java.
File:
PersegiPanjang.Javapackage inheritance;
public class PersegiPanjang extends BangunDatar {
float panjang;
float lebar;
@Override
float luas(){
float luas = panjang * lebar;
System.out.println("Luas Persegi Panjang:" + luas);
return luas;
}
@Override
float keliling(){
float kll = 2*panjang + 2*lebar;
System.out.println("Keliling Persegi Panjang: " + kll);
return kll;
}
}
File:
Segitiga.javapackage inheritance;
public class Segitiga extends BangunDatar {
float alas;
float tinggi;
@Override
float luas() {
float luas = 1/2 * (alas * tinggi);
System.out.println("Luas Segitiga: " + luas);
return luas;
}
}
Untuk class
Segitiga, kita hanya melakukan override terhadap method luas() saja. Karena untuk method keliling(), segitiga memiliki rumus yang berbeda-beda.
…atau mungkin bisa diturunkan lagi class segitiga ini menjadi:
SegitigaSiku, SegitigaSamaKaki, SegitigaSamaSisi, dsb.
Sekarang mari kita coba eksekusi class
Main lagi:
Tunggu dulu!
Tadi di awal katanya tidak efisien menulis berulang-ulang, lah ini?
Iya di awal kita menulis atribut dari
Enemy yang sama berulang-ulang. Berbeda dengan yang ini, kita memang menulis method yang sama. Tapi isi atau rumus di dalam method-nya berbeda-beda.
Ini nanti akan kita bahas dalam Polymorfisme (banyak bentuk).
Akhir Kata…
Inheritance adalah salah satu pilar penting dalam OOP yang harus dipahami. Karena kita akan sering menggunakannya dalam pembuatan program.
Selanjutnya silahkan perlajari tentang hak akses member (modifier).
Komentar
Posting Komentar