Inheritance
adalah konsep pemrograman berorientasi object yang memungkinkan membuat
hubungan di mana ada class yang
mewarisi semua attribute dan method dari class lain. Class baru yang
lebih spesifik disebut subclass atau class turunan, sedangkan class yang
diturunkan disebut superclass. Untuk menguji suatu kasus disebut inheritance
atau tidak, dapat menggunakan kata kunci “IS A”. (Namun, pengujian ini hanya
berlaku searah (dari subclass ke superclass))
Contoh
:
Mamalia:
(berdaun teling, beranak, menyusui). Contohnya: Anjing, kucing, marmut
Pengujiaannya:
marmut IS A mamalia.
Kendaraan
(mempunyai kemudi) contohnya: mobil, motor, pesawat terbang
Pengujiannya: motor IS A kendaraan
Praktek
1 (Extends)
Untuk membuat class
turunan, digunakan keyword extends.
Strukturnya seperti dibawah ini:
public
class [nama SubClass] extends [nama SuperClass]{}
Contoh: public class Kamus
extends Buku{}
Saat ini, kita akan mencoba
membuat program yang menerapkan prinsip inheritance
1. Program yang menjadi subClass
dengan menggunakan kata kunci extends.
class B extends A {
int z;
void getJumlah(){
System.out.println(“jumlah:”+ (x+y+z));
}
}
3. Buatlah class testernya
class InheritanceTest{
public static void main(String [] args)
{
A ortu = new A();
B anak = new B();
System.out.println(“superclass”);
ortu.x=10;
ortu.y=20;
ortu.getNilai();
System.out.println(“sub Class”);
anak.x=5;
anak.y=4;
anak.getNilai();
anak.z=50;
anak.getJumlah();
}
}
Dari kode
program diatas, kita dapat melihat bahwa bahwa method getNilai() muncul pada
class B. Padahal kita tidak melihat adanya method getNilai() di class B. Hal
ini membuktikan bahwa terdapat proses inheritance dari class A ke class B.
Hubungan ini bersifat generalization
dimana ClassChild mempunyai semua sifat dari ClassParent. Oleh
karena itu, pada ClassChild cukup ditambahkan bagian yang memang merupakan
spesifik milik classChild. Dari program sederhana ini pula, kita mendapatkan
keuntungan dari inheritance. Kita tidak perlu menambah atribut x dan y ataupun
method getHasil() pada class B. Kita hanya cukup menggunakan apa yang sudah ada
di class A , atau dengan kata lain,kita telah menerapkan prinsip “reuse of code”. Perlu diketahui: Java
tidak mengizinkan pewarisan berganda. Misalkan class aku diturunkan dari class
ayah dan class ibu. Pewarisan berganda ini bisa dilakukan di C++.
Praktek 2 (Hak Akses)
Pada
program diatas, setiap atribut yang digunakan bertipe default. Dengan kata
lain, atribut pada program diatas tidak terenkapsulasi sehingga dengan mudah
kita dapat mengisi nilai x dan y tanpa mengakses method apapun dari luar class
A maupun B. Pada pertemuan sebelumnya, kita diajarkan untuk melakukan
enkapsulasi dengan menggunakan hak akses yang bertipe private. Sekarang, ubahlah program diatas menjadi seperti dibawah
ini:
class B extends A {
private int z;
public void getJumlah(){
System.out.println(“jumlah:”+ (x+y+z));
}
public void setZ(int z){
this.z = z;
}
}
class A {
private int x;
private int y;
public void setX(int x){
this.x = x;
}
public void setY(int
y){
this.y = y;
}
public void getNilai(){
System.out.println(“nilai
x:”+ x +” nilai y:” + y);
}
class InheritanceTest{
public static void
main(String [] args)
{
A ortu = new A();
B anak = new B();
System.out.println(“superclass”);
ortu.setX(10);
ortu.setY(20);
ortu.getNilai();
System.out.println(“sub
Class”);
anak.setX(5);
anak.setY(4);
anak.getNilai();
anak.setz(50);
anak.getJumlah();
}
}
Compile program!
Seperti yang telah kita
bahas kemarin, terdapat 5 jenis hak akses. Error tersebut terjadi karena kita
mendefinisikan atribut x dan y sebagai private. Ingat, private hanya bisa
diakses di classnya. Tetapi tidak di class lain, bahkan di class turunannya
sendiri. Coba ganti hak akses dari atribut2 A dan B menjadi protected. Kemudian
compile program yang Anda buat tadi. Catatan:
Agar tetap menjaga konsistensi enkapsulasi, maka akses terhadap
super class dari sub class pada bagian attribute-nya tidak terlepas dari access
control protected. Hal ini digunakan untuk menjaga agar attribute hanya dapat
diakses oleh class yang menjadi turunannya saja.
Praktek 3
1. Sebuah class lagi yang mewarisi class B, misalkan class C:
class C extends B {
protected int w;
public void setW( int
w){
this.w = w;
}
public void getW(){
System.out.println(“nilai
w :”+ w);
}
}
2. Ubah class InheritanceTest menjadi seperti dibawah ini:
class InheritanceTest{
public static void
main(String [] args)
{
A ortu = new A();
B anak = new B();
C cucu = new C();
System.out.println(“superclass”);
ortu.setX(10);
ortu.setY(20);
ortu.getNilai();
System.out.println(“sub
Class”);
anak.setX(5);
anak.setY(4);
anak.getNilai();
anak.setz(50);
anak.getJumlah();
System.out.println(“sub
Class2”);
cucu.setX(5);
cucu.setY(4);
cucu.getNilai();
cucu.setz(50);
cucu.getJumlah();
cucu.setW();
cucu.getW();
}
}
Praktek 4 (Super)
Jika keyword this digunakan untuk membedakan variabel local
dengan atribut suatu objek, maka untuk membedakan atribut superclass dengan
atribut subclass digunakan keyword super.
Contoh program
class Bentuk {
protected int p,l;
}
class Persegi extends
Bentuk {
protected int p,l;
public void
setSuperP(int p){
super.p = p;
}
public void
setSuperL(int l){
super.l = l;
}
public void setP(int
p){
this.p = p;
}
public void setL(int
l){
this.l = l;
}
public void getLuas(){
System.out.println("Luas
super:"+(super.l*super.p));
System.out.println("Luas:"+
(this.l*this.p));
}
}
class PersegiTest {
public static void
main(String[] args){
Persegi kotak=new
Persegi();
kotak.setSuperP(5);
kotak.setSuperL(10);
kotak.setP(3);
kotak.setL(13);
kotak.getLuas();
}
}
Catatan
:
Keyword
super digunakan untuk merefer ke superclass dari class yang bersangkutan. Terlihat di output bahwa luas super dengan
luas subclassnya berbeda.
Praktek 5 (super constructor)
Untuk pengaksesan constructor method dari super class,
digunakan bentuk sebagai berikut :
super (argumen1,
argumen2, …) ;
contoh program
class A{
A(){
System.out.println("konstruktor
A dieksekusi");
}
}
class B extends A{
B(){
System.out.println("konstruktor
B dieksekusi");
}
}
class C extends B{
C(){
System.out.println("konstruktor
C dieksekusi");
}
}
class ConstructorTest{
public static void
main(String[] args){
C coba=new C();
}
}
Compile ulang
class A, B dan C serta ConstructorTest.
Dari percobaan
diatas, ada beberapa hal yang perlu diingat dalam penggunaan super constructor,
yaitu :
1. Sebenarnya, java menambahkan pemanggilan super secara
default ketika kita tidak memanggil
constructor super di subclassnya tetapi, jika pada superclass tidak terdapat constrructor default atau
constructor yang tidak menggunakan parameter, maka
kita harus melakukan pemanggilan salahasatu constructor pada subclassnya, sesuai dengan constructor yang ada pada
superclassnya.
2. Pemanggilan super() harus terletak pada pernyataan baris
pertama dalam sebuah constructor.
3. Pemanggilan super() hanya bisa dilakukan pada constructor.
4. Hal ini
mengimplikasikan bahwa this() dan super() yang dipanggil tidak dapat dinyatakan dalam constructor yang sama.
Praktek 6 (overriding method)
Buatlah class
class A{
public void show(){
System.out.println("Method
show milik class A dipanggil");
}
}
class B extends A{
public void show(){
System.out.println("Method
show milik class B dipanggil");
}
}
class OverridingTest{
public static void
main(String[] args){
B coba = new B();
coba.show();
}
}
Compile ketiga
program diatas.
method mana yang
dipanggil oleh class B?
Dalam program
tersebut terdapat 2 method dengan nama yang sama walaupun dalam class yang
berbeda. Contoh program tersebut merupakan aplikasi dari Overriding. Ketika
dalam suatu subclass, kita mendefinisikan method yang sama dengan
superclassnya, maka, method dalam subclass tersebut dikatakan meng-override superclassnya.
Sehingga, method yang dipanggil bukan lagi method milik superclass, tetapi
miliknya sendiri (subclass)
Lalu, bagaimana
cara memanggil method superclassnya?
Ubah code class
B menjadi seperti berikut:
class B extends A {
public void show(){
super.show();
System.out.println("Method
show milik class B dipanggil");
}
}
Praktek 7 (Final)
Contoh program
class
class Lingkaran{
final public double PI
= 3.14;
protected double r;
public void setR(
double r){
this.r=r;
}
public void getLuas(){
System.out.println("Luas
Lingkaran="+(this.PI*r*r));
}
}
class LingkaranTest{
public static void
main(String[] args){
Lingkaran bunder=new
Lingkaran();
bunder.PI=4;
bunder.setR(10);
bunder.getLuas();
}
}
Compile
kedua program.
Final
keyword, adalah penentu akses yang dapat diterapkan pada instance variable atau
pada method, di mana akan menjadikan : Suatu instance variable, akan dibuat
menjadi konstanta. Suatu method, akan dibuat menjadi tidak dapat di-override
pada sublassnya.
Jadi,
final keyword dalam hal ini dapat digunakan untuk memberikan batasan lebih (selain akses control) terhadap
pengaksesan attribute maupun method suatu class terhadap class turunannya.
