TypeScript Abstract Classes

TypeScript is a relatively strongly typed extension of JavaScript that incorporates contemporary object-oriented programming language characteristics into JavaScript. Additionally, it supports a concept known as abstract classes, which is crucial for developing well-structured, reusable, and scalable applications. This article will explore TypeScript abstract classes and abstract methods in detail, explaining their definitions, functionalities, and appropriate use cases. We will provide practical examples to ensure you gain a comprehensive understanding of the concept.

What is an Abstract Class?

In TypeScript, an abstract class can be viewed as a class that is inherently abstract and cannot be instantiated directly. It serves as a blueprint for other classes, mandating that the derived classes adhere to a particular structure.

Abstract classes can contain:

• ✅ Abstract methods: Methods which have no implementation and are to be implemented by the subclasses.
• ✅ Concrete methods: These are implemented methods which may be called by subclasses or can be overridden.
• ✅ Properties: An abstract class can also define properties (with or without values), just like other classes.

Conversely, the primary purpose of abstract classes is to establish a contract for subclasses, ensuring that all implementations remain consistent.

Syntax of Abstract Classes

Here's a simple example:

Example

abstract class Animal {
  abstract makeSound(): void;

  move(): void {
    console.log("Moving...");
  }
}

class Lion extends Animal {
  makeSound(): void {
    console.log("Roar");
  }
}

const myLion = new Lion();
myLion.makeSound(); 
myLion.move();

Output:

Roar
Moving...

Key Points:

• ✅ The Animal class has the abstract keyword.
• ✅ It has an abstract method makeSound without its body.
• ✅ Lion is a subclass of Animal and satisfies the contract of makeSound.
• ✅ You cannot create an instance of Animal directly.

Abstract Methods

An abstract method is defined without any implementation within an abstract class. If a subclass is not declared as abstract, it is required to provide implementations for all abstract methods.

Example

abstract class Shape {
  abstract getArea(): number;

  describe(): void {
    console.log("I am a shape.");
  }
}

class Square extends Shape {
  constructor(public side: number) {
    super();
  }

  getArea(): number {
    return this.side * this.side;
  }
}

const square = new Square(5);
console.log(square.getArea()); 
square.describe();

Output:

78.53981633974483
I am a shape.

The Shape class is an abstract class that defines the abstract method getArea and includes the concrete method describe, which provides information about the shape.

The Square class is derived from the Shape class, indicating that Square inherits characteristics from Shape. The constructor initializes a side property within the object.

The area of a square can be determined using the formula side x side. When a square is formed with a side length of 5, the getArea function computes the area of this square, while the describe function, inherited from the Shape class, outputs "I am a shape."

Abstract Constructors

To create more intricate factory patterns, it is beneficial to incorporate abstract constructors, a feature that TypeScript accommodates via interfaces and abstract classes.

Example

abstract class Vehicle {
  abstract startEngine(): void;
}

class truck extends Vehicle {
  startEngine(): void {
    console.log("Truck engine started");
  }
}

function createVehicle<T extends Vehicle>(VehicleConstructor: new () => T): T {
  return new VehicleConstructor();
}

const truck = createVehicle(Truck);
truck.startEngine();

Output:

Truck engine started

This approach is frequently employed in factory design patterns and dependency injection.

Why use Abstract Classes?

Let us explore various scenarios and reasons in which abstract classes are more advantageous:

1. Establishing a Standard Interface

Abstract classes mandate that their derived classes adhere to a unified API. This requirement proves beneficial in large-scale applications where multiple developers are engaged in various implementations that need to remain consistent.

1. Code Reuse

Abstract classes assist in reducing redundant code by enabling you to establish shared behavior (whether through concrete methods or properties) that can be utilized by various subclasses.

1. Layered Design

They help you establish a logical abstraction or hierarchy within your code, enhancing modularity and ease of maintenance.

Abstract Classes vs Interfaces

TypeScript has both abstract classes and interfaces, which can be used as a contract to enforce, but they do have some differences:

When to use which?

Utilize interfaces when your primary objective is to specify a shape or structure of data. In contrast, abstract classes should be employed when you aim to offer a default behavior alongside the contract, as abstract classes allow for both the definition and a partial implementation.

Limitations

Despite their usefulness, abstract classes come with certain warnings:

• ✅ Single Inheritance: TypeScript classes can extend only one class even it is an abstract class.
• ✅ Cannot Enforce Multiple Behaviors: You cannot use an abstract class to enforce multiple contracts at the same time unlike interfaces .
• ✅ Inheritance Chains Can Become Complex: Violent abstract classes can cause some maintenance problems in the deep hierarchies.
• ✅ Cannot Instantiate: Abstract class cannot be instantiated which will give the compile time error.

Best Practices

To make the abstract class work for you in TypeScript, do this:

• ✅ Keep abstractions minimal: Do not use abstract classes to implement too much logic. Keep them focused.
• ✅ Use interfaces for multiple contracts: If you want a class to fit multiple unrelated contracts, you should prefer an interface.
• ✅ Document abstract methods: Provide meaning and expectations for abstract methods.
• ✅ Favor composition over inheritance: Sticking to class inheritance may be overkill. Think composition when appropriate.
• ✅ Avoid deep inheritance trees: Flatten your class hierarchies as much as possible to make the code base maintainable.

Conclusion

Abstract classes in TypeScript offer a significant enhancement to a developer's resources for engaging with object-oriented design principles. They promote adherence to API standards, enable code reuse, and deliver an organized framework for constructing intricate applications. Gaining knowledge about abstract classes aids in creating robust and adaptable systems. You may discover abstract classes advantageous when developing a UI library, data models, or application architecture.