One of the many annoyances of programming is a variables scope. Generally variables can be declared within the global namespace or the local namespace. When working with methods and classes global variables appear to be a good idea, however overuse of the global namespace can cause variables to clash, it also undermines encapsulation. Moreover, a class which depends on a global variable is coupled with the project rendering it impossible to reuse (unless the global variable is declared). This will lead to unwanted debugging. Using the singleton design pattern, you can make a class seemingly “global.” Although the code in this article is PHP, the concepts apply across almost every programming language.


Problem:
While designing my framework I found access to the database object was required by many classes. Since I only intend on connecting to a single database server, only one object of my database class would ever need to be instantiated. A novice programmer would create a database class which would look like the following:
  To access any one of the methods you must instantiate the class then call the method:
 

Obviously the code above (assuming the methods have been implemented)will query the database. In most instances the code above is an acceptable practice. However, this will lead you down one of three roads: you will declare $db in the global namespace, you will instantiate a new database object each time it is needed, or you will end up passing $db to object X so when it creates object Y the database object can be passed. Alas, the learned programmer will choose to use the Singleton design pattern.

Solution:
The solution is to create a class that can only be instantiated itself. Moreover, it should not instantiate more than once instance of itself. We start by making the constructor private, creating a new static method which I will call getInstance(), and a new static variable which I will call $instance.
  Since the constructor is private, to convey the configuration settings to the database call we will need to pass them to the getInstance() function. Here is where the magic happens. The static variable $instance is used to hold the instance of this class (if one exists). Since we only want one instance to ever be created, we will check to see if $instance has already been set, if it has not, we will set $instance to a new instance of the object then return it. If it has been set, we will simply return the already created object. Confused? Take a look at the code �" it should clear things up:

  To use this class, we use PHP's scope resolution operator, which allows us to access a static function of a class, without instantiating it.
  We can now call the database::getInstance($config_info) from any class as many times as we want, without creating a new object. Moreover, we can access the same exact object created in a different location of our application essentially providing “global” access.