When dealing with classes and interfaces in TypeScript (as well as other object-oriented languages), it's important to understand their distinct roles.

An interface serves as a blueprint, outlining what methods and properties a type must have without providing any actual implementation. It essentially defines a "contract" that implementing instances must adhere to.

For instance:

interface Point {
    x: number;
    y: number;
    distance(other: Point): number;
}

In this example, any object implementing the Point interface must include two number-type members (x and y) and a method named distance, which takes another Point instance as a parameter and returns a number.

The real meat of the functionality lies in classes, which are responsible for implementing the details specified by interfaces:

class PointImplementation implements Point {
    public x: number;
    public y: number;
    
    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }
    
    public distance(other: Point): number {
        return Math.sqrt(Math.pow(this.x - other.x, 2) + Math.pow(this.y - other.y, 2));
    }
}

As illustrated in the code snippet above, classes provide the actual implementation based on the requirements laid out by interfaces.

It's worth noting that when extending or implementing classes/interfaces, there are subtle distinctions to keep in mind:

class Person {
    name: string;
    age: number;
}

class Child extends Person {}

class Man implements Person {}

In the case of trying to implement the Person interface with the Man class, you may encounter errors if the necessary properties are not defined, highlighting the fact that interfaces do not contain implementations.

To rectify such errors, make sure to explicitly define all required properties within the implementing class:

class NoErrorMan implements Person {
    name: string;
    age: number;
}

Ultimately, the key takeaway is that when working with classes and interfaces, it's essential to grasp the distinction between extending a class (inheriting its properties and methods) and implementing an interface (adhering to a set of rules without inheriting any concrete implementations).

Comparison between Extends and Implements

• extends: When a child class inherits all properties and methods from the parent class it extends.
• implements: The class using the implements keyword must implement all properties and methods declared in the interface it implements.

Simplified explanation:

• extends: Automatically acquires methods/properties from the parent class, eliminating the need for manual implementation.
• implements: Acts as a contractual obligation for the class to adhere to, ensuring implementation of specified methods/properties.

Example Scenario:

class Person {
  name: string;
  age: number;

  walk(): void {
    console.log('Walking (person Class)')
  }

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}
class Child extends Person { }

// Man is required to implement all properties
// and methods of the Person class
class Man implements Person {
  name: string;
  age: number

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

  walk(): void {
    console.log('Walking (man class)')
  }

}
    
(new Child('Mike', 12)).walk();
// Output: Walking(person Class)

(new Man('Tom', 12)).walk();
// Output: Walking(man class)

In the given example, we see that the Child class inherits everything from Person, while the Man class must implement all aspects of Person itself.

If something was removed from the Man class, like the walk method, a compile time error would occur:

'Man' does not correctly implement 'Person'. Should you perhaps extend 'Person' to inherit its members as a subclass? Property 'walk' is missing in type 'Man' but is required in type 'Person'.(2720)

What an insightful response from @nitzan-tomer! I found it extremely helpful and decided to expand on his demonstration a bit by incorporating:

IPoint interface;
Point implements IPoint;
Point3D extends Point;

I then explored how these elements behave within functions that expect an IPoint type.

From this experience, I've adopted a rule of thumb: when working with classes and methods that require generic types, utilize interfaces as the expected types. Additionally, ensure that the parent or base-class utilizes that interface so that all subclasses implementing the interface can be used effectively in those scenarios.

You can access the expanded demo here.

In simple terms:

• extends allows us to inherit all the properties and methods from the parent class.
• implements requires us to provide implementations for all the properties and methods specified in the interface.

1. Interface extending another interface with a specific shape
2. Interface expanding a class with a particular structure
3. To implement a class that implements an interface, all fields specified by the interface must also be implemented
4. Implementing a class that has a defined structure
5. Extending a class that includes all fields from another class

extends focuses on inheritance while implements concentrates on restrictions for interfaces or classes.

Utilizing interfaces in programming serves to decrease the connection between classes by establishing a set of rules or common communication system that dictates how various classes can engage with each other. This approach fosters a more flexible and easily maintainable codebase, as it encourages loose connections and facilitates future expansions (Adopting an interface-driven design). Through the implementation of interfaces rather than inheritance, the interdependencies among classes are minimized, resulting in decreased code entanglement. This separation improves the ability to reuse code, conduct thorough testing, and enhance the overall adaptability of the system.

• "extends": The keyword is utilized when a class or interface "extends" another class or

  interface> of the same type within its hierarchy.</li>
  <li>"<code>implements

  " : This keyword is used specifically when a class implements an interface.