Chapter Introduction: OOP in TypeScript

Object-oriented programming (OOP) is a powerful paradigm that allows us to model our applications in a way that is intuitive and closer to the real world. With TypeScript, we can harness the full power of OOP, taking advantage of its static typing and advanced features. In this chapter, we'll explore the fundamental concepts of OOP as they pertain to TypeScript, paving the way for more in-depth discussions on classes, interfaces, and beyond.

Understanding the Four Pillars of OOP

Before diving into TypeScript's implementation, let’s briefly review the four pillars of object-oriented programming: encapsulation, abstraction, inheritance, and polymorphism.

1. Encapsulation

Encapsulation is the principle of bundling the data (properties) and methods (functions) that operate on the data into a single unit, or class. This also naturally leads to restricting direct access to some of the object’s components.

In TypeScript, we can use access modifiers to enforce encapsulation. The three common access modifiers are:

public: Members are accessible from anywhere. This is the default modifier.
private: Members are only accessible within the class itself.
protected: Members are accessible within the class and by instances of derived classes.

Example of Encapsulation

class BankAccount {
    private balance: number;

    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }

    public deposit(amount: number): void {
        if (amount > 0) {
            this.balance += amount;
        }
    }

    public getBalance(): number {
        return this.balance;
    }
}

In this example, balance is a private property, encapsulated within the BankAccount class. The account balance can only be modified through the deposit method and can be accessed through the getBalance method, effectively controlling how changes are made.

2. Abstraction

Abstraction is about hiding complex implementation details and showing only the essential features of an object. This helps reduce complexity and allows the developer to focus on interactions at a higher level.

TypeScript supports abstraction through the use of abstract classes and interfaces. An abstract class can define methods that must be implemented in derived classes, while interfaces can specify how different classes should engage without dictating how they achieve that.

Example of Abstraction with Interfaces

interface Shape {
    area(): number;
}

class Circle implements Shape {
    constructor(private radius: number) {}
    
    area(): number {
        return Math.PI * Math.pow(this.radius, 2);
    }
}

class Rectangle implements Shape {
    constructor(private width: number, private height: number) {}

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

In this code, the Shape interface dictates that any shape must implement an area method, allowing for polymorphic behavior while hiding the specifics of each shape's area calculation.

3. Inheritance

Inheritance is a mechanism in which one class can inherit properties and methods from another, promoting code reuse and establishing a relationship between classes. Subclasses can override methods or properties of their superclass, enabling a tailored behavior while still retaining the base functionality.

TypeScript supports inheritance using the extends keyword.

Example of Inheritance

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

    makeSound(): string {
        return 'Some generic sound';
    }
}

class Dog extends Animal {
    makeSound(): string {
        return `${this.name} says Woof!`;
    }
}

const myDog = new Dog('Rex');
console.log(myDog.makeSound()); // Outputs: Rex says Woof!

Here, the Dog class inherits from the Animal class, overriding the makeSound method. This allows us to define specific behavior while maintaining a general structure.

4. Polymorphism

Polymorphism allows us to use a unified interface for different data types. It lets us define methods in a base class that can be overridden in derived classes, enabling an application to process objects differently based on their data type or class.

TypeScript achieves polymorphism through method overriding. Also, we can use interfaces to create polymorphic behaviors.

Example of Polymorphism

function printSound(animal: Animal): void {
    console.log(animal.makeSound());
}

const myDog = new Dog('Buddy');
const myAnimal = new Animal('Generic Animal');

printSound(myDog);      // Outputs: Buddy says Woof!
printSound(myAnimal);   // Outputs: Some generic sound

In this case, the printSound function takes an Animal parameter, allowing it to process both Dog and Animal objects seamlessly.

Classes and Interfaces in Depth

To further our understanding of how OOP principles can be applied in TypeScript, we will now look closely at classes and interfaces.

Classes

A class in TypeScript can contain properties and methods, with support for both static and instance members. When defining a class, we can specify types for each property and method, ensuring type safety.

Class Example

class Car {
    private currentSpeed: number = 0;

    constructor(private make: string, private model: string) {}

    public accelerate(speed: number): void {
        this.currentSpeed += speed;
        console.log(`Accelerating to ${this.currentSpeed} km/h`);
    }

    public getInfo(): string {
        return `${this.make} ${this.model}`;
    }
}

In this Car class, we not only define properties but also encapsulate behavior in methods. The private modifier restricts access to the currentSpeed property, while methods provide controlled interaction with class instances.

Interfaces

Interfaces serve as contracts for classes, specifying what properties and methods a class should implement. Using interfaces fosters a more decoupled design and is a fundamental part of TypeScript's type system.

Interface Example

interface Vehicle {
    accelerate(speed: number): void;
    getInfo(): string;
}

class Bicycle implements Vehicle {
    constructor(private model: string) {}

    public accelerate(speed: number): void {
        console.log(`Bicycle is accelerating to ${speed} km/h`);
    }

    public getInfo(): string {
        return `Bicycle model: ${this.model}`;
    }
}

By implementing the Vehicle interface, the Bicycle class must provide definitions for the accelerate and getInfo methods. This ensures that all vehicles adhere to a consistent interface, allowing us to write type-safe code that is easy to maintain.

Conclusion

As we wrap up this chapter, we’ve laid the groundwork for understanding how the principles of object-oriented programming are manifest in TypeScript. By embracing OOP concepts such as encapsulation, abstraction, inheritance, and polymorphism, you are well-prepared to dive deeper into the practical applications of classes and interfaces in TypeScript.

In the next chapters, we will delve into specific implementations of these concepts, exploring how to create robust, scalable applications that harness the full potential of TypeScript's powerful features. Get ready to transform your programming approach as we embark on this exciting journey into the world of object-oriented programming in TypeScript!

Programming - TypeScript