Interfaces vs Classes in TypeScript

In TypeScript, both interfaces and classes are used to define the structure of an object or blueprint for objects, but they serve different purposes and have different behaviors. Understanding when to use an interface and when to use a class is essential to writing clean, maintainable, and efficient TypeScript code.

 

Key Differences Between Interfaces and Classes

Definition of Structure vs Implementation

• Interface: Defines a contract or structure for objects without providing any implementation details. It defines the shape or blueprint of an object, ensuring that the object adheres to specific rules (properties and methods).
• Class: Provides both the structure and the implementation. It defines the blueprint for creating objects and can include implementation of methods, as well as data members (properties).

Instantiating

• Interface: Cannot be instantiated. An interface only defines the structure but does not create objects.
• Class: Can be instantiated to create objects. A class defines both the structure and the implementation, and you can create instances (objects) of a class.

Method Implementation

• Interface: Only defines method signatures but does not provide an implementation. Methods defined in an interface need to be implemented by the class that implements the interface.
• Class: Can define methods with full implementation. Classes can have both abstract methods (unimplemented) and concrete methods (implemented).

Inheritance

• Interface: Can extend multiple interfaces, which allows a type to inherit from several sources. Interfaces are purely structural and are used for type checking.
• Class: Can extend another class to inherit both its properties and methods. Classes can be instantiated and contain implementation logic.

Support for Properties and Methods

• Interface: Defines only the shape of properties and methods. It doesn't contain any implementation logic.
• Class: Contains both the definition (properties) and implementation (methods) of an object. A class can also have constructors, which define how the object is created.

Use Case

• Interface: Primarily used to define types, especially when you need to ensure that an object conforms to a certain shape or structure, or when working with types that will be implemented by different classes.
• Class: Used to define both the structure and the behavior of objects. Classes are used when you need to create instances or provide method logic for objects.

 

Example Comparison

Interface Example

interface Person {
  name: string;
  age: number;
  greet(): void;
}

class Employee implements Person {
  constructor(public name: string, public age: number) {}

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const employee = new Employee("John", 30);
employee.greet();  // Output: Hello, my name is John and I am 30 years old.

• The Person interface defines the structure for objects, including properties (name, age) and a method (greet()).
• The Employee class implements the Person interface, ensuring that it provides the correct structure and method implementation.

Class Example

class Car {
  constructor(public brand: string, public model: string) {}

  drive() {
    console.log(`The ${this.brand} ${this.model} is driving.`);
  }
}

const car = new Car("Toyota", "Corolla");
car.drive();  // Output: The Toyota Corolla is driving.

• The Car class not only defines properties (brand, model) but also provides the implementation of the drive() method.
• An object of type Car can be instantiated, and the method drive() can be invoked.

When to Use an Interface

• Type-checking: If you want to enforce that an object or class conforms to a specific shape or structure, you should use an interface.
• Multiple implementations: When different classes may have different implementations but should adhere to the same structure.
• Avoiding implementation: If you only need to define the shape of an object without needing the actual logic, interfaces are more suitable.

Example: Interface for Multiple Implementations

interface Animal {
  sound(): void;
}

class Dog implements Animal {
  sound() {
    console.log("Woof!");
  }
}

class Cat implements Animal {
  sound() {
    console.log("Meow!");
  }
}

const dog = new Dog();
dog.sound();  // Output: Woof!

const cat = new Cat();
cat.sound();  // Output: Meow!

Here, both Dog and Cat classes implement the same Animal interface, ensuring that both classes provide a sound() method.

When to Use a Class

• Instantiating objects: When you need to create instances or when you need to include methods with implementation logic.
• Object creation and behavior: If you need an object that has both data and functionality (methods).
• Inheritance: When you need to inherit from another class or extend functionality with superclasses.

Example: Class with Inheritance

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

  speak() {
    console.log(`${this.name} makes a sound`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks`);
  }
}

const dog = new Dog("Buddy");
dog.speak();  // Output: Buddy barks

Here, the Dog class extends the Animal class and overrides the speak() method to provide a specific implementation.

 

Summary

• Interfaces are used to define structures and types. They are best for ensuring that an object or class adheres to a certain contract or shape but do not provide implementation details.
• Classes provide both structure and behavior. They can be instantiated, have both methods and properties, and can be extended through inheritance.

When designing your application, use interfaces when you want to define types and structures, and use classes when you need to implement object behavior and create instances.