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

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