Memahami Inheritance dan Polymorphism dalam TypeScript untuk OOP yang Lebih Efisien

Dalam pemrograman berorientasi objek (OOP), konsep Inheritance TypeScript dan Polymorphism memainkan peran penting dalam menciptakan kode yang efisien, terstruktur, dan mudah dikembangkan. TypeScript, sebagai bahasa berorientasi objek modern di atas JavaScript, menyediakan fitur-fitur OOP yang kuat seperti class, inheritance, dan abstraction. Dengan memahami konsep ini, pengembang dapat membuat aplikasi yang modular dan mudah diperluas.

TypeScript tidak hanya menambahkan tipe data statis, tetapi juga memperluas kemampuan JavaScript dalam mendukung pemrograman berbasis class. Melalui Inheritance TypeScript, kita dapat mewarisi properti dan method dari class induk ke class turunan. Sementara Polymorphism memungkinkan objek untuk berperilaku berbeda tergantung konteksnya, tanpa mengubah struktur utama kode.

Apa Itu Inheritance dalam TypeScript?

Inheritance atau pewarisan memungkinkan satu class mewarisi properti dan method dari class lain. Dengan kata kunci extends, kita dapat membuat class turunan (subclass) yang memperluas fungsionalitas dari class induk (superclass). Ini sangat berguna untuk menghindari pengulangan kode dan menjaga konsistensi antar objek.

Contoh dasar inheritance:

class Animal {
  name: string;
  
  constructor(name: string) {
    this.name = name;
  }

  makeSound() {
    console.log("Suara hewan umum");
  }
}

class Dog extends Animal {
  makeSound() {
    console.log("Guk guk!");
  }
}

const myDog = new Dog("Buddy");
myDog.makeSound(); // Output: Guk guk!

Pada contoh di atas, class Dog mewarisi properti dan method dari Animal. Namun, ia juga bisa mengubah (override) method makeSound() sesuai kebutuhan.

Override Method dalam TypeScript

Override method adalah proses mengganti implementasi method dari class induk ke versi baru di class turunan. TypeScript akan memastikan bahwa tanda tangan fungsi (function signature) tetap sama agar tetap konsisten.

Contoh override method:

class Vehicle {
  move() {
    console.log("Kendaraan bergerak...");
  }
}

class Car extends Vehicle {
  move() {
    console.log("Mobil melaju di jalan raya...");
  }
}

const car = new Car();
car.move(); // Output: Mobil melaju di jalan raya...

Melalui override, kita dapat menyesuaikan perilaku method sesuai konteks objek tanpa mengubah struktur dasarnya. Ini juga merupakan dasar dari konsep polymorphism.

Apa Itu Polymorphism?

Polymorphism berarti “banyak bentuk”, di mana satu interface atau class dapat memiliki banyak implementasi berbeda. Dalam konteks TypeScript, polymorphism memungkinkan objek untuk diperlakukan sebagai class induknya, namun menjalankan perilaku spesifik class turunannya.

Contoh polymorphism:

class Shape {
  draw() {
    console.log("Menggambar bentuk umum");
  }
}

class Circle extends Shape {
  draw() {
    console.log("Menggambar lingkaran");
  }
}

class Square extends Shape {
  draw() {
    console.log("Menggambar persegi");
  }
}

function render(shape: Shape) {
  shape.draw();
}

render(new Circle()); // Output: Menggambar lingkaran
render(new Square()); // Output: Menggambar persegi

Dalam contoh di atas, fungsi render() dapat menerima objek dari class Shape, namun berkat polymorphism, ia menjalankan method draw() sesuai class turunannya.

Abstract Class dalam TypeScript

Selain inheritance biasa, TypeScript juga mendukung abstract class, yaitu class yang tidak dapat diinstansiasi secara langsung. Class ini biasanya digunakan sebagai blueprint bagi class turunannya. Abstract class dapat memiliki method abstract (tanpa isi) dan non-abstract (dengan isi).

Contoh penggunaan abstract class:

abstract class Animal {
  abstract makeSound(): void;

  move(): void {
    console.log("Bergerak...");
  }
}

class Cat extends Animal {
  makeSound() {
    console.log("Meong!");
  }
}

const cat = new Cat();
cat.makeSound(); // Output: Meong!
cat.move(); // Output: Bergerak...

Di sini, Animal bertindak sebagai blueprint. Semua class yang mewarisinya harus mengimplementasikan method makeSound() karena bersifat abstract.

Kesimpulan

Konsep Inheritance TypeScript dan Polymorphism memberikan dasar yang kuat untuk membangun sistem yang modular dan dapat diperluas. Dengan menggunakan extends, override, dan abstract class, pengembang dapat membuat hierarki class yang rapi serta mendukung pengembangan aplikasi jangka panjang dengan efisien.

Jika kamu sudah memahami inheritance dan polymorphism, langkah selanjutnya adalah belajar tentang interface implementation dan generic class, dua konsep penting untuk pengembangan TypeScript tingkat lanjut.