Polymorphism

23.57 in kuliah, PBO

Polymorphism adalah Kemampuan sebuah variabel reference untuk merubah behavior sesuai dengan apa yang dipunyai object.
Polymorphism membuat objek-objek yang berasal dari subclass yang berbeda, diperlakukan sebagai objek-objek dari satu superclass. Hal ini terjadi ketika memilih method yang sesuai untuk diimplementasikan ke objek tertentu berdasarkan pada subclass yang memiliki method bersangkutan.
Untuk menjelaskan polymorphism, mari kita bahas sebuah contoh.
Pada contoh sebelumnya, kita diberikan parent class yaitu Person dan subclassnya adalah Student, sekarang kita tambahkan subclass lainnya dari Person yaitu Employee
Berikut adalah hirarki class nya. 

Dalam Java, kita dapat membuat referensi dari suatu superclass ke object dari subclassnya. Sebagai contoh,
public static main( String[] args ) {
 
    Person  ref;
    Student studentObject = new Student();
    Employee employeeObject = new Employee();

    ref = studentObject; //titik referensi Person kepada                         // sebuah object Student
}

misalnya, kita memiliki sebuah method getName dalam superclass Person. Dan kita meng-override method ini di kedua subclass yaitu Student dan Employee
public class Student {
    public String getName(){
        System.out.println(“Student Name:” + name);
        return name;
    }
}

public class Employee {
    public String getName(){
        System.out.println(“Employee Name:” + name);
        return name;
    }
} 

Kembali ke method utama kita, ketika kita mencoba memanggil method getName dari referensi Person ref, method getName dari object Student akan dipanggil. Sekarang, jika kita memberi ref kepada object Employee, maka method getName juga akan dipanggil
public static main( String[] args ) {
    Person  ref;
    Student studentObject = new Student();
    Employee employeeObject = new Employee();

    ref = studentObject; //titik referensi Person kepada object Student

    //getName dari class Student dipanggil
    String temp=ref.getName();
    System.out.println( temp );

    ref = employeeObject; //titik referensi Person kepada  object Employee
   
    //getName dari class Employee dipanggil 
    String temp = ref.getName();
    System.out.println( temp );
} 
Contoh lain yang menggambarkan polymorphism adalah ketika kita mencoba untuk passing reference kepada method
jika kita memiliki sebuah method static printInformation yang menerima referensi Person sebagai parameter 
    public static printInformation( Person p ){
                            . . . .
    }

Sebenarnya kita dapat passing reference dari Employee dan Student kepada method printInformation selama kedua class tersebut merupakan subclass dari Person
public static main( String[] args )
{
        Student    studentObject = new Student();
        Employee    employeeObject = new Employee();

        printInformation( studentObject );

        printInformation( employeeObject );
}

Casting Object

Instance dari class juga dapat di-casting menjadi instance dari class lain, dengan satu batasan ::
Class asal dan tujuan harus direlasikan dalam inheritance, salah satu class harus berupa subclass dari class lain.
Casting object digunakan untuk mengkonversi nilai primitif menuju tipe yang lebih besar, beberapa object tidak perlu mengalami casting secara explisit.
Gunakan sintaks berikut untuk casting object,

        (classname)object

classname     - nama class tujuan
object            - reference untuk object asal


Berikut ini merupakan contoh proses casting sebuah instance dari class VicePresident ke instance dari class Employee.
VicePresident merupakan subclass dari class Employee dengan beberapa informasi tambahan.
Employee emp = new Employee();
VicePresident veep = new VicePresident();
 
emp = veep;

// casting explisit
veep = (VicePresident)emp; 


Abstract Class


Abstract class adalah Sebuah class yang tidak bisa diinstansiasi
Sering muncul pada puncak hierarki class object-oriented programming(OOP), mendefinisikan segala type action/tindakan yang mungkin dengan object semua subclass dari class
Method abstract adalah Method di dalam abstract class tidak mempunyai implementasi, untuk membuat abstract method, tulis saja deklarasi method tanpa body dan gunakan keyword abstract.
Sebagai contoh,
public abstract void someMethod();

Contoh abstract class

public abstract class LivingThing {
    public void breath(){
        System.out.println("Living Thing breathing...");
    }

    public void eat(){
        System.out.println("Living Thing eating...");
    }

    /** 
     * abstract method walk 
     * Kita ingin method ini di-overrride oleh subclass dari 
     * LivingThing 
     */
    public abstract void walk();
}
Ketika sebuah class meng-extends abstract class LivingThing, diwajibkan meng-override abstract method walk(), jika tidak, subclass tersebut juga akan menjadi abstract class, dan oleh karena itu tidak bisa diinstansiasi
Sebagai contoh,
public class Human extends LivingThing {

    public void walk(){
        System.out.println("Human walks...");
    }

}
Petunjuk penulisan program :
Menggunakan abstract class untuk mendefinisi jenis-jenis yang luas dari behavior yang ada di puncak hirarki class object-oriented programming, dan menggunakan subclassnya untuk menyediakan detail implementasi dari abstract class.