TypeScript Abstract Class: Methods, Properties, vs Interface

An abstract class is a base class marked abstract. It cannot be created with new, and it can declare abstract methods that have no body, which every subclass must implement.

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 shares describe() with every subclass and forces each one to supply area(). The type Shape[] holds any mix of subclasses.

An Abstract Class Cannot Be Instantiated

Calling new on an abstract class is a compile error, because the object would have methods with no implementation:

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

This is a compile-time rule. abstract is erased from the output, so the emitted Shape is an ordinary JavaScript class, and untyped JavaScript code could still call new Shape(). When a library needs a runtime guard, the constructor can check 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

Abstract Methods and Properties

A subclass must implement every abstract member, or be abstract itself. Missing one is error TS2515, which reads like Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape', or TS2654 listing all of them when several are missing.

Fields, getters and methods can all be abstract, and they can be 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());

An abstract method has no body; writing one is error TS1245 (Method 'x' cannot have an implementation because it is marked abstract). An abstract class does not have to have any abstract members at all: abstract on its own just prevents direct instantiation.

The Template Method Pattern

The most common reason to write an abstract class: the base class fixes the order of the steps, and each subclass fills in the steps that vary.

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 classes can be generic, as here, so each subclass picks the record type.

Abstract Constructor Types

typeof Shape for an abstract class is a constructor you are not allowed to call, so a parameter typed typeof Shape cannot do new c(). When a function should accept abstract classes (for example to register them or check instanceof), type it with an 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 accepts both abstract and concrete classes; plain new accepts only concrete ones.

Abstract Class vs Interface

The rule of thumb: an interface when you only need to describe a shape (the most common case, and it works for object literals too), an abstract class when subclasses share real implementation and you want the compiler to force them to fill in the gaps. The two combine well: an interface for the public contract, an abstract class as one convenient base that implements it. See interfaces vs types for the other common comparison.

Common Mistakes

• Using an abstract class where an interface would do. If the base class has no code, it is an interface with extra runtime weight and a single-inheritance limit.
• Trying static abstract. Not allowed. Static members cannot be abstract.
• Expecting a runtime error from new on an abstract class. There is none unless you write the new.target check.
• Calling an abstract method from the base constructor. It runs before the subclass's fields are initialized, so the implementation sees them as undefined.