Suggest an edit

Improve this article

Refine the answer for “Multiple inheritance”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## 1. Short answer

> **Yes, you can!**
> This uses the `extends` keyword,
> followed by **several interfaces separated by commas**.

---

### Example

```javascript
interface A {
  a: string;
}

interface B {
  b: number;
}

interface C extends A, B {
  c: boolean;
}

const obj: C = {
  a: "Hello",
  b: 42,
  c: true,
};
```

> Interface `C` now includes properties **from all three interfaces**:
> `a`, `b`, and `c`.

---

## 2. How it works

- TypeScript combines all properties from interfaces `A` and `B`.
- If the inherited fields **do not conflict**, everything is fine.
- If the same property is declared in several interfaces,
TypeScript checks **whether their types are compatible**.

---

### Example of compatible properties

```javascript
interface X {
  value: string;
}

interface Y {
  value: string;
}

interface Z extends X, Y {
  flag: boolean;
}

const z: Z = { value: "ok", flag: true }; // types match
```

---

### Example of conflicting properties

```javascript
interface X {
  value: string;
}

interface Y {
  value: number;
}

interface Z extends X, Y {} // Error: types are incompatible
```

> TypeScript cannot merge `string` and `number`
> into a single property with the same name.

---

## 3. Inheritance can be combined with your own fields

You can extend several interfaces **and add new properties**:

```javascript
interface Position {
  x: number;
  y: number;
}

interface Shape {
  color: string;
}

interface Circle extends Position, Shape {
  radius: number;
}

const c: Circle = {
  x: 0,
  y: 0,
  color: "red",
  radius: 10,
};
```

> `Circle` combines everything: coordinates, color, and radius.

---

## 4. Inheriting interfaces with methods

```javascript
interface CanFly {
  fly(): void;
}

interface CanSwim {
  swim(): void;
}

interface Duck extends CanFly, CanSwim {
  quack(): void;
}

const duck: Duck = {
  fly: () => console.log("Flying"),
  swim: () => console.log("Swimming"),
  quack: () => console.log("Quack!"),
};
```

> The `duck` object must implement **all the methods**
> from `CanFly`, `CanSwim`, and `Duck`.

---

## 5. You can combine interfaces and `type`

If you have a `type`, an interface **cannot directly inherit** from it,
but you can use an **intersection of types (**`&`**)**:

```javascript
type Timestamped = { createdAt: Date };

interface Entity {
  id: number;
}

interface User extends Entity, Timestamped {  // not allowed directly
  name: string;
}

// alternative via &:
type UserFull = Entity & Timestamped & { name: string };
```

> `interface` can only extend other interfaces via `extends`.
> If you need to combine a `type` and an `interface`, use `&`.

---

## 6. Example from a real project

```javascript
interface Identifiable {
  id: number;
}

interface Timestamped {
  createdAt: Date;
  updatedAt: Date;
}

interface User extends Identifiable, Timestamped {
  name: string;
  email: string;
}

const u: User = {
  id: 1,
  createdAt: new Date(),
  updatedAt: new Date(),
  name: "Tim",
  email: "tim@example.com",
};
```

> A single interface (`User`) combines identification data and timestamps.

---

## Summary

> In TypeScript, an interface can **inherit from several other interfaces**:
>
> ```javascript
> interface C extends A, B, D { ... }
> ```
>
> This allows you to:
>
> - combine structures without duplicating code;
> - build a "hierarchy of contracts";
> - extend interfaces with methods, properties, and options;
> - compose behavior (for example, `CanFly`, `CanSwim`, `CanRun`).

Markdown · drag & drop images · ⌘B / ⌘I shortcuts564 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.