Nama : Chaterine Nurhayati (200300007)

Makalah Pemograman Berorientasi Objek

(Inheritence) Pewarisan pada Java

Catatan Tambahan untuk dijelaskan di makalah :

Fungsi Extends
Tambahkan Penjelasan mengenai Objek dan Class

Rumusan Masalah :
1. Apa pengertian dari Pewarisan (Inheritence) pada Java ?
2. Kenapa kita harus menggunakan Pewarisan (Inheritence) pada Java ?
3. Apa manfaat menggunakan Pewarisan (Inheritence) ?
4. Bagaimana Konsep dari Pewarisan (Inheritence) pada Java
5. Studi Kasus Pewarisan Inheritence!

Pengertian. Pada bahasa pemrograman Java, suatu kelas bisa diwariskan/diturunkan ke

kelas lain, yang secara otomatis ikut mewariskan method maupun atribut dari kelas tersebut.
Kelas yang mewarisi method dan atribut dari suatu kelas lain biasa disebut
dengan subclass atau extended class. Sedangkan kelas yang mewariskan disebut
dengan superclass.
Konsep Pewarisan (Inheritence) Melalui fitur ini, kita dapat membuat class baru yang
memiliki karakteristik mirip dengan class yang lainnya. Dikatakan mirip karena class yang
baru ini nantinya dapat memiliki atribut dan method yang sama dengan class yang lain.
Selain itu, pada class yang baru ini dapat kita tambahkan atribut dan method khusus yang
tidak dimiliki oleh class yang lain.
Ide dari inheritance atau pewarisan sendiri sangat simpel, apabila kita ingin membuat kelas
baru yang mirip dengan kelas yang sudah ada, dan mempunyai method dan atribut yang
sama. Kenapa kita harus membuat dari awal, kalau kita bisa dengan mudah mewariskan
atribut dan method dari kelas asal.
Pada platform Java sendiri, semua kelas pada dasarnya mewarisi atribut dan method dari
suatu super class, yang bernama Object. Kelas Object bisa dibilang adalah ibu dari segala
macam kelas yang ada di Java.
Pada subclass ada beberapa hal yang bisa dilakukan, yatu sebagai berikut :
 Atribut yang diwariskan bisa langsung digunakan, seperti atribut-atribut lain
 Nama variabel/konstanta dari subclass bisa disamakan dengan nama
variabel/konstanta pada superclass. Tetapi hal ini tidak disarankan karena kita
bisa langsung menggunakan variabel/konstanta superclass pada subclass tanpa
harus membuat baru.
 Kalian bisa mendeklarasikan variabel/konstanta baru pada subclass, yang belum
ada di superclass.
 Method yang diwariskan bisa langsung digunakan.
 Kalian bisa membuat method baru pada subclass yang mempunyai nama dan
atribut yang sama dengan method pada superclass. Hal ini berarti kalian telah
melakukan override (menimpa) pada method tersebut.
  Kalian bisa membuat static method baru pada subclass yang mempunyai nama
dan atribut yang sama dengan method pada superclass. Hal ini berarti kalian
telah melakukan hiding (menyembunyikan) pada method tersebut.
 Kalian bisa mendeklarasikan method baru pada subclass yang belum ada di
superclass.
 Kalian bisa membuat konstruktor pada subclass yang memanggil konstruktor
pada superclass, baik secara implisit maupun menggunakan keyword super

Apa Manfaat dari Pewarisan (Inheritence) :

konsep tentang pewarisan yang merupakan suatu proses dimana suatu class diturunkan dari
class lainnya sehingga ia mendapatkkan ciri atau sifat dari class tersebut.Dari hirarki di atas
dapat dilihat bahwa, semakin ke bawah, class akan semakin bersifat spesifik. Misalnya,
sebuah Class mamalia memiliki seluruh sifat yang dimiliki oleh binatang, demikian halnya
juga anjing, kucing dan monyet memiliki seluruh sifat yang diturunkan dari class mamalia.

