Difference Between Abstract Class and Interface in Typescript

1. Introduction

In TypeScript, both abstract classes and interfaces are used for designing blueprints for other classes, but they serve different purposes. An abstract class is a base class that cannot be instantiated and can include implementation details for its members. An interface, however, is a purely structural contract - it contains no implementation details but defines the syntax that any class must adhere to.

2. Key Points

1. Implementation: Abstract classes can contain implementation details, but interfaces cannot.

2. Instantiation: Abstract classes cannot be instantiated directly, interfaces are never instantiated.

3. Methods: Abstract classes can have both abstract and concrete methods, and interfaces can only have abstract methods (no implementation).

4. Extension: Abstract classes can be extended, and interfaces can be extended and implemented.

3. Differences

Characteristic Abstract Class Interface
Implementation Can contain implementation Cannot contain implementation
Instantiation Cannot be instantiated directly Never instantiated
Methods Abstract and concrete methods Only abstract methods
Extension Can be extended Can be extended and implemented

4. Example

// Example of an Abstract Class
abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('Moving along!');

// Example of an Interface
interface Movable {
    move(): void;

// Implementing an Interface
class Car implements Movable {
    move(): void {
        console.log('Driving along!');


Abstract Class Output:
Cannot be instantiated, but can define both abstract and concrete methods.
Interface Output:
Defines a contract for classes, no implementation included.


1. The Animal abstract class includes an abstract method makeSound and a concrete method move.

2. The Movable interface only defines the contract for a move method, which the Car class then implements.

5. When to use?

- Use an abstract class when you need to define a base class with some shared implementation that other classes should inherit from.

- Use an interface when you need to enforce a specific contract or shape for classes without concerning yourself with implementation details.