Abstract Class TypeScript: Method, Property, vs Interface

Abstract class adalah class dasar yang ditandai abstract. Class ini tidak bisa dibuat dengan new, dan boleh mendeklarasikan method abstract tanpa isi yang wajib diimplementasikan oleh setiap subclass.

abstract class Shape {
    abstract area(): number; // no body: subclasses provide it

    describe(): string {
        // Concrete methods can call abstract ones.
        return `${this.constructor.name} with area ${this.area().toFixed(2)}`;
    }
}

class Circle extends Shape {
    constructor(private r: number) {
        super();
    }
    area(): number {
        return Math.PI * this.r ** 2;
    }
}

class Rect extends Shape {
    constructor(private w: number, private h: number) {
        super();
    }
    area(): number {
        return this.w * this.h;
    }
}

const shapes: Shape[] = [new Circle(1), new Rect(2, 3)];
for (const s of shapes) console.log(s.describe());
// Circle with area 3.14
// Rect with area 6.00

Shape membagikan describe() ke setiap subclass dan memaksa masing-masing menyediakan area(). Tipe Shape[] bisa menampung campuran subclass apa pun.

Abstract Class Tidak Bisa Diinstansiasi

Memanggil new pada abstract class adalah error kompilasi, karena objek yang dihasilkan akan punya method tanpa implementasi:

// This does not compile: Shape is abstract.
abstract class Shape {
    abstract area(): number;
}

const s = new Shape();
console.log(s.area());

index.ts(6,11): error TS2511: Cannot create an instance of an abstract class.

Ini aturan saat kompilasi. abstract dihapus dari output, jadi Shape yang dihasilkan adalah class JavaScript biasa, dan kode JavaScript tanpa tipe tetap bisa memanggil new Shape(). Kalau sebuah library butuh pengaman saat runtime, constructor bisa memeriksa new.target:

abstract class Plugin {
    constructor() {
        if (new.target === Plugin) {
            throw new TypeError("Plugin is abstract; extend it");
        }
    }
    abstract run(): string;
}

class Hello extends Plugin {
    run(): string {
        return "hello";
    }
}

console.log(new Hello().run()); // hello

Method dan Property Abstract

Subclass wajib mengimplementasikan setiap member abstract, atau ikut menjadi abstract. Kalau ada yang terlewat, muncul error TS2515 yang bunyinya kira-kira Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape', atau TS2654 yang mendaftar semuanya kalau ada beberapa yang terlewat.

Field, getter, dan method semuanya bisa abstract, dan bisa juga protected:

abstract class Report {
    abstract readonly title: string;          // abstract property
    protected abstract rows(): string[];      // only for subclasses

    abstract get footer(): string;            // abstract getter

    render(): string {
        return [this.title, ...this.rows(), this.footer].join("\n");
    }
}

class SalesReport extends Report {
    readonly title = "Sales Q1";

    protected rows(): string[] {
        return ["Jan: 120", "Feb: 95", "Mar: 140"];
    }

    get footer(): string {
        return "Total: 355";
    }
}

console.log(new SalesReport().render());

Method abstract tidak punya isi; kalau kamu menulis isinya, muncul error TS1245 (Method 'x' cannot have an implementation because it is marked abstract). Abstract class juga tidak wajib punya member abstract sama sekali: abstract saja sudah cukup untuk mencegah class dibuat secara langsung.

Pola Template Method

Alasan paling umum untuk menulis abstract class: class dasar menetapkan urutan langkah, dan setiap subclass mengisi langkah yang berbeda-beda.

abstract class Importer<T> {
    // The algorithm lives here, once.
    import(raw: string): T[] {
        const lines = raw.trim().split("\n");
        const records = lines.map((line) => this.parse(line));
        return records.filter((r) => this.isValid(r));
    }

    protected abstract parse(line: string): T;

    // A default subclasses may override.
    protected isValid(_record: T): boolean {
        return true;
    }
}

type Person = { name: string; age: number };

class PersonImporter extends Importer<Person> {
    protected parse(line: string): Person {
        const [name, age] = line.split(",");
        return { name, age: Number(age) };
    }

    protected override isValid(p: Person): boolean {
        return !Number.isNaN(p.age);
    }
}

console.log(new PersonImporter().import("Ada,36\nBob,x\nCy,29"));
// [ { name: 'Ada', age: 36 }, { name: 'Cy', age: 29 } ]

Abstract class bisa generic, seperti di sini, sehingga setiap subclass memilih tipe record-nya sendiri.

Tipe Constructor Abstract

typeof Shape untuk abstract class adalah constructor yang tidak boleh kamu panggil, jadi parameter bertipe typeof Shape tidak bisa menjalankan new c(). Kalau sebuah fungsi perlu menerima abstract class (misalnya untuk mendaftarkannya atau memeriksa instanceof), beri tipe dengan abstract construct signature:

abstract class Animal {
    abstract sound(): string;
}
class Dog extends Animal {
    sound(): string {
        return "woof";
    }
}

type AbstractCtor<T> = abstract new (...args: never[]) => T;
type Ctor<T> = new () => T;

function isKind<T>(value: unknown, kind: AbstractCtor<T>): value is T {
    return value instanceof kind;
}

function create<T>(kind: Ctor<T>): T {
    return new kind();
}

const pet = create(Dog);     // fine: Dog is concrete
console.log(pet.sound());    // woof
console.log(isKind(pet, Animal), isKind("cat", Animal)); // true false
// create(Animal) is an error: Animal is abstract

abstract new menerima abstract class maupun class konkret; new biasa hanya menerima class konkret.

Abstract Class vs Interface

Patokannya: pakai interface kalau kamu hanya perlu mendeskripsikan bentuk (kasus paling umum, dan juga berlaku untuk object literal), pakai abstract class kalau subclass berbagi implementasi sungguhan dan kamu ingin compiler memaksa mereka mengisi bagian yang kosong. Keduanya bisa digabung dengan baik: interface untuk kontrak publik, abstract class sebagai satu class dasar praktis yang mengimplementasikannya. Lihat interface vs type untuk perbandingan umum lainnya.

Kesalahan Umum

• Memakai abstract class padahal interface sudah cukup. Kalau class dasar tidak berisi kode, itu sebenarnya interface dengan beban runtime tambahan dan batasan pewarisan tunggal.
• Mencoba static abstract. Tidak diizinkan. Member static tidak bisa abstract.
• Mengira new pada abstract class menghasilkan error saat runtime. Tidak ada error, kecuali kamu menulis pemeriksaan new.target.
• Memanggil method abstract dari constructor class dasar. Method itu berjalan sebelum field milik subclass diinisialisasi, jadi implementasinya melihat field tersebut sebagai undefined.