Beginnen wir mit einem der einfachsten Erzeugungsmuster: dem Einzelstück (engl. Singleton). Das Singleton-Muster ist eng mit der Frage verknüpft, wie zur Laufzeit einer objektorientierten Anwendung sichergestellt werden kann, dass max. 1 Objekt einer Klasse erzeugt werden kann.

Das Singleton-Muster soll über folgendes Beispiel motiviert werden: Stellen wir uns vor, dass wir in einer Java-Anwendung eine Verbindung zu einer Datenbank aufbauen wollen. Dazu wird die folgende Klasse DatabaseConnection entworfen, die eine Methode zum Verbindungsaufbau und weitere Methoden zum Abfragen und Verändern der Daten enthält. Diese fachlichen Methoden werden in den Code-Listings weiter unten ausgeblendet.

public class DatabaseConnection {
	public boolean connect(String host, String user, String pass, String db) { /* ... */ }
	public ResultSet query(String sqlStatement) { /* ...*/ }
	/* ... */ 
}

Es ist ausreichend, wenn diese Datenbankverbindung beim Start der Anwendung nur einmal aufgebaut wird, und es demzufolge nur ein Objekt dieser Klasse gibt. Dieses Objekt entspricht einer globalen Variable. Es soll nicht möglich sein, dass aus Methoden in beliebigen anderen Klassen in unserem Projekt oder durch Dritte, die unsere Klasse weiterverwenden, DatabaseConnection-Instanzen erzeugt werden können. Um genau das zu verhindern, wird die Sichtbarkeit des Konstruktors der Klasse DatabaseConnection auf private gesetzt. Damit können nur noch aus der Klasse selbst Instanzen erzeugt werden. In der Klasse selbst wird ein statisches Attribut vom Typ DatabaseConnection angelegt, auf das über eine ebenfalls statische und öffentliche Methode zugegriffen werden kann. In folgendem Code wird das Attribut instance bereits beim Laden der Klasse instantiiert.

public class DatabaseConnection {
	// Singleton object
	private static DatabaseConnection instance = new DatabaseConnection();
	// Private constructor
	private DatabaseConnection() {}
	// Static access to singleton object
	public static DatabaseConnection getInstance() { return instance; }
	/* ... */ 	
}

Soll die Erzeugung des Singleton-Objekts nicht beim Laden der Klasse, sondern erst beim ersten Zugriff erfolgen (Lazy Creation), muss die Zugriffsmethode durch das Java-Schlüsselwort synchronized als kritischer Abschnitt geschützt werden, sodass nur ein paralleler Thread gleichzeitig diese Methode durchlaufen kann. Threads und kritische Abschnitte werden erst später im Kapitel Synchronisation von Threads behandelt.

Wenn das Beispiel der Datenbankverbindung verallgemeinert wird (d.h. die Klasse heißt nun Singleton anstatt DatabaseConnection), erhalten wir das geläufige Erzeugungsmuster Singleton, das zusichert, dass zur Laufzeit max. 1 Objekt einer Klasse instantiiert werden kann.

public class Singleton {
	// Singleton object
	private static Singleton instance;
	// Private constructor
	private Singleton() {}
	// Static access to singleton object with lazy creation
	public static synchronized Singleton getInstance() {
		if (instance == null) { instance = new Singleton(); }
		return instance;
	}
	/* ... */ 	
}

Das folgende Modell entspricht dem obigen Java-Code. Unterstreichungen von Attributen oder Methoden in einem UML-Klassendiagramm bedeuten, dass diese statisch sind.

Das Muster realisiert eine einfache Zugriffskontrolle auf das Singleton-Objekt. Durch Unterklassen kann eine allgemeine Singleton-Klasse spezialisiert werden. Das Singleton-Muster sollte aber nicht als Ersatz für sämtliche globale Variablen genutzt werden. Wenn dies exzessiv erfolgt, würde zwar eine große Anzahl von Klassen entstehen, die objektorientierte Idee aber trotzdem untergraben werden.