🧩 Prototype Pattern

✅ Intent

• Create new objects by cloning a prototype rather than instantiating from scratch
• Reuse a pre-configured object as a base and apply only the necessary differences

✅ Motivation

• Avoid hardcoding the entire configuration of an object every time
• Instead, maintain a single source of truth and clone it for variations

✅ When to Use

• When object creation involves expensive setup or many default values
• You need to generate many similar instances with minor differences
• You're dealing with notification templates, configuration sets, or UI components

✅ Code Example

TypeScript

interface Cloneable<T> {
  clone(): T;
}

class Notification implements Cloneable<Notification> {
  constructor(
    public header: string,
    public footer: string,
    public user: string = "",
    public message: string = ""
  ) {}

  clone(): Notification {
    return new Notification(this.header, this.footer);
  }

  send(): void {
    console.log(
      `${this.header}\n宛先: ${this.user}\n本文: ${this.message}\n${this.footer}`
    );
  }
}

// プロトタイプ生成
const prototype = new Notification("件名: お知らせ", "-- 通知システム");

// 利用例
const n1 = prototype.clone();
n1.user = "hiroshi";
n1.message = "こんにちは";
n1.send();

const n2 = prototype.clone();
n2.user = "satoshi";
n2.message = "お知らせがあります";
n2.send();

PHP

<?php

class Notification {
  public function __construct(
    public string $header,
    public string $footer,
    public string $user = "",
    public string $message = ""
  ) {}

  public function clone(): Notification {
    return new Notification($this->header, $this->footer);
  }

  public function send(): void {
    echo "{$this->header}\n宛先: {$this->user}\n本文: {$this->message}\n{$this->footer}\n";
  }
}

// プロトタイプ生成
$prototype = new Notification("件名: お知らせ", "-- 通知システム");

// 利用例
$n1 = $prototype->clone();
$n1->user = "hiroshi";
$n1->message = "こんにちは";
$n1->send();

$n2 = $prototype->clone();
$n2->user = "satoshi";
$n2->message = "お知らせがあります";
$n2->send();

Python

import copy

class Notification:
    def __init__(self, header: str, footer: str, user: str = "", message: str = ""):
        self.header = header
        self.footer = footer
        self.user = user
        self.message = message

    def clone(self) -> 'Notification':
        return copy.deepcopy(self)

    def send(self):
        print(f"{self.header}\n宛先: {self.user}\n本文: {self.message}\n{self.footer}")

# プロトタイプ生成
prototype = Notification("件名: お知らせ", "-- 通知システム")

# 利用例
n1 = prototype.clone()
n1.user = "hiroshi"
n1.message = "こんにちは"
n1.send()

n2 = prototype.clone()
n2.user = "satoshi"
n2.message = "お知らせがあります"
n2.send()

✅ Explanation

This code uses the Prototype pattern to create new Notification objects by cloning a pre-initialized instance.

Each clone inherits all base properties and logic (e.g. headers, formatting rules), and can then be customized with user-specific content before sending.

1. Prototype Pattern Overview

• Prototype: An interface or base class that defines a cloning method
  → Cloneable<T>

• ConcretePrototype: Implements the cloning logic and serves as the base for duplication
  → Notification

• Client: Clones the prototype and updates only the necessary fields before use

2. Key Classes and Responsibilities

• Cloneable<T>

  • Defines the clone() method
  • Ensures each prototype instance can be duplicated

• Notification

  • Implements Cloneable
  • Provides clone() and send() methods
  • Base template can be cloned and reused with customized content

• Client Code

  • Creates a base prototype with fixed settings
  • Clones it for each user/message and customizes as needed

3. UML Class Diagram

4. Benefits of the Prototype Pattern

• Avoids duplication: Write setup logic once and reuse it through cloning
• Efficient object creation: Especially useful when instantiation is complex or resource-intensive
• Flexible extension: Add variations by modifying clones instead of subclassing

This design is ideal for building systems that need to generate multiple pre-configured objects with slight variations, such as email templates, UI components, or configuration snapshots.