Class Inheritance
Inheritance merupakan suatu cara untuk menurunkan suatu class yang lebih umum
menjadi suatu class yang lebih spesifik.
Superclass dan Subclasses
Subclass merupakan class yang diturunkan dari suatu class superclass. Superclass
kadang-kadang disebut dengan parent class atau base class. sedangkan subclass biasa
disebut dengan child class atau extended class.
Pada subclass biasanya terdapat fungsi yang lebih atau class yang lebih detail
dibandingkan superclass-nya.
untuk membuat subclass digunakan keyword extends sehingga :
class namaClass extends namaSuperclass {
. . .
}
contoh :
pada circle.java
public class Circle { private double radius; Circle(double r) { //Constructor radius = r; } Circle() { //Constructor radius = 1.0; }
public double getRadius() { return radius;
}
public double findArea() {
return radius*radius*3.14159; }
pada cylinder.java yang merupakan subclass dari class Circle
public class Cylinder extends Circle { private double length;
public Cylinder() { //Constructor super();
length = 1.0; }
public Cylinder(double r,double l) { //Constructor super(r);
length = l; }
public double getLength() { return length;
}
public double findVolume() { return findArea() * length; }
}
pada Test.java
public class Test {
public static void main(String [] Args) {
//Create Cylinder object and display it's properties Cylinder myCylinder = new Cylinder(5.0,2.0);
System.out.println("The length is "+myCylinder.getLength()); System.out.println("The radius is "+myCylinder.getRadius()); System.out.println("The Cylinder Volume is
"+myCylinder.findVolume());
System.out.println("The area of Circle is "+myCylinder.findArea());
} }
Menggunakan Keyword “super”
Keyword super digunakan untuk melakukan reference ke superclass-nya. super dapat
digunakan untuk dua cara yaitu :
•
memanggil superclass constructor
•
memanggil superclass method
Untuk memanggil superclass constructor syntaks yang digunakan adalah :
super(parameters);
Contoh :
pada Cylinder.java
public class Cylinder extends Circle { private double length;
public Cylinder() { //Constructor super();
length = 1.0; }
public Cylinder(double r,double l) { //Constructor super(r);
length = l; }
... }
pemanggilan keyword super harus dilakukan awal didalam constructor
Untuk memanggil superclass method syntaks yang digunakan adalah :
super.method(parameters);
Contoh :
pada Cylinder.java findVolume dapat dibuat menjadi :
public class Cylinder extends Circle { ...
public double findVolume() {
return super.findArea() * length; }
... }
Penggunaan super untuk method boleh digunakan atau tidak digunakan apabila method
pada superclass tidak dioverride / dibuat ulang pada subclass. bila terjadi method
override keyword super harus digunakan.
contoh :
pada Cylinder.java
public class Cylinder extends Circle { private double length;
public Cylinder() { //Constructor super();
length = 1.0; }
public Cylinder(double r,double l) { //Constructor super(r);
length = l; }
public double getLength() { return length;
}
public double findArea() {
System.out.println(“Call Cylinder find Area”);
return 2*super.findArea()+2*getRadius()*3.14159*length; }
public double findVolume() { return findArea() * length; }
}
Class Object
Semua class yang dibuat di java merupakan turunan dari class java.lang.object. jika
keyword extends tidak diikuti dengan class superclass maka subclass tersebut merupakan
extends dari class java.lang.object
dua method penting dari object class adalah :
•
public boolean equals()
•
public String toString()
Method ini digunakan untuk membandingkan apakah dua object sama. dua buah object
sama hanya jika keduanya mempunyai nilai yang sama pada nilai datanya. Syntaks
penggunaan adalah sebagai berikut :
object1.equals(object2);
Method toString()
Method toString() digunakan untuk merepresentasikan nilai object dalam bentuk String.
secara default, toString() mengembalikan suatu String yang berisi nama class dari object,
tanda “@” dan nilai yang merepresentasikan object.
Contoh :
Cylinder myCylinder = new Cylinder(5.0,2.0);
System.out.println(myCylinder.toString());
akan menghasilkan seperti
Cylinder@15037e5. Method toString() harus dioverride jika
ingin menghasilkan suatu informasi yang berguna.
Contoh :
public String toString() {
return “Cylinder length = “ + length;
}
maka jika dilakukan pemanggilan toString() akan menghasilkan seperti :
Cylinder length = 5
protected, final dan abstract Modifier
protected Modifier
protected modifier dapat digunakan pada data/ attribute dan method. Protected data
maupun protected method pada suatu public class dapat diakses oleh class lain dengan
syarat :
•
menggunakan package yang sama
•
subclass-nya dengan package yang sama atau berlainan.
Contoh :
jika C1 mempunyai protected data bernama x di dalam package P1 maka :
1. jika class C2 pada package P2 merupakan subclass dari C1, maka x dapat diakses C2
karena x dapat diakses oleh semua subclass C1
2. jika class C3 pada package P1 mempunyai instance dari C1 bernama c1, maka x
dapat diakses c1 karena C3 dan C1 berada pada package yang sama
3. jika class C4 pada package P2 mempunyai instance dari C1 bernama c1, maka x tidak
dapat diakses karena C4 dan C1 berlainan package.
final Modifier
final modifier dapat digunakan pada class, data dan method. final modifier pada class
digunakan untuk membuat class yang tidak dapat diperluas lagi (tidak dapat dibuat
subclass-nya). sedangkan penggunaan pada method biasanya untuk membuat method
yang tidak dapat dioverride pada subclass-nya.
abstract Modifier
Penggunaan abstract modifier yaitu pada class atau method. Untuk penggunaan pada
class biasanya disebut dengan abstract class yaitu class yang sifatnya tidak dapat
mempunyai instance yang spesifik. sedangkan penggunaan pada method biasanya disebut
dengan abstract method yaitu method yang tidak mempunyai implementasi / kosong.
Implementasi baru dilakukan pada subclass dari class tersebut.
contoh :
pada GeometricObject
public abstract class GeometricObject { //abstract class private String color;
private double weight;
public GeometricObject(String c, double w) { color = c; weight = w; } public GeometricObject() { color = “white”; weight = 1.0; }
public String getColor() { return color;
}
public double getWeight() { return weight;
}
public abstract double findArea(); //abstract method public abstract double findCircumference(); //abstract method
}
pada contoh diatas GeometricObject merupakan abstract class dan mempunyai dua buah
method abstract yaitu findArea() dan findCircumference(). kedua method ini akan
diimplementasikan pada subclass-nya.
public class Circle extends GeometriObject { private double radius;
public Circle(double r, double w, String c) { super(c,w); radius = r; } public Circle() { this(1.0,1.0,”white”); } public Circle(double r) { super(“white”,1.0); radius = r; }
public double getRadius() { return radius;
}
public double findArea() {
return radius*radius*Math.PI; //implementasi findArea() }
public double findCircumference() {
return 2*radius*Math.PI; //implementasi findCircumference() }
public String toString() {
return “Circle radius = “+radius; }
}
Casting Objects
Casting object / konversi object digunakan untuk melakukan konversi dari suatu object
ke object lain dalam satu susunan hirarki yang sama.
untuk mengkonversi dapat dilakukan dengan cara
Circle myCircle = (Circle)myCylinder;
Cylinder myCylinder = (Cylinder)myCircle;
mengkonversi superclass myCircle menjadi subclass-nya myCylinder.
pada saat mengkonversi object ke object lain biasakan gunakan operator instanceof
untuk melakukan pemeriksaan apakah object tersebut benar-benar dalam satu susunan
hirarki class yang sama.
contoh :
Circle myCircle = new Circle(); ....
if(myCircle instanceof Cylinder) {
//lakukan konversi jika myCircle instance dari Cylinder Cylinder myCylinder = (Cylinder) myCircle;
.... }
....
casting object kadang-kadang diperlukan apabila kita mempunyai array dari object yang
berisi bermacam-macam object dan kita ingin menjalankan method yang berlainan dari
object-object tersebut. Perhatikan contoh berikut :
pada TestCasting.java
public class TestCasting {
public static void main (String [] args) {
//GeometricObject untuk menampung kedua jenis object GeometricObject geoObject[] = new GeometricObject[2]; geoObject[0] = new Circle(5.0,2.0,”white”);
geoObject[1] = new Cylinder(5.0,2.0,”black”); for(int i=0;i<2;i++) {
if (geoObject[i] instanceof Cylinder) { //check apakah object Cylinder ?
System.out.println(“Object is Cylinder”); System.out.println(“Cylinder volume = “+ ((Cylinder)geoObject[i]).findVolume())); }
//Check apakah object Circle ?
else if (geoObject[i] instanceof Cirlce) { System.out.println(“Object is Circle”); System.out.println(“Cylinder area = “+ ((Circle)geoObject[i]).findArea())); } } } }
pada Cylinder.java
class Cylinder extends Circle { private double length;
public Cylinder() { super();
length = 1.0; }
public Cylinder(double r,double w,String c, double l) { super(r,w,c);
length=l; }
public Cylinder(double r,double l) { this(r,1.0,”white”,l)
}
public double getLength() { return length;
}
public double findVolume() { return findArea()*length; }
}
hal ini dapat dilakukan karena Cylinder merupakan subclass dari Circle dan Circle
merupakan subclass dari GeometricObject
interfaces
interfaces digunakan untuk melakukan penurunan dari beberapa class atau multiple
inheritance. jika kita menggunakan keywords extends penurunan hanya dilakukan dari
sebuah parent class. dengan interface kita dapat menurunkan beberapa class menjadi
sebuah subclass.
pendeklarasian suatu interfaces class adalah sebagai berikut :
modifier interfaces InterfaceName { //Constant declarations;
//method signatures; }
sedangkan untuk menggunakan interfaces pada suatu class digunakan keyword
Implements.
modifier class Classname implements interface1,interface2,...{ //...
}
atau dengan penggabungan dengan keyword extends
modifier class Classname extends anyClass implements interface1,...{ //...
}
Contoh :
pada CompareObject.java
public interface CompareObject { public static final int LESS = -1; public static final int EQUAL = 0; public static final int GREATER = 1;
public int compare(CompareObject otherObject); }
pada Sort.java class Sort {
public static void sort(CompareObject[] o) { CompareObject currentMax; int currentMaxIndex; for(int i=o.length-1;i>=1;i--) { currentMax = o[i]; currentMaxIndex = i; for(int j=i-1;j>=0;j--) { if(currentMax.compare(o[j])==-1) { currentMax = o[j]; currentMaxIndex =j; } } if(currentMaxIndex!=i) { o[currentMaxIndex]=o[i]; o[i]=currentMax; } } } }
pada TestSort.java public class TestSort {
public static void main(String[] args) { CompareCircle[] c = new CompareCircle[10];
for(int i=0;i<c.length;i++)
c[i]= new CompareCircle(100*Math.random(),1.0,”white”); Sort.sort(c);
System.out.println(“Sorted Circles”); printObject(c);
CompareCylinder[] cyl = new CompareCylinder[10]; for(int i=0;i<cyl.length;i++)
cyl[i]= new CompareCylinder(100*Math.random(),1.0,”white”, 100*Math.random()); Sort.sort(cyl); System.out.println(“Sorted Cylinders”); printObject(cyl); }
public static void printObject(Object[] c) { for(int i=0;i<c.length;i++)
System.out.println(“”+c[i]); }
}
pada CompareCircle.java
class CompareCircle extends Circle implements CompareObject {
public CompareCircle(double r,double w, String c) { super(r,w,c);
}
public int compare(CompareObject otherObject) { Circle c = (Circle) otherObject;
if(getRadius() < c.getRadius()) return LESS;
else if(getRadius() == c.getRadius()) return EQUAL;
else return GREATER; }
pada CompareCylinder.java
class CompareCylinder extends Cylinder implements CompareObject {
public CompareCylinder(double r,double w, String c, double l) { super(r,w,c,l);
}
public int compare(CompareObject otherObject) { Cylinder c = (Cylinder) otherObject;
if(getVolume() < c.getVolume()) return LESS;
else if(getVolume() == c.getVolume()) return EQUAL;
else return GREATER; }
public String toString() {
return “Cylinder volume = “+findVolume()); }
}
Perbedaan interfaces dengan abstract adalah :
1. interfaces class digunakan untuk multiple inheritance pada java, sedangkan abstract class digunakan untuk single inheritance.
2. interfaces class hanya boleh berisi data constant dan method
signature saja. sedangkan pada abstract class boleh berisi tipe data
apa saja dan method dapat berisi atau method signature saja.
3. interface tidak dapat menggunakan modifier abstract pada class-nya. sedangkan abstract class menggunakan abstract modifier pada awal
