Java OOP | Polymorphism
Polymorphism In Java
Makna polymorphism terdiri dari dua kata, yang berasal dari Yunani: kata Poly berarti (Banyak), kata Morphs berarti (Bentuk), "Banyak Bentuk".
Polymorphism adalah kemampuan untuk menghandle banyak bentuk, yang memungkinkan kita untuk memproses object yang dapat berubah bentuk menjadi bentuk lain dalam satu antarmuka yang seragam. Polymorphism erat kaitannya dengan Inheritance.
Contoh polymorphism dalam kehidupan nyata: anda adalah seorang object pria yang dapat memiliki karakteristik/method yang berbeda. Seperti pada saat anda menjadi seorang ayah, seorang suami, seorang karyawan, seseorang dalam keluarga. anda seorang pria yang sama memiliki karakteristik yang berbeda dalam situasi yang berbeda, itulah polymorphism.
Java memiliki dua tipe polymorphism:
- Compile time Polymorphism(static polymorphism)
- Runtime Polymorphism(dynamic polymorphism)
Compile Time Polymorphism
Tipe polymorphism ini menerapkan tekhnik fungsi/method Overloading, method Overloading dipanggil melalui variable reference object kelas saat ini, bukan superclass.
Jika didalam sebuah kelas memiliki nama method yang sama dengan jumlah parameter dan tipedata yang berbeda, Itu adalah method overloading.
Contoh 1: Demonstrasi Compile Time Polymorphism
File: Developer.java
public class Developer {
public void seyHello(String name) {
System.out.println("Developer Name : "+name);
}
public void seyHello(String name, String company) {
System.out.println("Developer Name : "+name);
System.out.println("Working in Company : "+company);
}
public void seyHello(String name, String company, String position) {
System.out.println("Developer Name : "+name);
System.out.println("Working in Company : "+company);
System.out.println("Developer Position : "+position);
}
}
File: MainApp.java
public class MainApp {
public static void main(String[] args) {
Developer developer = new Developer();
developer.seyHello("Kiki", "dewaprogrammer.com");
/* OUTPUT:
Developer Name : Kiki
Working in Company : dewaprogrammer.com
*/
}
}
Contoh 2: Demonstrasi Compile Polymorphism
File: Employe.java
public class Employe {
public long getSalary(long salary, float bonus) {
float getBonus = salary * bonus;
long total = (long) (getBonus + salary);
return total;
}
public long getSalary(long salary, float bonus, float tunjanganAnak) {
float getBonus = (salary * bonus) + (salary * tunjanganAnak);
long total = (long) (getBonus + salary);
return total;
}
}
File: MainApp.java
public class MainApp {
public static void main(String[] args) {
Employe employe = new Employe();
var employeSalary1 = employe.getSalary(10_000_000, 0.1F);
var employeSalary2 = employe.getSalary(4_500_000, 0.1F, 0.02F);
System.out.println("Salary Employe 1 : Rp."+employeSalary1);
System.out.println("Salary Employe 2 : Rp."+employeSalary2);
/* OUTPUT:
Salary Employe 1 : Rp.11000000
Salary Employe 2 : Rp.5040000
*/
}
}
Sewaktu kompilasi, Java sudah tahu method mana yang akan dipanggil. Overloading juga dapat diterapkan pada Method Constructor.
Runtime Polymorphism
Tipe polymorphism ini menerapkan tekhnik fungsi/method Overriding. Overriding adalah mendefinisikan ulang method yang sudah ada pada kelas Parent didalam kelas Child.
Proses pemangilan method overriding dipanggil melalui variable reference superclass. untuk menentukan method Override mana yang akan dipanggil, berdasarkan Object yang ditunjuk oleh variable reference superclass.
Contoh 1: Demonstrasi Runtime Polymorphism
public class Bank {
public String name;
public float interestCost() {
return 0.0F;
}
}
public class Bri extends Bank {
public float interestCost() {
return 4.12F;
}
}
public class Bca extends Bank {
public float interestCost() {
return 4.23F;
}
}
public class Mandiri extends Bank {
public float interestCost() {
return 7.0F;
}
}
public class MainApp {
public static void main(String[] args) {
Bank bank; //variable reference superclass
bank = new Bri();
bank.name = "BRI";
System.out.println("Interest Cost "+bank.name+" : "+bank.interestCost()+"%");
bank = new Bca();
bank.name = "BCA";
System.out.println("Interest Cost "+bank.name+" : "+bank.interestCost()+"%");
bank = new Mandiri();
bank.name = "MANDIRI";
System.out.println("Interest Cost "+bank.name+" : "+bank.interestCost()+"%");
/* OUTPUT:
Interest Cost BRI : 4.12%
Interest Cost BCA : 4.23%
Interest Cost MANDIRI : 7.0%
*/
}
}
Pada contoh demonstrasi diatas, Bri Bca dan Mandiri, meng-Override method interestCost. Java akan menunggu pada saat Runtime untuk menentukan menthod interestCost() mana yang akan dipanggil. bukan pada saat waktu kompilasi
Bank bank //variable reference superclass
bank = new Bri()
bank = new Bca()
bank = new Mandiri()
Jika kita mensubtitusi variable reference superclass dengan object subclass maka kita tidak bisa mengakses langsung field & method yang ada pada subclass. Kita hanya bisa mengakses field dan method yang ada pada superclass serta method override.
Jika ingin mengembalikan object subclass ke reference real subclass nya, kita bisa melakukan dengan cara Downcasting. sehingga dengan melakukan cara ini kita bisa mengakses field & method pada subclass.
Bank bank = new Bri();
/*Downcasting*/
Bri bri = (Bri) bank
Contoh 2: Demonstrasi Runtime Polymorphism
public class Employe {
public float bonus;
public long getSalary(long salary) {
return salary;
}
}
public class Developer extends Employe {
public long getSalary(long salary) {
return (long) (salary * super.bonus) + salary;
}
}
public class Designer extends Employe {
public long getSalary(long salary) {
return (long) (salary * super.bonus) + salary;
}
}
public class PolymorphismApp {
public static void main(String[] args) {
Employe employe = new Employe();
employe = new Developer();
employe.bonus = 0.1F;
System.out.println("Developer Salary : "+employe.getSalary(10_000_000));
employe = new Designer();
employe.bonus = 0.07F;
System.out.println("Designer Salary : "+employe.getSalary(8_850_000));
}
}
Output:
Developer Salary : 11000000
Designer Salary : 9469500
Posting Komentar