TypeScript - Kelas Abstrak

Hai sana, para pemrogram yang sedang mencari ilmu! Hari ini, kita akan melakukan perjalanan menarik ke dunia TypeScript dan mengexplore salah satu fitur yang kuatnya: Kelas Abstrak. Jangan khawatir jika Anda masih baru dalam pemrograman; saya akan memandu Anda melalui konsep ini langkah demi langkah, sama seperti yang saya lakukan untuk ribuan murid selama tahun-tahun mengajar. mari kita masuk ke dalamnya!

Apa Itu Kelas Abstrak?

Sebelum kita masuk ke rincian kelas abstrak, mari kita mulai dengan analogi sederhana. Bayangkan Anda di dealer mobil dan Anda melihat tanda yang mengatakan "Vehicle" (Kendaraan). Anda tidak bisa benar-benar membeli "Kendaraan" karena itu terlalu umum. Anda perlu memilih jenis kendaraan tertentu, seperti mobil, truk, atau motor. Dalam pemrograman, kelas abstrak seperti konsep "Kendaraan" umum itu - itu adalah blueprint untuk kelas lain, tapi Anda tidak bisa membuat objek langsung dari itu.

Kelas abstrak dalam TypeScript berfungsi sebagai kelas dasar yang dapat diwarisi oleh kelas lain. Mereka dapat memiliki metode abstrak (metode tanpa tubuh) dan metode konkrit (metode dengan tubuh). Hal penting yang perlu diingat adalah Anda tidak dapat membuat instansi langsung dari kelas abstrak.

Membuat Kelas Abstrak

Sekarang, mari kita lihat bagaimana kita membuat kelas abstrak dalam TypeScript. Kita gunakan kata kunci abstract sebelum kata kunci class. Berikut adalah struktur dasar:

abstract class ClassName {
// Properti dan metode di sini
}

Metode Abstrak

Kelas abstrak dapat memiliki metode abstrak. Ini adalah metode yang dideklarasikan tapi tidak memiliki implementasi dalam kelas abstrak. Setiap kelas yang mewarisi kelas abstrak ini harus menyediakan implementasi untuk metode ini.

Metode Konyak

Kelas abstrak juga dapat memiliki metode konyak, yaitu metode yang sepenuhnya diimplementasikan dan dapat diwarisi oleh kelas anak.

Contoh 1: Kelas Abstrak Shape

Mari kita buat contoh sederhana untuk mengilustrasikan bagaimana kelas abstrak bekerja. Kita akan membuat kelas abstrak Shape dengan metode abstrak calculateArea().

abstract class Shape {
color: string;

constructor(color: string) {
this.color = color;
}

abstract calculateArea(): number;

displayColor(): void {
console.log(`This shape is ${this.color}`);
}
}

Dalam contoh ini:

• Shape adalah kelas abstrak kita.
• color adalah properti yang dimiliki oleh semua bentuk.
• calculateArea() adalah metode abstrak. Catatan bahwa itu tidak memiliki tubuh, hanya deklarasi.
• displayColor() adalah metode konyak yang dapat digunakan oleh semua bentuk.

Sekarang, mari kita buat beberapa bentuk tertentu yang mewarisi kelas Shape:

class Circle extends Shape {
radius: number;

constructor(color: string, radius: number) {
super(color);
this.radius = radius;
}

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

class Rectangle extends Shape {
width: number;
height: number;

constructor(color: string, width: number, height: number) {
super(color);
this.width = width;
this.height = height;
}

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

Sekarang kita dapat menggunakan kelas ini:

const circle = new Circle("red", 5);
console.log(circle.calculateArea()); // Output: 78.53981633974483
circle.displayColor(); // Output: This shape is red

const rectangle = new Rectangle("blue", 4, 6);
console.log(rectangle.calculateArea()); // Output: 24
rectangle.displayColor(); // Output: This shape is blue

Dalam contoh ini, keduanya Circle dan Rectangle mewarisi kelas Shape dan menyediakan implementasi mereka sendiri untuk metode calculateArea(). Mereka juga mewarisi metode displayColor() dari kelas Shape.

Contoh 2: Kelas Abstrak Animal

Mari kita buat contoh lain untuk menguatkan pemahaman kita. kali ini, kita akan membuat kelas abstrak Animal:

abstract class Animal {
name: string;

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

abstract makeSound(): void;

move(distance: number = 0): void {
console.log(`${this.name} moved ${distance} meters.`);
}
}

class Dog extends Animal {
constructor(name: string) {
super(name);
}

makeSound(): void {
console.log("Woof! Woof!");
}
}

class Cat extends Animal {
constructor(name: string) {
super(name);
}

makeSound(): void {
console.log("Meow!");
}
}

Mari kita gunakan kelas ini:

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Woof! Woof!
dog.move(10); // Output: Buddy moved 10 meters.

const cat = new Cat("Whiskers");
cat.makeSound(); // Output: Meow!
cat.move(5); // Output: Whiskers moved 5 meters.

Dalam contoh ini, Animal adalah kelas abstrak dengan metode abstrak makeSound() dan metode konyak move(). Dog dan Cat mewarisi Animal dan menyediakan implementasi mereka sendiri untuk makeSound().

Mengapa Menggunakan Kelas Abstrak?

Anda mungkin berpikir, " Mengapa harus mengalami kesulitan ini? Mengapa tidak hanya menggunakan kelas biasa?" Well, kelas abstrak sangat berguna ketika Anda ingin menentukan antar muka umum untuk set kelas yang berkaitan. Mereka memungkinkan Anda untuk:

1. Menentukan struktur umum untuk kelompok kelas yang berkaitan.
2. Menyatakan metode yang harus diimplementasikan oleh kelas anak.
3. Menyediakan beberapa fungsionalitas umum yang dapat digunakan oleh semua kelas anak.

Pertimbangkan hal ini sebagai membuat template atau kontrak yang kelas lain harus mengikuti. Itu adalah cara untuk memastikan konsistensi di antara kelas yang berkaitan saat masih memungkinkan kustomisasi di mana perlu.

Metode dalam Kelas Abstrak

Berikut adalah tabel yang menggabungkan jenis metode yang Anda dapat memiliki dalam kelas abstrak:

Tipe Metode	Deskripsi	Bisa dipanggil di kelas abstrak?	Harus diimplementasikan oleh kelas anak?
Metode Abstrak	Dideklarasikan tanpa implementasi	Tidak	Ya
Metode Konyak	Metode yang sepenuhnya diimplementasikan	Ya	Tidak (dapat di-overriding)

Kesimpulan

Dan begitu juga, teman-teman! Kita telah melakukan perjalanan melalui dunia kelas abstrak di TypeScript. Dari memahami apa itu kelas abstrak, membuatnya, hingga melihat mereka dalam aksi dengan contoh nyata, Anda sekarang memiliki dasar kuat dalam fitur kuat ini.

Ingat, kelas abstrak seperti blueprint untuk bangunan. Mereka menyediakan struktur dan beberapa detail, tapi kelas yang mewarisi mereka yang bertanggung jawab untuk mengisi khusus dan membawa mereka kehidupan.

Saat Anda terus melanjutkan perjalanan pemrograman Anda, Anda akan menemukan bahwa kelas abstrak adalah alat yang sangat berguna dalam kotak alat TypeScript Anda. Mereka membantu Anda menulis kode yang lebih bersih, lebih terorganisir, dan mudah dipelihara. Jadi, teruskan dan abstrak sesuai hati Anda!

Selamat coding, dan sampai jumpa lagi, terus eksplorasi dan terus belajar!

Credits: Image by storyset