TypeScript Abstract Class: Metotlar, Özellikler ve Interface Farkı

Abstract class, abstract olarak işaretlenmiş bir temel sınıftır. new ile oluşturulamaz ve gövdesi olmayan abstract metotlar bildirebilir; bunları her alt sınıf implement etmek zorundadır.

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, describe() metodunu her alt sınıfla paylaşır ve her birini area() metodunu sağlamaya zorlar. Shape[] tipi alt sınıfların her türlü karışımını tutabilir.

Abstract Class'ın Örneği Oluşturulamaz

Bir abstract class üzerinde new çağırmak bir derleme hatasıdır, çünkü ortaya çıkan nesnenin implementasyonu olmayan metotları olurdu:

// 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.

Bu bir derleme zamanı kuralıdır. abstract çıktıdan silinir, bu yüzden üretilen Shape sıradan bir JavaScript sınıfıdır ve tipsiz JavaScript kodu yine de new Shape() çağırabilir. Bir kütüphanenin çalışma zamanında bir korumaya ihtiyacı olduğunda constructor new.target değerini kontrol edebilir:

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

Abstract Metotlar ve Özellikler

Bir alt sınıf her abstract üyeyi implement etmek ya da kendisi abstract olmak zorundadır. Birini eksik bırakmak, Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape' gibi okunan TS2515 hatasıdır; birkaç üye eksikse hepsini listeleyen TS2654 hatası gelir.

Alanlar, getter'lar ve metotların hepsi abstract olabilir ve protected olabilir:

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());

Bir abstract metodun gövdesi yoktur; gövde yazmak TS1245 hatasıdır (Method 'x' cannot have an implementation because it is marked abstract). Bir abstract class'ın hiç abstract üyesi olmak zorunda değildir: tek başına abstract yalnızca doğrudan örnek oluşturmayı engeller.

Template Method Kalıbı

Abstract class yazmanın en yaygın nedeni: temel sınıf adımların sırasını sabitler, her alt sınıf da değişen adımları doldurur.

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 } ]

Buradaki gibi abstract class'lar generic olabilir; böylece her alt sınıf kayıt tipini kendisi seçer.

Abstract Constructor Tipleri

Bir abstract class için typeof Shape, çağırmanıza izin verilmeyen bir constructor'dır; bu yüzden typeof Shape olarak tiplenmiş bir parametre new c() yapamaz. Bir fonksiyonun abstract class'ları kabul etmesi gerektiğinde (örneğin onları kaydetmek ya da instanceof kontrolü yapmak için), onu abstract bir construct imzasıyla tipleyin:

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 hem abstract hem de somut sınıfları kabul eder; düz new ise yalnızca somut olanları kabul eder.

Abstract Class ve Interface

Genel kural: yalnızca bir biçimi tarif etmeniz gerekiyorsa interface (en yaygın durum ve nesne literalleri için de çalışır), alt sınıflar gerçek bir implementasyonu paylaşıyorsa ve derleyicinin onları boşlukları doldurmaya zorlamasını istiyorsanız abstract class. İkisi iyi birleşir: public sözleşme için bir interface, onu implement eden kullanışlı bir temel olarak da bir abstract class. Diğer yaygın karşılaştırma için interface ve type sayfasına bakın.

Sık Yapılan Hatalar

• Bir interface'in yeteceği yerde abstract class kullanmak. Temel sınıfın hiç kodu yoksa, fazladan çalışma zamanı yükü ve tekli kalıtım sınırı olan bir interface'ten farkı yoktur.
• static abstract denemek. İzin verilmez. Statik üyeler abstract olamaz.
• Abstract class üzerinde new kullanıldığında çalışma zamanı hatası beklemek. new.target kontrolünü siz yazmadıkça hata yoktur.
• Temel constructor'dan abstract bir metot çağırmak. Bu çağrı alt sınıfın alanları başlatılmadan önce çalışır, bu yüzden implementasyon onları undefined olarak görür.