Polymorfisme atau Polymorphism adalah salah satu konsep penting dalam object oriented

programming (OOP) di bahasa Java setelah abstraction dan inheritance. Polymorphism berarti
banyak bentuk. Ada beberapa definisi berbeda tentang polymorphism. Sedangkan polymorphism
sendiri sulit didefinisikan. Berikut adalah beberapa pengertian polimorfisme :
➢ Polimorfisme merupakan suatu konsep yang menyatakan sesuatu yang sama dapat memiliki
berbagai bentuk dan perilaku berbeda. Istilah ini sendiri berasal dari bahasa Yunani, yang
berarti “Mempunyai banyak bentuk”.
➢ Polimorfisme merupakan kemampuan objek-objek yang berbeda kelas namun terkait dalam
pewarisan untuk merespon secara berbeda terhadap suatu pesan yang sama. Polimarfisme
juga dapat dikatakan kemampuan sebuah objek untuk memutuskan method mana yang akan
diterapkan padanya, tergantung letak objek tersebut pada jenjang pewarisan.
➢ Polimorfisme adalah kemampuan suatu objek untuk mengungkapkan banyak hal melalui
satu cara yang sama. Polimorfisme mengizinkan kelas induk untuk mendefinisikan sebuah
method general (bersifat umum) untuk semua kelas turunanya, dan selanjutnya kelas-kelas
turunan dapat memperbaharui implementasi dari method tersebut secara lebih spesifik
sesuai dengan karakteristiknya masing-masing.

Pada dasarnya, Polimorfisme dalam OOP adalah sebuah prinsip di mana class dapat memiliki
banyak “bentuk” method yang berbeda-beda meskipun namanya sama. Polymorphism sering
dikaitkan dengan penggunaan lebih dari satu metoda dengan nama sama. Penggunaan metoda
dengan nama sama dapat melalui method overloading dan juga method overriding. Peran
polymorphism sebenarnya tidak terbatas hanya pada hal-hal tersebut. Ada keterkaitan erat
antara polymorphism dan inheritance (turunan).
Dalam konsep turunan, saat obyek dari subclass dikonstruksi, obyek dari superclass juga ikut
dikonstruksi. Jadi setiap instance dari subclass adalah juga instance dari superclass. Apabila Anda
mendeklarasikan metoda dengan parameter dari tipe superclass, Anda diperbolehkan untuk
memberi argumen berupa obyek subclass yang merupakan turunan dari superclass tersebut.
Sesuai dengan namanya, Poly artinya banyak, morfisme artinya bentuk. “Bentuk” di sini dapat
kita artikan: isinya berbeda, parameternya berbeda, dan tipe datanya berbeda.
Terdapat 2 macam Polimorfisme pada Java, yaitu :
1. Static Polymorphism (Polimorfisme statis);
2. Dynamic Polymorphism (Polimorfisme dinamis).

Beda dari keduanya terletak pada cara membuat polimorfismenya. Polimorfisme statis
menggunakan method overloading sedangkan polimorfisme dinamis menggunakan method
overriding, sehingga proses Override dibentuk agar Java dapat mendukung konsep polimorfisme.
Berikut perbedaan kedua jenis polimorfisme tersebut.

1. Static Polymorphism (Polimorfisme statis) menggunakan Method overloading

Method overloading ini terjadi pada sebuah class yang memiliki nama method yang sama
tapi memiliki parameter dan tipe data yang berbeda. Kata kunci yang perlu diingat adalah :
a) “Dalam satu class”
b) “Nama method sama”
c) “Tipe data dan parameter beda”
Contoh :
Misalkan kita memiliki class Lingkaran.java. Pada class ini terdapat method luas(), maka
method luas() ini bisa saja memiliki parameter yang berbeda. jika 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);
}

}
 Pada program diatas, Class Lingkaran memiliki dua method yang namanya sama, yakni luas().
Tapi parameter dan tipe datanya berbeda, begitu juga isi atau rumus di dalamnya berbeda.
Inilah yang disebut polimorfisme statis.

2. Dynamic Polymorphism (Polimorfisme dinamis) menggunakan Method overriding

Polimorfisme dinamis biasanya terjadi saat kita menggunakan pewarisan (inheritance) dan
implementasi interface. 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, inilah yang disebut polimorfisme. Berikut adalah contoh polmorfisme
dinamis :

Class anak pada gambar diatas akan memiliki nama method yang sama, tapi nanti isi dan
parameternya bisa berbeda dari class induk. Karena si class anak melakukan method overriding
(menindih method) yang diwariskannya. Polimofirme dinamis juga bisa terjadi saat menggunakan
interface (akan dibahas pada materi interface).
Contoh Program Polimorfisme Dinamis
Contoh program polimorfisme dinamis sudah pernah dibahas pada materi Inheritance, namun akan
diulang kembali dalam materi ini. Berikut contoh programnya :

Program data dari Persegi, Lingkaran, dan Segitiga dengan superclass Bangundatar
a) Berikut class diagramnya

Pada diagram tersebut, terdapat class BangunDatar 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.

b) Package bangundatar
Lakukan Langkah Pembuatan Package
c) Class BangunDatar
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;
}
}

d) Class Persegi
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;
}
}
e) Class Segitiga
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;
}
}

f) Class Lingkaran
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);
}

}
g) Class Main
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());
}
}

h) Output
LATIHAN
Buatlah program :
1. Static Polymorphism (Polimorfisme statis);
2. Dynamic Polymorphism (Polimorfisme dinamis).
Sertakan langkah-langkahnya dan outputnya