Polimorfisme adalah salah satu konsep utama dalam pemrograman berorientasi objek (OOP) yang memungkinkan objek dari class yang berbeda untuk merespons metode yang sama dengan cara yang sesuai dengan class mereka. Dengan kata lain, polimorfisme memungkinkan objek untuk berperilaku dengan cara yang bervariasi sesuai dengan jenis objeknya. Artikel ini akan menjelaskan konsep polimorfisme dalam OOP, bagaimana cara menerapkannya dalam TypeScript, dan mengapa itu penting dalam pengembangan aplikasi.

Apa Itu Polimorfisme?

Polimorfisme berasal dari bahasa Yunani yang berarti "banyak bentuk." Dalam konteks pemrograman berorientasi objek, polimorfisme mengacu pada kemampuan objek dari class yang berbeda untuk merespons metode dengan nama yang sama. Ini memungkinkan pemrosesan objek secara umum tanpa perlu mengetahui class sebenarnya dari objek tersebut.

Polimorfisme dapat diterapkan melalui dua cara utama:

1. Polimorfisme Compile-Time (Polimorfisme Statis): Polimorfisme yang terjadi selama kompilasi. Ini terkait dengan overloading dan interface dalam TypeScript.

2. Polimorfisme Runtime (Polimorfisme Dinamis): Polimorfisme yang terjadi saat runtime. Ini terkait dengan inheritance dan override dalam TypeScript.

Menerapkan Polimorfisme dalam TypeScript

1. Polimorfisme Compile-Time (Polimorfisme Statis)

Menggunakan Overloading

Polimorfisme compile-time dapat dicapai melalui overloading metode. Ini memungkinkan Anda untuk mendefinisikan beberapa versi dari suatu metode dengan berbagai jenis parameter.

class Calculator {
  add(a: number, b: number): number;
  add(a: string, b: string): string;
  add(a: any, b: any): any {
    return a + b;
  }
}

const calculator = new Calculator();
console.log(calculator.add(5, 10));         // Output: 15
console.log(calculator.add("Hello, ", "World!")); // Output: Hello, World!

Dalam contoh di atas, metode add di-overload untuk menerima parameter dengan tipe yang berbeda. Pemanggilan calculator.add akan menghasilkan hasil yang sesuai dengan jenis parameter yang diberikan.

Menggunakan Interface

Polimorfisme compile-time juga dapat dicapai melalui interface. Interface memungkinkan Anda untuk mendefinisikan kontrak metode yang harus diimplementasikan oleh class-class yang mengimplementasikan interface tersebut.

interface Shape {
  calculateArea(): number;
}

class Circle implements Shape {
  radius: number;

  constructor(radius: number) {
    this.radius = radius;
  }

  calculateArea(): number {
    return Math.PI * this.radius * this.radius;
  }
}

class Square implements Shape {
  side: number;

  constructor(side: number) {
    this.side = side;
  }

  calculateArea(): number {
    return this.side * this.side;
  }
}

Dalam contoh di atas, Shape adalah interface yang mengharuskan class-class yang mengimplementasikannya untuk memiliki metode calculateArea(). Polimorfisme compile-time memungkinkan kita untuk memproses objek-objek dari class yang berbeda dengan cara yang sama.

2. Polimorfisme Runtime (Polimorfisme Dinamis)

Menggunakan Inheritance

Polimorfisme runtime terkait dengan pewarisan dan override dalam OOP. Ini memungkinkan objek dari class turunan untuk digunakan dengan cara yang serupa seperti objek dari class dasar.

class Animal {
  speak(): void {
    console.log("Animal speaks");
  }
}

class Dog extends Animal {
  speak(): void {
    console.log("Dog barks");
  }
}

const myAnimal: Animal = new Dog();
myAnimal.speak(); // Output: Dog barks

Dalam contoh di atas, myAnimal adalah objek dari class Dog, tetapi ia digunakan dalam variabel bertipe Animal. Meskipun begitu, metode yang dipanggil adalah versi yang dioverride dalam class Dog.

Keuntungan Polimorfisme

Polimorfisme memungkinkan fleksibilitas dalam pemrograman berorientasi objek:

• Anda dapat bekerja dengan objek dari class yang berbeda tanpa harus tahu class sebenarnya dari objek tersebut.
• Anda dapat menangani objek-objek yang mengimplementasikan interface tertentu dengan cara yang serupa.
• Dalam pewarisan, Anda dapat menggunakan objek dari class turunan dalam situasi yang mengharapkan objek dari class dasar.

Polimorfisme memungkinkan Anda untuk memodelkan hubungan antara objek dengan lebih baik dan mengurangi kebutuhan untuk kode yang berulang. Itu adalah salah satu pilar utama dalam pemrograman berorientasi objek yang membantu dalam membangun aplikasi yang lebih fleksibel dan mudah dikelola.