JavaScript Polymorphism – One Interface, Many Implementations

class Notification {
  constructor(message) {
    this.message = message;
    this.timestamp = new Date().toISOString();
  }

  send() {
    return `[${this.timestamp.slice(11,19)}] Sending: ${this.message}`;
  }

  format() {
    return this.message;  // base format — overridden by subclasses
  }
}

class EmailNotification extends Notification {
  constructor(message, to) {
    super(message);
    this.to = to;
  }

  format() {
    return `To: ${this.to}\nSubject: Notification\n\n${this.message}`;
  }
}

class SMSNotification extends Notification {
  format() {
    // SMS: keep it short
    return this.message.length > 160
      ? this.message.slice(0, 157) + '...'
      : this.message;
  }
}

class PushNotification extends Notification {
  constructor(message, badge = 1) {
    super(message);
    this.badge = badge;
  }

  format() {
    return `🔔 (${this.badge}) ${this.message}`;
  }
}

// Polymorphic usage — same interface, different behaviour
const notifications = [
  new EmailNotification('Your order shipped!', 'user@example.com'),
  new SMSNotification('Your code: 123456'),
  new PushNotification('New message from Alice', 3)
];

notifications.forEach(n => console.log(n.format()));
console.log('---');
notifications.forEach(n => console.log(n.send()));

class Shape {
  constructor(color = 'black') {
    if (new.target === Shape) throw new Error('Shape is abstract');
    this.color = color;
  }

  area()      { throw new Error(`${this.constructor.name} must implement area()`); }
  perimeter() { throw new Error(`${this.constructor.name} must implement perimeter()`); }

  describe() {
    return `${this.constructor.name} [${this.color}]: area=${this.area().toFixed(2)}, perimeter=${this.perimeter().toFixed(2)}`;
  }
}

class Circle extends Shape {
  constructor(radius, color) {
    super(color);
    this.radius = radius;
  }
  area()      { return Math.PI * this.radius ** 2; }
  perimeter() { return 2 * Math.PI * this.radius; }
}

class Rectangle extends Shape {
  constructor(width, height, color) {
    super(color);
    this.width  = width;
    this.height = height;
  }
  area()      { return this.width * this.height; }
  perimeter() { return 2 * (this.width + this.height); }
}

class Triangle extends Shape {
  constructor(a, b, c, color) {
    super(color);
    this.a = a; this.b = b; this.c = c;
  }
  perimeter() { return this.a + this.b + this.c; }
  area() {
    const s = this.perimeter() / 2;
    return Math.sqrt(s * (s - this.a) * (s - this.b) * (s - this.c));
  }
}

const shapes = [
  new Circle(5, 'red'),
  new Rectangle(4, 6, 'blue'),
  new Triangle(3, 4, 5, 'green')
];

shapes.forEach(s => console.log(s.describe()));

// Total area — polymorphic reduce
const total = shapes.reduce((sum, s) => sum + s.area(), 0);
console.log(`Total area: ${total.toFixed(2)}`);

// Function only cares that the object has a .speak() method
function makeNoise(animal) {
  if (typeof animal.speak !== 'function') {
    throw new TypeError('Object must have a speak() method');
  }
  return animal.speak();
}

// These are unrelated objects — no shared class hierarchy
const dog  = { name: 'Rex',   speak() { return `${this.name}: Woof!`; } };
const cat  = { name: 'Luna',  speak() { return `${this.name}: Meow!`; } };
const duck = { name: 'Donald', speak() { return `${this.name}: Quack!`; } };
const robot = { name: 'R2D2', speak() { return `${this.name}: Beep boop!`; } };

[dog, cat, duck, robot].forEach(a => console.log(makeNoise(a)));

// Array also works if it has speak method!
const trumpet = {
  name: 'Trumpet',
  speak() { return `${this.name}: 🎺 Toot!`; }
};
console.log(makeNoise(trumpet));

class Vector2D {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  // Used in string contexts: template literals, console.log, String()
  toString() {
    return `Vector(${this.x}, ${this.y})`;
  }

  // Used in numeric contexts: +, -, *, comparisons
  valueOf() {
    return Math.sqrt(this.x ** 2 + this.y ** 2);  // magnitude
  }

  add(other) {
    return new Vector2D(this.x + other.x, this.y + other.y);
  }
}

const v1 = new Vector2D(3, 4);
const v2 = new Vector2D(1, 2);

console.log(`${v1}`);           // toString() called
console.log(String(v1));        // toString() called
console.log(+v1);               // valueOf() called → magnitude = 5
console.log(v1 > v2);          // valueOf() called for comparison
console.log(v1.add(v2).toString()); // add returns new Vector