Inheritance in TypeScript

Inheritance is a core concept in object-oriented programming (OOP) that allows a class to inherit properties and methods from another class. TypeScript, being a superset of JavaScript, supports inheritance using the extends keyword. This allows for the creation of a new class based on an existing class, enabling code reuse and extending functionality.

 

Key Points About Inheritance:

1. Base class (superclass): The class whose properties and methods are inherited.
2. Derived class (subclass): The class that inherits properties and methods from the base class.
3. The derived class can add new properties and methods or override existing ones from the base class.

 

Inheriting from a Class

In TypeScript, a class can extend another class using the extends keyword. This allows the derived class to access all public and protected members (properties and methods) of the base class.

Example:

class Animal {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  speak(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  breed: string;

  constructor(name: string, breed: string) {
    super(name);  // Calling the constructor of the base class (Animal)
    this.breed = breed;
  }

  speak(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy", "Golden Retriever");
dog.speak();  // Output: Buddy barks.

In this example:

• The Dog class extends the Animal class and inherits its name property and speak() method.
• The Dog class also overrides the speak() method to provide specific functionality for dogs.

The super Keyword

The super keyword is used to call the constructor and methods of the base class. It must be called in the constructor of the derived class to access the constructor of the base class.

Example:

class Animal {
  constructor(public name: string) {}

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Cat extends Animal {
  constructor(name: string) {
    super(name);  // Calls the constructor of the Animal class
  }

  speak() {
    console.log(`${this.name} meows.`);
  }
}

const cat = new Cat("Whiskers");
cat.speak();  // Output: Whiskers meows.

In this example:

• The Cat class calls the super(name) constructor to pass the name parameter to the Animal class constructor.
• The speak() method is overridden in the Cat class to provide specific functionality for cats.

Access Modifiers and Inheritance

When you inherit from a class, you can access its properties and methods based on their access modifiers:

• public: Accessible everywhere, including in the derived class.
• protected: Accessible within the class and its subclasses.
• private: Not accessible outside the class, not even in the derived class.

Example:

class Animal {
  public name: string;
  protected species: string;
  private age: number;

  constructor(name: string, species: string, age: number) {
    this.name = name;
    this.species = species;
    this.age = age;
  }

  public greet(): void {
    console.log(`Hello, I am a ${this.species} named ${this.name}.`);
  }
}

class Dog extends Animal {
  constructor(name: string, species: string, age: number) {
    super(name, species, age);
  }

  // Accessing protected member 'species'
  getSpecies(): string {
    return this.species;
  }

  // The following line would cause an error because 'age' is private
  // getAge(): number {
  //   return this.age;  // Error: Property 'age' is private and only accessible within class 'Animal'.
  // }
}

const dog = new Dog("Buddy", "Golden Retriever", 5);
dog.greet();  // Output: Hello, I am a Golden Retriever named Buddy.
console.log(dog.getSpecies());  // Output: Golden Retriever

In this example:

• The species property is protected, so it can be accessed in the Dog class, but the age property is private and cannot be accessed directly in the derived class.

Method Overriding

In TypeScript, a derived class can override methods of the base class. To do this, the method in the derived class must have the same name and signature as the method in the base class. If the method in the base class is marked as virtual (by convention, though TypeScript does not have the virtual keyword), the derived class can override it.

Example:

class Animal {
  speak(): void {
    console.log("The animal makes a sound.");
  }
}

class Dog extends Animal {
  speak(): void {
    console.log("The dog barks.");
  }
}

class Cat extends Animal {
  speak(): void {
    console.log("The cat meows.");
  }
}

const dog = new Dog();
const cat = new Cat();

dog.speak();  // Output: The dog barks.
cat.speak();  // Output: The cat meows.

In this example:

• Both the Dog and Cat classes override the speak() method to provide their own implementation.

 

Summary

Inheritance in TypeScript allows classes to share functionality and behavior through the extends keyword. Key points include:

• Base and derived classes: A derived class inherits properties and methods from a base class.
• The super keyword: Used to call the constructor and methods of the base class.
• Access modifiers: Public, protected, and private members have different accessibilities in the derived class.
• Method overriding: Derived classes can override base class methods to provide specialized behavior.

Inheritance helps improve code reuse, maintainability, and organization, making it an essential concept in object-oriented programming.