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 constructor B constructor C constructor
11. Inheritance dan Upcasting Perhatikan contoh berikut untuk memahami persoalan inheritance dan upcasting class A { public void play() { } static void tune(A i) { i.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; } BoxWeight() { super();
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(); } }
