How to fix Cannot extend non-abstract class with abstract members in TypeScript

What this error means

The "Cannot extend non-abstract class with abstract members" error appears when you create a regular class that extends an abstract class, but you don't provide implementations for all the abstract methods or properties defined in the base class. Abstract classes in TypeScript serve as blueprints that define a contract. When you mark a method or property as abstract, you're declaring that any concrete (non-abstract) subclass must provide its own implementation. If a class extends an abstract class without implementing all abstract members, TypeScript raises this error to enforce the contract. This is a fundamental principle of object-oriented programming: abstract members exist to ensure that all concrete instances have the required functionality. TypeScript enforces this at compile time, preventing runtime errors where you might try to call a method that doesn't exist. The error typically manifests as "Non-abstract class 'ClassName' does not implement inherited abstract member 'methodName' from class 'BaseClassName'." This clearly identifies which abstract members are missing implementations.

Typical symptoms

• Compilation fails with 'Non-abstract class does not implement inherited abstract member'
• Error code TS2515 appears in TypeScript output
• IDE shows red underlines on the class declaration extending the abstract class
• Error message specifically names the missing abstract method or property
• Code worked in JavaScript but breaks when adding TypeScript types
• Multiple errors if several abstract members are unimplemented

Common causes

1. Forgot to implement one or more abstract methods from the parent class
2. Implemented the method but with incorrect signature (wrong name, parameters, or return type)
3. Typo in method name - implementation doesn't match the abstract declaration exactly
4. Class extends abstract base but was not meant to be concrete yet
5. Abstract property declared in base class but not assigned in derived class
6. Added new abstract member to base class but didn't update all subclasses
7. Case sensitivity mismatch in method names between declaration and implementation

How to fix "Cannot extend non-abstract class with abstract members"

// Example error message:
// Non-abstract class 'Dog' does not implement inherited
// abstract member 'makeSound' from class 'Animal'

abstract class Animal {
  abstract makeSound(): string;
  abstract age: number;
}

// This will cause the error:
class Dog extends Animal {
  // Missing: makeSound() and age
}

abstract class Animal {
  abstract makeSound(): string;
  abstract move(distance: number): void;
}

// CORRECT - All abstract methods implemented
class Dog extends Animal {
  makeSound(): string {
    return "Woof!";
  }

  move(distance: number): void {
    console.log(`Dog moved ${distance} meters`);
  }
}

// Now you can instantiate:
const dog = new Dog();
console.log(dog.makeSound()); // "Woof!"
dog.move(10);

abstract class Vehicle {
  abstract wheels: number;
  abstract readonly brand: string;
}

// CORRECT implementation
class Car extends Vehicle {
  wheels: number = 4;
  readonly brand: string = "Toyota";

  // Or initialize in constructor:
  constructor(brand: string) {
    super();
    this.brand = brand;
  }
}

// WRONG - missing property implementations
class Motorcycle extends Vehicle {
  wheels: number = 2;
  // Error: missing 'brand' property
}

abstract class Shape {
  abstract calculateArea(): number;
  abstract draw(context: CanvasRenderingContext2D): void;
}

// WRONG - signature mismatch
class Circle extends Shape {
  // Wrong return type (void instead of number)
  calculateArea(): void {
    console.log("Calculating...");
  }

  // Wrong parameter type
  draw(context: any): void {
    // ...
  }
}

// CORRECT - signatures match
class Rectangle extends Shape {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    super();
    this.width = width;
    this.height = height;
  }

  calculateArea(): number {
    return this.width * this.height;
  }

  draw(context: CanvasRenderingContext2D): void {
    context.fillRect(0, 0, this.width, this.height);
  }
}

abstract class Animal {
  abstract makeSound(): string;
  abstract eat(food: string): void;
}

// Intermediate abstract class - doesn't implement everything
abstract class Mammal extends Animal {
  // Implements only one abstract member
  eat(food: string): void {
    console.log(`Eating ${food}`);
  }

  // makeSound() still abstract - concrete subclasses must implement
}

// Now concrete class only needs to implement remaining abstract members
class Cat extends Mammal {
  makeSound(): string {
    return "Meow";
  }
  // eat() is inherited from Mammal
}

const cat = new Cat();
cat.eat("fish");           // From Mammal
console.log(cat.makeSound()); // From Cat

abstract class Base {
  abstract process(): void;

  // Non-abstract method
  initialize(): void {
    console.log("Initializing...");
  }
}

class Derived extends Base {
  // Implementing abstract method
  override process(): void {
    console.log("Processing...");
  }

  // Overriding non-abstract method
  override initialize(): void {
    super.initialize();
    console.log("Extra initialization");
  }
}

{
  "compilerOptions": {
    "noImplicitOverride": true
  }
}

