Belajar Java OOP: Memahami Prinsip Polimorfisme dalam OOP
Pemrograman berorientasikan objek atau OOP, memiliki beberapa pilar atau konsep penting yang harus dipahami.
Di antaranya ada: Class, Objek, Enkapsulasi, Inheritance, dan lainnya.
Pada tutorial sebelumnya, kita sudah belajar tentang:
Berikutnya, kita akan belajar tentang Polimorfisme.
Apa itu Polimorfisme dan bagaimana contohnya?
Mari kita bahas!
Apa itu Polimorfisme?
Poly artinya banyak, morfisme artinya bentuk.
Polimorfisme (bahasa inggris polymorphism) adalah sebuah prinsip dalam biologi di mana oraganisme atau spesias dapat memiliki banyak bentuk atau tahapan (stages). 1
Prinsip ini juga diadopsi pada pemrograman berorientasikan objek.
Sehingga kita dapat definisikan sebagai berikut:
Polimorfisme dalam OOP adalah sebuah prinsip di mana class dapat memiliki banyak “bentuk” method yang berbeda-beda meskipun namanya sama.
“Bentuk” di sini dapat kita artikan: isinya berbeda, parameternya berbeda, dan tipe datanya berbeda.
Polimorfisme pada Java ada dua macam:
- Static Polymorphism (Polimorfisme statis);
- Dynamic Polymorphism (Polimorfisme dinamis).
Beda dari keduanya terletak pada cara membuat polimorfismenya.
Polimorfisme statis menggunakan method overloading sedangkan polimorfisme dinamis menggunakan method overriding.
Karena kamu baru mendengar kedua hal ini, mari kita bahas perbedaanya lebih detail:
Perbedaan Method Overloading dengan Method Overriding
Method overloading terjadi pada sebuah class yang memiliki nama method yang sama tetapi memiliki parameter dan tipe data yang berbeda.
Kata kunci yang perlu kamu ingat:
“Dalam satu class”
“Nama method sama”
“Tipe data dan parameter beda”
Itulah method Overloading.
Contohnya bagaimana?
Contohnya misalkan kita memiliki class Lingkaran.java. Pada class ini terdapat method luas().
Nah, si method luas() ini bisa saja memiliki parameter yang berbeda.
Misalnya kita ingin menghitung luas berdasarkan jari-jari (radius) atau diameter.
Maka kita dapat membuat class-nya seperti ini:
class Lingkaran {
// method menghitung luas dengan jari-jari
float luas(float r){
return (float) (Math.PI * r * r);
}
// method menghitung luas dengan diameter
double luas(double d){
return (double) (1/4 * Math.PI * d);
}
}
Coba perhatikan!
Class Lingkaran memiliki dua method yang namanya sama, yakni luas().
Tetapi parameter dan tipe datanya berbeda dan isi atau rumus di dalamnya berbeda. Inilah yang disebut polimorfisme satatis.
Sudah paham ‘kan? Lalu Polimorfisme yang dinamis bagaimana?
Polimorfisme dinamis biasanya terjadi saat kita menggunakan pewarisan (inheritance) dan implementasi interface.
Seperti yang sudah kita ketahui:
Pada pewarisan, kita bisa mewariskan atribut dan method dari class induk ke class anak.
Class anak akan memiliki nama method yang sama dengan class induk dan anak yang lainnya.
Nah! Di sinilah akan terjadi polimorfisme.
Class anak akan memiliki nama method yang sama, tapi nanti isi dan parameternya bisa berbeda dari class induk.
Karena si class anak melakukan method overriding (mendindih method) yang diwariskannya.
Polimofirme dinamis juga bisa terjadi saat menggunakan interface.
Oh iya, buat kamu yang belum tahu interface.
Interface adalah class kosong yang berisi nama-nama method yang nanti harus diimplementasikan pada class lain. Dalam pengimplementasiannya bisa saja tiap-tiap class akan mengimplementasikan secara berbeda dengan nama method yang sama.
Nah! kelihatan kan bedanya?
Jadi polimorfisme statis hanya terjadi dalam satu class saja, sedangkan polimorfisme dinamis terjadi pada saat ada hubungan dengan class lain seperti inheritance.
Oke sekarang mari kita lihat contohnya:
Contoh Program Polimorfisme Dinamis
Contoh program polimorfisme dinamis sebenarnya sudah pernah kita buat pada pembahasan inheritance.
Kita coba bahas lagi, ya!
Perhatikan diagram ini:
Pada diagram tersebut, terdapat class BanungDatar yang memiliki tiga subclass, yaitu: Persegi, Lingkaran, dan Segitiga.
Setiap class memiliki method yang sama yaitu luas() dan keliling(). Akan tetapi method-method ini memiliki isi rumus yang berbeda.
Mari kita coba buat dalam program Java.
Buatlah proyek baru di Netbeans!
Berikan nama ContohPolimorfisme:
Setelah itu, buat package baru dengan nama bangundatar.
Buat class baru di dalam package bangundatar. Caranya, klik kanan lalu pilih New Java Class.
Buatlah class baru dengan BangunDatar, kemudian isi dengan kode berikut:
package bangundatar;
public class BangunDatar {
float luas(){
System.out.println("Menghitung luas bangun datar");
return 0;
}
float keliling(){
System.out.println("Menghitung keliling bangun datar");
return 0;
}
}
Berikutnya buat class lagi dengan nama Persegi dan isi kodenya seperti ini:
package bangundatar;
public class Persegi extends BangunDatar{
int sisi;
public Persegi(int sisi) {
this.sisi = sisi;
}
@Override
public float luas() {
return this.sisi * this.sisi;
}
@Override
public float keliling(){
return this.sisi * 4;
}
}
Berikutnya buat class Segitiga dengan isi sebagai berikut:
package bangundatar;
public class Segitiga extends BangunDatar{
int alas;
int tinggi;
public Segitiga(int alas, int tinggi) {
this.alas = alas;
this.tinggi = tinggi;
}
@Override
public float luas(){
return this.alas * this.tinggi;
}
}
Berikutnya buat class Lingkaran dengan isi sebagai berikut:
package bangundatar;
public class Lingkaran extends BangunDatar {
int r;
public Lingkaran(int r) {
this.r = r;
}
@Override
public float luas(){
return (float) (Math.PI * r * r);
}
@Override
public float keliling(){
return (float) (2 * Math.PI * r);
}
}
Terakhir, buat class Main dengan isi sebagai berikut:
package bangundatar;
public class Main {
public static void main(String[] args) {
BangunDatar bangunDatar = new BangunDatar();
Persegi persegi = new Persegi(4);
Segitiga segitiga = new Segitiga(6, 3);
Lingkaran lingkaran = new Lingkaran(50);
// memanggil method luas dan keliling
bangunDatar.luas();
bangunDatar.keliling();
System.out.println("Luas persegi: " + persegi.luas());
System.out.println("keliling persegi: " + persegi.keliling());
System.out.println("Luas segitiga: " + segitiga.luas());
System.out.println("Luas lingkaran: " + lingkaran.luas());
System.out.println("keliling lingkaran: " + lingkaran.keliling());
}
}
Sekarang kita sudah punya lima class di dalam package bagnundatar.
Class yang bisa dijalankan hanyalah class Main, karena ia memiliki method main.
Untuk menjalankannya, silahkan klik kanan pada class main, lalu pilih Run File.
Maka hasilnya:
Mau Contoh Lagi?
Oke, di contoh yang kedua ini kita akan membuat aplikasi untuk mengirim notifikasi dengan Interface.
Ini adalah bentuk diagramnya:
Mari kita coba buat!
Pada proyek ContohPolimorfisme, buatlah package baru dengan nama notifikasi.
Setelah itu, di dalam package notifikasi, buatlah class baru dengan nama InterfaceNotifikasi dan isi kodenya seperti ini:
package notifikasi;
public interface InterfaceNotifikasi {
void sendMessage(String receiver, String content);
}
Berikutnya, di dalam package yang sama, buatlah class baru dengan nama EmailNotification dan isi seperti ini:
package notifikasi;
public class EmailNotification implements InterfaceNotifikasi{
@Override
public void sendMessage(String receiver, String content) {
System.out.println("Mengirim email ke " + receiver + " dengan isi:");
System.out.println(content);
}
}
Berikutnya, di dalam package yang sama.. buatlah class baru dengan nama SMSNotification dan isi seperti ini:
package notifikasi;
public class SMSNotification implements InterfaceNotifikasi{
@Override
public void sendMessage(String receiver, String content) {
System.out.println("Mengirim SMS ke " + receiver + " dengan isi:");
System.out.println(content);
}
}
Berikutnya, di dalam package yang sama, buatlah class baru dengan nama PushNotification dan isi seperti ini:
package notifikasi;
public class PushNotification implements InterfaceNotifikasi{
@Override
public void sendMessage(String receiver, String content) {
System.out.println("Mengirim Push Notif ke " + receiver + " dengan isi:");
System.out.println(content);
}
}
Terakhir, buatlah class Main di dalam package notifikasi dan isi kodenya seperti ini:
package notifikasi;
public class Main {
public static void main(String[] args) {
String emailPenerima = "[email protected]";
String nomerHp = "+628111111111";
String mobileId = "android-123456";
EmailNotification emailNotif = new EmailNotification();
SMSNotification smsNotif = new SMSNotification();
PushNotification pushNotif = new PushNotification();
String message = "Tutorial Polimorfisme sudah terbit di Petani Kode, cek sekarang di https://www.petanikode.com/java-oop-polimorfisme";
emailNotif.sendMessage(emailPenerima, message);
smsNotif.sendMessage(nomerHp, message);
pushNotif.sendMessage(mobileId, message);
}
}
Hasilnya:
Walapun semua isi method sendMessage() sama, namun nanti pada implementasinya di dunia nyata akan beda-beda. EmailNotification biasanya akan mengirim email dengan metode SMTP atau API. Sedangkan SMS bisa melalui SMS Gateway. Begitu juga dengan PushNotofication, nanti akan menggunakan API yang berbeda.
Nah itulah contoh polimorfisme dengan interface. Pelajari Java OOP lebih lanjut pada artikel berikut!
Baca juga: Tutorial Java OOP: Memahami Interface di Java (dan Contohnya) | Tutorial Java OOP: Mengenal Class Abstrak dan Cara Pakainya | Tutorial Java OOP: Mengenal Class Anonymous di Java
