デザインパターン多言語比較

public class Singleton {
    private static Singleton singleton = new Singleton();
    private Singleton() {                                 
        System.out.println("インスタンスを生成しました。");
    }
    public static Singleton getInstance() {
        return singleton;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Start.");
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        if (obj1 == obj2) {
            System.out.println("obj1とobj2は同じインスタンスです。");
        } else {
            System.out.println("obj1とobj2は同じインスタンスではありません。");
        }
        System.out.println("End.");
    }
}

package main

import (
	"fmt"
	"sync"
)

// singleton は型名を小文字にして「外部パッケージから勝手に生成させない」を表現する。
// Go には private constructor が無いので、
//   - 型を非公開(singleton)にする
//   - 生成手段を GetInstance() だけに絞る
//
// の組み合わせで唯一性を守るのが定番。
type singleton struct {
	// 状態を持たせるならここに。今回は存在確認だけなので空。
}

var (
	instance *singleton
	once     sync.Once
)

// GetInstance は唯一のインスタンスを返す。
// sync.Once により初回だけ生成し、以降は同じものを返す。
// 複数の goroutine から同時に呼ばれても生成は一度きり（スレッド安全）。
func GetInstance() *singleton {
	once.Do(func() {
		fmt.Println("インスタンスを生成しました。")
		instance = &singleton{}
	})
	return instance
}

// 【別解】遅延生成が不要なら、パッケージ変数の即時初期化が最短:
//
//	var instance = &singleton{}
//	func GetInstance() *singleton { return instance }
//
// Java版の「private static Singleton singleton = new Singleton();」に一番近いのはこちら。
// パッケージ変数の初期化はプログラム起動時に一度だけ走るので、これも安全。

package main

import "fmt"

// 実行: go run ./GoF/patterns/Singleton/go
//
// 「インスタンスを生成しました。」が一度しか出ないこと、
// obj1 と obj2 がポインタとして等しいことで、唯一性を確認する。
func main() {
	fmt.Println("Start.")
	obj1 := GetInstance()
	obj2 := GetInstance()
	if obj1 == obj2 {
		fmt.Println("obj1とobj2は同じインスタンスです。")
	} else {
		fmt.Println("obj1とobj2は同じインスタンスではありません。")
	}
	fmt.Println("End.")
}

<?php


/**
 * 絶対唯一君臨するグローバル変数
 * システム中に一つだけあれば良い、または一つしかいて欲しくない
 * インスタンスを制御するためのパターン
 * 生成が重くて至る所でnewさせちゃいけないとき
 */

/**
 * ログや設定ファイル、重いオブジェクトなど
 * その実態を使いまわしたいときに用いる
 * やり方
 * 
 * 1. コンストラクタをprivateにする
 * 2. 自身を保持するprivate staticな変数を作成する
 * 3. 自身を返す public staticなメソッドを作る
 * 
 * 
 */


class Singleton
{
  private static $instance;

  /**
   * 外部からnewできないようにコンストラクタを
   * privateで実装
   */

  private function __construct()
  {
  }

  /**
   * インスタンスが生成されていなければnew、
   * されていればそのままインスタンスを返す
   */

  public static function getInstance()
  {
    if (!self::$instance) {
      self::$instance  = new Singleton();
    }
    return self::$instance;
  }
}


$obj1 = Singleton::getInstance();
$obj2 = Singleton::getInstance();

if ($obj1 === $obj2) {
  print "同じオブジェクトだ";
} else {
  print "違うオブジェクトだ";
}

// Singleton パターン: 唯一のインスタンス (Java版と同じ題材)
//
// 実行:
//   npx tsx main.ts
//
// 「インスタンスを生成しました。」が一度しか出ないこと、
// obj1 と obj2 が===で等しいことで、唯一性を確認する。

// TypeScriptにはJavaのprivateコンストラクタがそのまま存在する(コンパイル時チェックだが実用上十分)。
// 「privateコンストラクタ + static instance + static getInstance()」で唯一性を守るのが
// Java版に最も近い書き方。
class Singleton {
  private static instance: Singleton | undefined;