Dengan konsep ini, karakteristik yang dimiliki oleh class binatang cukup didefinisikan dalam
class binatang saja. Class mamalia tidak perlu mendefinisikan ulang apa yang telah dimiliki
oleh class binatang, karena sebagai class turunannya, ia akan mendapatkan karakteristik dari
class binatang secara otomatis. Demikian juga dengan class anjing, kucing dan monyet,
hanya perlu mendefinisikan karakteristik yang spesifik dimiliki oleh class-nya masing-
masing. Dengan memanfaatkan konsep pewarisan ini dalam pemrograman, maka hanya perlu
mendefinisikan karakteristik yang lebih umum akan didapatkan dari class darimana ia
diturunkan.
Manfaat penggunaan konsep pewarisan antara lain:
 Kita dapat menggunakan kembali kelas-kelas yang kita buat (sebagai superkelas) dan
membuat kelas-kelas baru berdasar superkelas tersebut dengan karakteristik yang
lebih khusus dari behaviour umum yang dimiliki superkelas.

 Kita dapat membuat superkelas yang hanya mendefinisikan behaviour namun tidak
memberi implementasi dari metode-metode yang ada. Hal ini berguna jika kita ingin
membuat semacam template kelas. Kelas semacam ini disebut kelas abstrak, karena
behaviournya masih abstrak dan belum diimplementasikan. Subkelas-subkelas dari
kelas semacam ini, yang disebut kelas konkret, mengimplementasikan behaviour
abstrak tersebut sesuai dengan kebutuhan masing-masing.

Contoh Pewarisan (Inheritence) :

Kelas Animal.java
Kelas Animal merupakan superclass dari program yang nantinya kelas ini bisa diwariskan ke
kelas lainnya.

1public class Animal {

2
3 public String nama;
4 public int umur;
5
 6
public void makan()
7
{
8 System.out.println("Sedang Makan");
9 }
10
11 public void mengeluarkanSuara()
12 {
13 System.out.println("Sedang Bersuara");
14 }
15}

Kelas Kucing.java
Kelas kucing merupakan subclass dari kelas Animal, karena itu kelas ini akan mewarisi
atribut dari kelas Animal.
1public class Kucing extends Animal{
2
3 @Override
4 public void mengeluarkanSuara()
5 {
6 System.out.println("Meong");
7 }
8}

Kelas AnimalTest.java
Kelas ini yang berfungsi sebagai driver untuk menjalankan program, atau bisa disebut juga
dengan Main Class. Pada program ini didemokan bahwa walaupun memanggil method yang
sama mengeluarkanSuara() namun ternyata program menghasilkan output yang berbeda

1
2public class AnimalTest
3{
4
5 public static void main(String[] args)
{
6
Animal animal1 = new Animal();
7
animal1.nama = "Binatang Abstrak";
8
animal1.mengeluarkanSuara();
9
10 Kucing kucing1 = new Kucing();
11 kucing1.nama = "Kitten";
12 kucing1.mengeluarkanSuara();
13
14 Animal animal2 = new Kucing();
15 animal2.nama = "Mew";
16
17 }
18
19}

Kenapa harus menggunakan Pewarisan (Inhertence) ?

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.java
class Zombie {
String name;
int hp;
int attackPoin;

void attack(){
// ...
}

void walk(){
//...
}
}

File: Pocong.java
class Pocong {
String name;
int hp;
int attackPoin;

void attack(){
// ...
}

void jump(){
//...
}
}

File: Burung.java
class 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.java
class 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.java
class Zombie extends Enemy {
void walk(){
System.out.println("Zombie jalan-jalan");
}
}

File: Pocong.java
class Pocong extends Enemy {
void jump(){
System.out.println("loncat-loncat!");
}
}

File: Burung.java
class 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 dalam Netbeans :

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.java
package 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.java
package inheritance;

public class Persegi extends BangunDatar {

float sisi;
}

File: inheritance/Lingkaran.java
package inheritance;

public class Lingkaran extends BangunDatar{

// jari-jari lingkaran
float r;

File: inheritance/PersegiPanjang.java
package inheritance;

public class PersegiPanjang extends BangunDatar {

float panjang;
float lebar;
}

File: inheritance/Segitiga.java
package inheritance;

public class Segitiga extends BangunDatar {

float alas;
 float tinggi;

File: inheritance/Main.java
package 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.java
class 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.java
package 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.Java
package 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.java
package 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).