Clases abstractas en TypeScript: métodos, propiedades e interfaces

Una clase abstracta es una clase base marcada como abstract. No se puede crear con new, y puede declarar métodos abstract sin cuerpo, que cada subclase debe implementar.

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 comparte describe() con todas las subclases y obliga a cada una a aportar area(). El tipo Shape[] admite cualquier mezcla de subclases.

Una clase abstracta no se puede instanciar

Llamar a new sobre una clase abstracta es un error de compilación, porque el objeto tendría métodos sin implementación:

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

Es una regla en tiempo de compilación. abstract se borra de la salida, así que el Shape generado es una clase normal de JavaScript, y código JavaScript sin tipos podría seguir llamando a new Shape(). Cuando una librería necesita una protección en tiempo de ejecución, el constructor puede comprobar 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

Métodos y propiedades abstractos

Una subclase debe implementar todos los miembros abstractos, o ser abstracta a su vez. Si falta uno, es el error TS2515, que dice algo como Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape', o TS2654, que los enumera todos cuando faltan varios.

Los campos, los getters y los métodos pueden ser abstractos, y pueden ser 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());

Un método abstracto no tiene cuerpo; escribirle uno es el error TS1245 (Method 'x' cannot have an implementation because it is marked abstract). Una clase abstracta no tiene por qué tener ningún miembro abstracto: abstract por sí solo impide la instanciación directa.

El patrón template method

La razón más habitual para escribir una clase abstracta: la clase base fija el orden de los pasos, y cada subclase rellena los pasos que varían.

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

Las clases abstractas pueden ser genéricas, como aquí, para que cada subclase elija el tipo de registro.

Tipos de constructor abstractos

typeof Shape para una clase abstracta es un constructor que no se puede llamar, así que un parámetro de tipo typeof Shape no puede hacer new c(). Cuando una función debe aceptar clases abstractas (por ejemplo para registrarlas o comprobar instanceof), típala con una firma de construcción abstracta:

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 acepta clases abstractas y concretas; new a secas solo acepta las concretas.

Clase abstracta frente a interfaz

La regla práctica: una interfaz cuando solo necesitas describir una forma (el caso más habitual, y también funciona con objetos literales), una clase abstracta cuando las subclases comparten implementación real y quieres que el compilador las obligue a rellenar los huecos. Las dos se combinan bien: una interfaz para el contrato público y una clase abstracta como base práctica que la implementa. Consulta interface frente a type para la otra comparación habitual.

Errores habituales

• Usar una clase abstracta donde bastaría una interfaz. Si la clase base no tiene código, es una interfaz con peso extra en tiempo de ejecución y el límite de herencia única.
• Intentar static abstract. No está permitido. Los miembros estáticos no pueden ser abstractos.
• Esperar un error en tiempo de ejecución al hacer new sobre una clase abstracta. No lo hay, salvo que escribas la comprobación de new.target.
• Llamar a un método abstracto desde el constructor base. Se ejecuta antes de que se inicialicen los campos de la subclase, así que la implementación los ve como undefined.