What are the differences between the classes and the interfaces in TypeScript?

In TypeScript, Classes and Interfaces are crucial concepts that play a key role in structuring large applications. Below, I will elaborate on their main differences:

1. Definition and Purpose

Interfaces:

• Interfaces are primarily used to define the structure of an object, specifying which properties and methods it should have without providing implementations for those methods.
• In TypeScript, interfaces are a powerful way to define type specifications and contracts, commonly used to enforce specific structures.

Classes:

• Classes serve as concrete blueprints for objects, defining both properties and methods while providing implementations for those methods.
• Classes can be instantiated to create object instances.
• Classes support inheritance, allowing them to extend the functionality of other classes.

2. Implementation Approach

Interfaces:

• Interfaces only define the signatures of properties and methods without including actual implementations.
• For example, an interface might declare a getName method but does not implement it.

typescript
interface Person {
    name: string;
    getName(): string;
}

Classes:

• Classes implement all properties and methods they declare.
• Classes can implement one or more interfaces and must implement all methods defined in the interfaces.

typescript
class Employee implements Person {
    name: string;

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

    getName(): string {
        return this.name;
    }
}

3. Multiple Inheritance and Extension

Interfaces:

• Interfaces support multiple inheritance, meaning an interface can inherit from multiple interfaces.

typescript
interface NamedEntity {
    name: string;
}

interface Loggable {
    log(): void;
}

interface User extends NamedEntity, Loggable {
    getLastAccess(): Date;
}

Classes:

• Classes do not support multiple inheritance; a class can inherit from only one other class but can implement multiple interfaces.

typescript
class Admin extends Employee implements User {
    getLastAccess(): Date {
        return new Date();
    }

    log(): void {
        console.log(this.name);
    }
}

4. Comparison with Abstract Classes

• In TypeScript, abstract classes are similar to interfaces as neither can be directly instantiated, but abstract classes can include implementation details.
• Interfaces are more suitable for defining contracts between different classes, while abstract classes are commonly used to provide common functionality implementations for subclasses.

From the above comparison, it is evident that while both classes and interfaces are core concepts in object-oriented programming, their purposes, definitions, and supported features differ. In practical development, choosing between classes and interfaces appropriately can make the code clearer and more maintainable.