Our Medium class from chapter 13 can currently be instantiated DIRECTLY (new Medium(...)) – conceptually nonsensical, since a "medium" by itself is abstract; in the real world there are only CONCRETE media (books, audiobooks). Abstract classes enforce exactly that.

Marking Medium as abstract

export abstract class Medium {
  constructor(
    public readonly isbn: string,
    public title: string,
    // ... remaining properties as in chapter 13
  ) {}

  abstract description(): string; // NO implementation - only the signature
}

new Medium('123', 'Test'); // error - abstract classes CANNOT be instantiated directly

abstract class forbids new Medium(...) – the class exists ONLY as a base for inheritance. abstract description(): string (with no function body!) FORCES every derived, CONCRETE class to implement this method ITSELF.

export class Book extends Medium {
  // description() MUST be implemented - otherwise error:
  // "Non-abstract class 'Book' does not implement inherited abstract member 'description'"
  description(): string {
    return `${this.title} (Book)`;
  }
}

Implementing interfaces with implements

A RELATED but different concept: a class can promise to FULFILL an interface, with implements:

export interface Borrowable {
  isAvailable(): boolean;
  checkOut(): void;
  returnItem(): void;
}

import { Borrowable } from './Borrowable.js';

export abstract class Medium implements Borrowable {
  status: 'available' | 'borrowed' = 'available';

  isAvailable(): boolean {
    return this.status === 'available';
  }

  checkOut(): void {
    this.status = 'borrowed';
  }

  returnItem(): void {
    this.status = 'available';
  }

  abstract description(): string;
}

implements Borrowable OBLIGATES Medium to provide ALL of the interface's methods – the compiler checks this IMMEDIATELY at the class declaration, not somewhere later in the code.

The difference: abstract class vs. interface

// A class can inherit from ONLY ONE base class:
class Book extends Medium { /* ... */ }

// BUT can implement any number of interfaces at once:
interface Reservable {
  reserve(): void;
}

class Book extends Medium implements Borrowable, Reservable {
  reserve(): void {
    this.status = 'reserved';
  }
}