  private constructor() {
    console.log("インスタンスを生成しました。");
  }

  // 遅延生成: 呼ばれるまでインスタンスを作らない(Go版のsync.Once版と同じ発想)。
  static getInstance(): Singleton {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton();
    }
    return Singleton.instance;
  }
}

// 【別解1】Java版の「private static Singleton singleton = new Singleton();」に一番近いのは即時初期化:
//
//   class Singleton {
//     private static readonly instance: Singleton = new Singleton();
//     private constructor() { console.log("インスタンスを生成しました。"); }
//     static getInstance(): Singleton { return Singleton.instance; }
//   }
//
//   staticフィールドの初期化式はクラス定義の評価時に一度だけ走る
//   (モジュールはimport先で一度しか評価されないので安全)。
//
// 【別解2】モジュールスコープの単一オブジェクトをそのままexportする:
//
//   class SingletonImpl { ... }
//   export const instance = new SingletonImpl();
//
//   ESモジュールは一度しか評価されずimport先で共有されるため、
//   「クラス+getInstance()」という器すら要らず、モジュール自体がシングルトンとして機能する。
//   これがJS/TSでもっとも慣用的な形。

function main(): void {
  console.log("Start.");
  const obj1 = Singleton.getInstance();
  const obj2 = Singleton.getInstance();
  if (obj1 === obj2) {
    console.log("obj1とobj2は同じインスタンスです。");
  } else {
    console.log("obj1とobj2は同じインスタンスではありません。");
  }
  console.log("End.");
}

main();

"""Singleton パターン: 唯一のインスタンス (Java版と同じ題材)

実行:
    python3 main.py

「インスタンスを生成しました。」が一度しか出ないこと、
obj1 と obj2 がis演算子で同一であることで、唯一性を確認する。
"""

from __future__ import annotations


class Singleton:
    """Java版の「private static Singleton singleton」+「public static getInstance()」を
    クラス変数(_instance)とクラスメソッド(get_instance)で再現する。

    Pythonにはprivateコンストラクタという言語機能がない(先頭アンダースコアは
    「触るな」という慣習に過ぎず、Singleton()を直接呼べば実際に生成されてしまう)。
    Java版のような強制力はないので、「get_instance()経由でしか使わない」という
    規約で唯一性を担保する — Go版がコメントで書いている「型を非公開にする」代わりに、
    Pythonでは命名規約と設計意図のドキュメント化で守る、という対比になる。

    【別解1】モジュール自体をシングルトンとして使う
        Pythonのモジュールはimport時に一度だけ実行されキャッシュされる。
        そのためモジュールレベルの関数・変数がそのままシングルトンとして機能し、
        クラスすら要らない。これがPythonでもっとも慣用的な形。

    【別解2】__new__をオーバーライドしてインスタンス生成そのものを差し替える
        def __new__(cls):
            if cls._instance is None:
                cls._instance = super().__new__(cls)
            return cls._instance
        こうすると Singleton() を直接呼んでも同じインスタンスが返るようになり、
        「コンストラクタを隠す」ではなく「コンストラクタの中身を唯一性チェックにすり替える」
        という発想でJava版のprivateコンストラクタに近づける。
    """

    _instance: "Singleton | None" = None

    def __init__(self) -> None:
        print("インスタンスを生成しました。")

    @classmethod
    def get_instance(cls) -> "Singleton":
        # 遅延生成: 呼ばれるまでインスタンスを作らない(Go版のsync.Once版と同じ発想)。
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance


def main() -> None:
    print("Start.")
    obj1 = Singleton.get_instance()
    obj2 = Singleton.get_instance()
    if obj1 is obj2:
        print("obj1とobj2は同じインスタンスです。")
    else:
        print("obj1とobj2は同じインスタンスではありません。")
    print("End.")


if __name__ == "__main__":
    main()