TypeScript - Kelas Abstrak

Hai teman-teman yang sedang belajar pemrograman! Hari ini, kita akan melakukan perjalanan menarik ke dunia TypeScript dan mengexplore salah satu fitur yang kuatnya: Kelas Abstrak. Jangan khawatir jika Anda masih pemula; saya akan mengarahkan Anda melalui konsep ini secara langkah demi langkah, seperti yang saya lakukan untuk ribuan siswa 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 toko mobil dan Anda melihat tanda yang mengatakan "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 ini - itu adalah blueprint untuk kelas lain, tapi Anda tidak bisa membuat objek langsung dari itu.

Kelas abstrak di TypeScript bertindak sebagai kelas dasar dari mana kelas lainnya dapat menginherit. Mereka dapat memiliki metode abstrak (metode tanpa tubuh) dan metode konkrit (metode dengan tubuh). Hal penting yang harus diingat adalah Anda tidak bisa membuat instance langsung dari kelas abstrak.

Membuat Kelas Abstrak

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

abstract class NamaKelas {
// 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 mengextend kelas abstrak ini harus menyediakan implementasi untuk metode ini.

Metode Konkrit

Kelas abstrak juga dapat memiliki metode konkrit, 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 semua bentuk akan memiliki.
• calculateArea() adalah metode abstrak. Perhatikan bahwa itu tidak memiliki tubuh, hanya deklarasi.
• displayColor() adalah metode konkrit yang semua bentuk dapat gunakan seperti biasa.

Sekarang, mari kita buat beberapa bentuk khusus yang mengextend kelas Shape kita:

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, baik Circle maupun Rectangle mengextend 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 konkrit move(). Dog dan Cat mengextend 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 kelompok 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 semua kelas anak dapat gunakan.

Pertimbangkan itu sebagai template atau kontrak yang kelas lain harus mengikuti. Itu adalah cara untuk memastikan konsistensi di antara kelas yang berkaitan saat masih memungkinkan penyesuaian di mana diperlukan.

Metode Dalam Kelas Abstrak

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

Jenis Metode	Deskripsi	Dapat dipanggil pada kelas abstrak?	Harus diimplementasikan oleh kelas anak?
Metode Abstrak	Dideklarasikan tanpa implementasi	Tidak	Ya
Metode Konkrit	Metode yang sepenuhnya diimplementasikan	Ya	Tidak (dapat di-override)

Kesimpulan

Dan itu adalah nya, teman-teman! Kita telah melakukan perjalanan melalui dunia kelas abstrak di TypeScript. Dari memahami apa itu kelas abstrak, membuatnya, sampai melihat nya dalam tindakan dengan contoh nyata, Anda sekarang memiliki dasar kuat dalam fitur kuat ini dari TypeScript.

Ingat, kelas abstrak adalah seperti blueprint untuk bangunan. Mereka menyediakan struktur dan beberapa detail, tapi itu adalah tanggung jawab kelas yang mengextend mereka untuk mengisi khusus dan membawa mereka kehidupan.

Sebagai 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 abstrakkan ke hati Anda!

Selamat pemrograman, dan sampai jumpa lagi, terus eksplor dan terus belajar!

Credits: Image by storyset