Typescript Implementing Interfaces In Classes Complete Guide

Top 10 Questions and Answers: Implementing Interfaces in Classes with TypeScript

An interface in TypeScript is a contract that defines a structure or blueprint for objects. It declares the syntax for classes to follow, detailing the properties and methods a class must implement. Interfaces are not compiled into JavaScript; rather, they are used during development to provide type-checking and a better development experience.

When a class implements an interface, it must adhere to the structure defined by that interface, ensuring consistency across classes that perform similar functionalities.

2. How do you implement an interface in a TypeScript class?

To implement an interface in a TypeScript class, use the implements keyword followed by the name of the interface. For example:

interface Animal {
    name: string;
    makeSound(): void;
}

class Dog implements Animal {
    name: string;

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

    makeSound() {
        console.log("Woof woof!");
    }
}

In this example, the Dog class implements the Animal interface, providing an implementation for the name property and the makeSound method.

3. Can a single class implement multiple interfaces?

Yes, a class can implement multiple interfaces by separating the interface names with commas. For example:

interface Serializable {
    serialize(): string;
}

interface Comparable <T> {
    compare(other: T): number;
}

class MyClass implements Serializable, Comparable<MyClass> {
    serialize() {
        return JSON.stringify(this);
    }

    compare(other: MyClass): number {
        // comparison logic...
        return 0;
    }
}

Here, the MyClass class implements both Serializable and Comparable interfaces.

4. What happens if a class does not implement all the methods and properties of an interface?

If a class does not implement all the required methods and properties of an interface, TypeScript will raise a compile-time error, indicating which members are missing. This ensures that the class correctly adheres to the contract defined by the interface, providing a robust and error-free codebase.

5. Can an interface extend another interface?

Yes, an interface can inherit from one or more other interfaces using the extends keyword, similar to classes. Interfaces can also extend multiple interfaces. For example:

interface Flying {
    fly(): void;
}

interface Swimmer {
    swim(): void;
}

interface Duck extends Flying, Swimmer {}

class Mallard implements Duck {
    fly() {
        console.log("Flying...");
    }

    swim() {
        console.log("Swimming...");
    }
}

The Duck interface extends both Flying and Swimmer, and any class that implements Duck must provide implementations for both fly and swim methods.

6. Can methods in an interface have default implementations?

No, methods in an interface cannot have default implementations. Interfaces in TypeScript are purely abstract and can only contain declarations for properties, methods, and event handlers, without providing any implementation. This differs from abstract classes, which allow both declarations and default implementations.

7. Are properties in an interface always optional?

No, unless explicitly specified as optional using the ? symbol, properties in an interface are considered mandatory. For example:

interface Point {
    x: number;
    y?: number; // optional property
}

Here, x is required, while y is optional. Attempting to create an object that doesn't provide a value for x will result in a compile-time error.

8. How can you implement an interface with methods that have complex behavior involving other methods?

When implementing an interface with dependent methods, you can define the required methods in the class, even if their behavior relies on other methods. Here's an example:

interface Vehicle {
    startEngine(): void;
    stopEngine(): void;
    move(): void;
}

class Car implements Vehicle {
    private engineRunning: boolean = false;

    startEngine() {
        if (!this.engineRunning) {
            console.log("Engine started.");
            this.engineRunning = true;
        }
    }

    stopEngine() {
        if (this.engineRunning) {
            console.log("Engine stopped.");
            this.engineRunning = false;
        }
    }

    move() {
        if (this.engineRunning) {
            console.log("Car is moving.");
        } else {
            console.error("Engine must be started before moving.");
        }
    }
}

In this example, the move method's behavior depends on whether the engine is running, which is managed by startEngine and stopEngine methods.

9. Can interfaces be used with other TypeScript features like generics and enums?

Yes, interfaces can be used with generics and enums in TypeScript. This allows you to create flexible and reusable code patterns. For example:

enum Status {
    Active,
    Inactive
}

interface User<T> {
    id: number;
    name: string;
    status: T;
}

class PremiumUser implements User<Status> {
    id: number;
    name: string;
    status: Status;

    constructor(id: number, name: string, status: Status) {
        this.id = id;
        this.name = name;
        this.status = status;
    }
}

In this example, the User interface is generic and can be parameterized with different types, such as the Status enum, when implementing the PremiumUser class.

10. What is the difference between interfaces and abstract classes in TypeScript?

Interfaces and abstract classes serve similar purposes, but they have some key differences:

• Interfaces: Cannot contain implementation details. They are purely abstract and can only define method signatures and property declarations without providing any concrete implementations.

• Abstract Classes: Can contain both abstract (unimplemented) and concrete (implemented) methods. Abstract classes cannot be instantiated directly and are meant to be inherited by other classes.

For example, an interface could represent a contract that classes need to follow, while an abstract class could provide some common functionality that derived classes can build upon.