CSC/ECE 517 Fall 2010/ch3 3f lj: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
No edit summary
Line 27: Line 27:
         return INSTANCE;
         return INSTANCE;
     }
     }
==Ruby==
class NewClass
  include Singleton
end

Revision as of 05:00, 6 October 2010

Singleton Pattern in Static and Dynamic languages

Singleton pattern

A singleton pattern is a design pattern that restricts the amount of instantiations of a class to one object. This pattern is implemented when exactly one object is needed to coordinate actions across the entire system. The restriction of only having one object can sometimes make the system more efficient and allow the programmer to exercise more control over certain actions in the system. A singleton must satisfy some global access principles, which say all of the classes must be able to access the functionality contained in the singleton class/es.

Implementation

When this pattern is implemented then it must only have one instantiation of a class and that class must satisfy the global access principles. The pattern requires a mechanism to access the singleton class without instantiating another class object and a mechanism to persist the value of class members among class objects.

Creating an instance

Accessing the instance

Examples

Java

Java's API includes a Singleton class which implements the static version of the Singleton pattern. Java's implementation of the Singleton pattern only allows the programmer to create one instance of the Singleton class. The Singleton class automatically creates INSTANCE when it is initialized. The getInstance() method returns the single instance of the class that has been initialized.

   private static final Singleton INSTANCE = new Singleton();
  
   // Private constructor prevents instantiation from other classes
   private Singleton() {
   }
   public static Singleton getInstance() {
       return INSTANCE;
   }

Ruby

class NewClass

 include Singleton

end