What are the types of inheritance classified in TypeScript?

In TypeScript, inheritance is a mechanism that allows us to create new classes based on an existing class, which is referred to as a child class. This child class inherits properties and methods from another class (referred to as the parent class). TypeScript supports several forms of inheritance, primarily as follows:

1. Single Inheritance

Single inheritance is the most common form, where a child class inherits from only one parent class. This approach is intuitive, easy to manage, and understand, and it is a standard practice in most object-oriented programming languages.

Example:

typescript
class Animal {
    eat() {
        console.log("Eating");
    }
}

class Dog extends Animal {
    bark() {
        console.log("Barking");
    }
}

let dog = new Dog();
dog.eat(); // calling methods inherited from Animal
dog.bark(); // calling Dog's own methods

2. Multiple Inheritance

TypeScript does not natively support inheriting properties and methods from multiple classes (i.e., multiple inheritance), but it can emulate this functionality through interfaces. Interfaces can extend multiple interfaces, and classes can implement multiple interfaces.

Example:

typescript
interface CanFly {
    fly(): void;
}

interface CanSwim {
    swim(): void;
}

class Bird implements CanFly {
    fly() {
        console.log("Flying");
    }
}

class Fish implements CanSwim {
    swim() {
        console.log("Swimming");
    }
}

class Duck implements CanFly, CanSwim {
    fly() {
        console.log("Duck flying");
    }
    swim() {
        console.log("Duck swimming");
    }
}

let duck = new Duck();
duck.fly();   // implementing methods from CanFly interface
duck.swim();  // implementing methods from CanSwim interface

3. Abstract Class Inheritance

Abstract classes are special classes that cannot be instantiated and serve as base classes for other classes. Abstract methods can be defined in these classes, which must be implemented in derived classes.

Example:

typescript
abstract class Vehicle {
    abstract move(): void; // abstract method that derived classes must implement
}

class Car extends Vehicle {
    move() {
        console.log("Car is moving");
    }
}

let car = new Car();
car.move(); // implementing the abstract method from Vehicle

Through these inheritance mechanisms, TypeScript provides flexible ways to reuse code and create structured object-oriented programs. Each mechanism has specific use cases and trade-offs, and selecting the appropriate approach can enhance code clarity and maintainability.