Abstract Method

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

abstract class BaseClass {
    // Abstract method declaration: abstract keyword, no implementation body
    abstract methodName(param: string): number;
    
    // Abstract classes can still contain implemented methods
    standardMethod(): void {
        console.log("Implemented in base class");
    }
}

class ConcreteClass extends BaseClass {
    // Mandatory implementation of the abstract method
    override methodName(param: string): number {
        return param.length;
    }
}

​

Technical Characteristics

• Enclosure Requirement: Abstract methods can only exist inside classes that are explicitly prefixed with the abstract keyword. Attempting to declare an abstract method in a standard class will result in a compiler error.
• Declaration Structure: The declaration must include the abstract keyword, optional access modifiers, the method name, and parameters. While the return type is syntactically optional in loose configurations, modern TypeScript environments with strict (or noImplicitAny) enabled require an explicit return type to prevent compiler error TS7010. The declaration must end with a semicolon rather than an implementation block.
• Modifier Restrictions: The abstract modifier cannot be combined with the static modifier. Attempting to do so produces compiler error TS1243 ('abstract' modifier cannot be used with 'static' modifier). Additionally, abstract methods cannot be combined with the async modifier, as async dictates implementation behavior rather than signature structure (to enforce asynchronous behavior, specify a Promise return type instead).
• Access Modifiers: Abstract methods can be declared as public or protected. They cannot be declared as private, as the derived class must be able to access and implement the method.
• Signature Compatibility and Variance: The TypeScript compiler enforces structural compatibility for the overriding method.
  • Return Types: The concrete method can be covariant in its return type (returning a narrower, more specific type than the abstract signature).
  • Parameters: Using standard method syntax, TypeScript parameters are bivariant. This means a derived class is permitted by the compiler to narrow or widen the parameter types. To enforce strict contravariance (requiring the derived class to accept identical or wider types, preventing unsafe narrowing), the abstract member must be defined using function property syntax combined with the strictFunctionTypes compiler option. Parameters can also be safely omitted in the implementation.
• The override Keyword: When implementing an abstract method, it is standard practice to use the override keyword. This instructs the compiler to verify that the method actually overrides a base class member. It is strictly required if the noImplicitOverride compiler option is enabled in tsconfig.json.
• Implementation Deferral: If a derived class is also declared as abstract, it is not required to implement the inherited abstract methods. The compile-time obligation to implement them propagates down the class inheritance hierarchy until a concrete class is defined.
• Runtime Erasure: Abstract methods do not exist at runtime. They leave no trace on the JavaScript prototype chain, functioning purely as a design-time enforcement mechanism.

abstract class LevelOne {
    // Standard method syntax: parameters are bivariant
    protected abstract process(data: string | number): void;
    
    // Function property syntax: parameters are strictly contravariant (with strictFunctionTypes)
    abstract strictProcess: (data: string | number) => void;
    
    // Cannot use static:
    // abstract static init(): void; // Compiler Error TS1243
    
    // Cannot use async (async is an implementation detail):
    // abstract async fetch(): Promise<void>; // Compiler Error
    
    abstract getConfig(): { id: string };
}

// Valid: LevelTwo is abstract, so it defers the implementation down the hierarchy
abstract class LevelTwo extends LevelOne {
    abstract validate(): boolean;
}

// Valid: LevelThree is concrete, so it must implement ALL inherited abstract members
class LevelThree extends LevelTwo {
    // Bivariant parameter: TS allows narrowing 'string | number' to 'string' using standard method syntax
    protected override process(data: string): void {
        console.log(data.toUpperCase());
    }

    // Contravariant parameter: must accept 'string | number' or wider (e.g., 'unknown')
    // Narrowing to 'string' here would cause a compiler error under strictFunctionTypes
    override strictProcess = (data: unknown): void => {
        console.log(String(data));
    };

    override validate(): boolean {
        return true;
    }

    override getConfig(): { id: string; name: string } {
        // Covariant return type: returning a narrower/more specific object
        return { id: "123", name: "Production" };
    }
}