Tutorial Inheritance
1. Terminologi Inheritance
Inheritance adalah fakta bahwa satu class dapat diturunkan sebagian atau seluruh
strukturnya dari class lainnya. Class yang melakukan penurunan disebut subclass atau
childclass dari class yang menurunkan yang disebut superclass atau parent class. Jika B
merupakan subclass dari A, maka A disebut superclass atau base class dan B di sebut
subclass atau class turunan. Perhatikan gambar berikut :
Untuk membuat class bernama B sebagai subclass dari base class A, caranya :
class B extends A {
.
. // tambahan atau modifikasi,
. // turunan dari class A
.
}
2. Aksesibilitas
Dalam subclass kita dapat megakses method public superclass dan protected serta fields , tapi bukan
method private dari superclass. Jika subclass dan superclass dalam package yang sama, kita juga
dapat mengakses method dan field default superclass. Perhatikan contoh berikut :
public class P {
public void publicMethod() { }
protected void protectedMethod() { }
void defaultMethod() { }
}
class C extends P {
public void testMethod() { publicMethod();
protectedMethod(); defaultMethod(); }
3. Method Overriding
a) Saat kita meng-extends suatu class, kita dapat merubah behavior dari method dalam
parent class maka kita melakukan method overriding.
b) Hal ini terjadi saat kita menulis method dalam yang mempunyai nama atau pengenal
yang sama dengan method pada parent class.
c) Jika hanya namanya yang sama tetapi daftar argument parameternya tidak maka kita
melakukan suatu method overloading.
4. Keyword extends
Jika kita akan meng-exend / meperluas / menurunkan suatu class gunakan keyword extends,
misal terdapat class Parent.java dan akan membuat turunanya yang di beri nama Child.java,
perhatikan contoh berikut :
public class Parent { }
public class Child extends Parent { }
5. Class Turunan
Untuk memahami atau membuat class turunan perhatikan contoh berikut :
class Animal {public Animal(String aType) { type = aType;
}
public String toString() { return "This is a " + type; }
private String type; }
class Dog extends Animal { public Dog(String name){ super(name);
}
private String breed; }
6. Keyword super, sebagai instan atau superclass clangsung dari object saat ini
1. Kita dapat secara explicit memanggil konstruktor parent class dari konstruktor
subclass dengan menggunakan keyword super.
2. 'super' harus menjadi statement pertama dalam konstruktor, perhatikan contoh berikut
class Parent {public Parent(){
} }
public class Child extends Parent { public Child () {
super(); }
7. Konstruktor class turunan : Pemanggilan konctruktor base class
Perhatikan contoh berikut,
class Animal {public Animal(String aType) { type = new String(aType); }
public String toString() { return "This is a " + type; }
private String type; }
class Dog extends Animal { public Dog(String aName) { super("Dog");
name = aName; breed = "Unknown"; }
public Dog(String aName, String aBreed) { super("Dog");
name = aName; breed = aBreed; }
private String name; private String breed; }
8. Overriding method base class
Kita dapatmelakukan overriding method pada base class seperti contoh berikut
class Animal {public Animal(String aType) { type = new String(aType); }
public String toString() { return "This is a " + type; }
private String type; }
class Dog extends Animal { public Dog(String aName) { super("Dog");
name = aName; breed = "Unknown"; }
public Dog(String aName, String aBreed) { super("Dog");
name = aName; breed = aBreed; }
public String toString() {
return "It's " + name + " the " + breed; }
private String name; private String breed; }
9. Type Casting
Type casting adalah suatu konversi tipe atau object ke tipe atau object lainnya,
a) Dengan objects, kita dapat melaukan cast pada suatu instance subclass ke parent
class.
b) Casting pada suatu bject ke parent class di sebut upcasting misalnya,
Child child = new Child ();Parent parent = child;
Untuk melakukan upcasting yang kita perlukan adalah melakukan assignment pada object
yang di acu ke suatu referensi variabel dari tipe parent-nya. Variabel referensi Parent tidak
dapat diakses anggota yang hanya tersedia di child class. Karena referensi parent suatu object
bertipe child, kita dapat melakukan casting kembali ke child, ini dinamakan downcasting,
karena kita melakukan cast dari object ke class secara menurun dari hirarki inheritance.
Child child2 = (Child) parent;
10. Inheritance, constructor dan argument
Untuk memahami hal di atas perhatikan contoh berikut,
class A {A(int i) {
System.out.println("A constructor"); } } class B extends A { B(int i) { super(i); System.out.println("B constructor"); } } class C extends B { C() { super(11); System.out.println("C constructor"); } }
public class MainClass {
public static void main(String[] args) { C x = new C();
} }
akan menghasilkan output
A constructorB constructor C constructor
11. Inheritance dan Upcasting
Perhatikan contoh berikut untuk memahami persoalan inheritance dan upcasting
class A {public void play() { }
} }
class B extends A { }
public class MainClass {
public static void main(String[] args) { B flute = new B();
A.tune(flute); // Upcasting }
}
12. Overloading nama method base class dalam class turunan dalam versi base class
yang tidak tersembunyi
Perhatikan contoh berikut
class A {char doh(char c) {
System.out.println("doh(char)"); return 'd';
}
float doh(float f) {
System.out.println("doh(float)"); return 1.0f; } } class B {} class C extends A { void doh(B m) { System.out.println("doh(B)"); } }
public class MainClass {
public static void main(String[] args) { C b = new C(); b.doh(1); b.doh('x'); b.doh(1.0f); b.doh(new B()); } }
Output program sebagai berikut
doh(float)doh(char) doh(float) doh(B)
13. Membersihkan Inheritance
Membersihkan inheritance dapat di pahami dari contoh berikut
class Characteristic {private String s;
Characteristic(String s) { this.s = s;
System.out.println("Creating Characteristic " + s); }
protected void dispose() {
System.out.println("finalizing Characteristic " + s); } } class Description { private String s; Description(String s) { this.s = s;
System.out.println("Creating Description " + s); }
protected void dispose() {
System.out.println("finalizing Description " + s); }
}
class LivingCreature {
private Characteristic p = new Characteristic("is alive");
private Description t = new Description("Basic Living Creature"); LivingCreature() {
System.out.println("LivingCreature()"); }
protected void dispose() {
System.out.println("LivingCreature dispose"); t.dispose();
p.dispose(); }
}
class Animal extends LivingCreature {
private Characteristic p = new Characteristic("has heart"); private Description t = new Description("Animal not Vegetable"); Animal() {
System.out.println("Animal()"); }
protected void dispose() {
System.out.println("Animal dispose"); t.dispose();
p.dispose(); super.dispose(); }
class Amphibian extends Animal {
private Characteristic p = new Characteristic("can live in water"); private Description t = new Description("Both water and land"); Amphibian() {
System.out.println("Amphibian()"); }
protected void dispose() {
System.out.println("Amphibian dispose"); t.dispose();
p.dispose(); super.dispose(); }
}
class Frog extends Amphibian {
private Characteristic p = new Characteristic("Croaks"); private Description t = new Description("Eats Bugs"); public Frog() {
System.out.println("Frog()"); }
protected void dispose() {
System.out.println("Frog dispose"); t.dispose();
p.dispose(); super.dispose(); }
}
public class MainClass {
public static void main(String[] args) { Frog frog = new Frog();
System.out.println("Bye!"); frog.dispose();
} }
Output program adalah sebagai berikut :
Creating Characteristic is alive
Creating Description Basic Living Creature LivingCreature()
Creating Characteristic has heart
Creating Description Animal not Vegetable Animal()
Creating Characteristic can live in water Creating Description Both water and land Amphibian()
Creating Characteristic Croaks Creating Description Eats Bugs Frog()
Bye!
Frog dispose
finalizing Description Eats Bugs finalizing Characteristic Croaks Amphibian dispose
finalizing Description Both water and land finalizing Characteristic can live in water Animal dispose
finalizing Description Animal not Vegetable finalizing Characteristic has heart
LivingCreature dispose
finalizing Description Basic Living Creature finalizing Characteristic is alive
14. Multilevel Hirarki
Perhatikan contoh membuat multilevel hirarki class
class Box {private double width; private double height; private double depth;
Box(Box ob) { // pass object to constructor width = ob.width;
height = ob.height; depth = ob.depth; }
Box(double w, double h, double d) { width = w;
height = h; depth = d; }
Box() {
width = -1; // use -1 to indicate height = -1; // an uninitialized depth = -1; // box
}
Box(double len) {
width = height = depth = len; }
double volume() {
return width * height * depth; }
}
class BoxWeight extends Box { double weight; // weight of box
BoxWeight(BoxWeight ob) { // pass object to constructor super(ob);
weight = ob.weight; }
BoxWeight(double w, double h, double d, double m) { super(w, h, d); // call superclass constructor weight = m;
}
weight = -1; }
BoxWeight(double len, double m) { super(len);
weight = m; }
}
class Shipment extends BoxWeight { double cost;
Shipment(Shipment ob) { // pass object to constructor super(ob);
cost = ob.cost; }
Shipment(double w, double h, double d, double m, double c) { super(w, h, d, m); // call superclass constructor
cost = c; } Shipment() { super(); cost = -1; }
Shipment(double len, double m, double c) { super(len, m);
cost = c; }
}
class DemoShipment {
public static void main(String args[]) {
Shipment shipment1 = new Shipment(10, 20, 15, 10, 3.41); Shipment shipment2 = new Shipment(2, 3, 4, 0.76, 1.28); double vol;
vol = shipment1.volume();
System.out.println("Volume of shipment1 is " + vol);
System.out.println("Weight of shipment1 is " + shipment1.weight); System.out.println("Shipping cost: $" + shipment1.cost);
System.out.println(); vol = shipment2.volume();
System.out.println("Volume of shipment2 is " + vol);
System.out.println("Weight of shipment2 is " + shipment2.weight); System.out.println("Shipping cost: $" + shipment2.cost);
} }
15. Demonstrasi saat konstruktor di panggil dalam multilevel hirarki
Perhatikan contoh demonstrasinya di bawah ini
class A {A() {
System.out.println("Inside A's constructor."); }
class B extends A { B() {
System.out.println("Inside B's constructor."); }
}
class C extends B { C() {
System.out.println("Inside C's constructor."); }
}
class CallingCons {
public static void main(String args[]) { C c = new C();
} }