Advanced notes

abstract class AbstractLogger {
  protected logLevel: string = "info";

  abstract log(message: string): void;

  // Concrete helper method
  formatMessage(msg: string): string {
    return `[${this.logLevel}] ${msg}`;
  }
}

interface ILogger {
  log(message: string): void;
  level: string;
}

abstract class DataStore {
  // Abstract - must be implemented
  abstract connect(): Promise<void>;
  abstract disconnect(): Promise<void>;
  abstract query(sql: string): Promise<any>;

  // Concrete - shared across all implementations
  private isConnected: boolean = false;

  async ensureConnected(): Promise<void> {
    if (!this.isConnected) {
      await this.connect();
      this.isConnected = true;
    }
  }

  // Template method pattern
  async executeQuery(sql: string): Promise<any> {
    await this.ensureConnected();
    return this.query(sql);
  }
}

class PostgresStore extends DataStore {
  async connect(): Promise<void> {
    // Postgres-specific connection
  }

  async disconnect(): Promise<void> {
    // Postgres-specific disconnection
  }

  async query(sql: string): Promise<any> {
    // Postgres-specific query
  }

  // Inherits ensureConnected() and executeQuery()
}

abstract class Model {
  abstract id: number;

  // Abstract static method
  static abstract fromJSON(data: any): Model;

  // Regular abstract instance method
  abstract save(): Promise<void>;
}

class User extends Model {
  id: number;
  name: string;

  constructor(id: number, name: string) {
    super();
    this.id = id;
    this.name = name;
  }

  // Must implement static method
  static fromJSON(data: any): User {
    return new User(data.id, data.name);
  }

  // Must implement instance method
  async save(): Promise<void> {
    // Save logic
  }
}

// Usage:
const user = User.fromJSON({ id: 1, name: "Alice" });
await user.save();

abstract class Component {
  protected props: any;

  constructor(props: any) {
    this.props = props;
  }

  abstract render(): HTMLElement;
}

class Button extends Component {
  // Must call super() with props
  constructor(props: any) {
    super(props);
  }

  render(): HTMLElement {
    const button = document.createElement("button");
    button.textContent = this.props.label;
    return button;
  }
}

abstract class Factory<T> {
  abstract create(): T;

  createMultiple(count: number): T[] {
    return Array(count).fill(null).map(() => this.create());
  }
}

class UserFactory extends Factory<User> {
  create(): User {
    return new User(
      Math.random(),
      `User${Math.floor(Math.random() * 1000)}`
    );
  }
}

const factory = new UserFactory();
const users: User[] = factory.createMultiple(5);

Frequently asked questions

What does "TS2515" mean?

The "Cannot extend non-abstract class with abstract members" error appears when you create a regular class that extends an abstract class, but you don't provide implementations for all the abstract methods or properties defined in the base class. Abstract classes in TypeScript serve as blueprints that define a contract. When you mark a method or property as abstract, you're declaring that any concrete (non-abstract) subclass must provide its own implementation.

How do I fix "TS2515"?

This TypeScript error occurs when a non-abstract (concrete) class extends an abstract base class but fails to implement all abstract members. All classes that extend abstract classes must either implement every abstract method and property, or be declared abstract themselves.

What causes "TS2515"?

Forgot to implement one or more abstract methods from the parent class Implemented the method but with incorrect signature (wrong name, parameters, or return type) Typo in method name - implementation doesn't match the abstract declaration exactly

Is the "TS2515" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• Cannot extend with union type containing 'never'

  How to fix 'Cannot extend with union type containing never' in TypeScript

  MEDIUM

• Expression produces a union type that is too complex to represent

  Expression produces a union type that is too complex to represent

  MEDIUM

• src/index.ts is not under 'rootDir'

  How to fix 'file is not under rootDir' error in TypeScript

  MEDIUM

• This expression is not constructable

  How to fix 'This expression is not constructable' error in TypeScript

  MEDIUM

• Cannot find name 'process'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.

  How to fix "Cannot find name 'process'" in TypeScript

  MEDIUM

• Module has no exported member 'X'

  How to fix 'Module has no exported member X' error in TypeScript

  MEDIUM

Official resources & further reading

• 📚TypeScript Official Documentation
• 📖
  TypeScript Handbook - Classes(Official Docs)
• 📖
  TypeScript Handbook - Classes (Legacy)(Official Docs)
• Tutorial Teacher - TypeScript Abstract Class
• LogRocket - TypeScript Abstract Classes and Constructors
• Ultimate Courses - Abstract Classes in TypeScript
• 🐙
  TypeScript GitHub - Restrict abstract class type to non-abstract implementation(GitHub)
• TypeScript Tutorial - Abstract Classes