> ## 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. # TypeScript Abstract Method An abstract method in TypeScript is a method signature declared within an abstract class that lacks an implementation body. It serves as a strict compile-time structural contract, mandating that any concrete (non-abstract) subclass inheriting from the base class must provide the explicit implementation for that method. Because they are a TypeScript-only type-checking construct, abstract methods are entirely erased during compilation and emit no JavaScript code. ```typescript theme={"dark"} 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. ```typescript theme={"dark"} 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; // 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" }; } } ```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping! Learn More