Shulou(Shulou.com)06/03 Report--

The purpose of the singleton pattern is to control that a particular class produces only one object, and of course allows flexibility to change the number of objects under certain circumstances.

How to implement the singleton pattern?

The generation of objects in a class is done by the class constructor. If you want to limit the generation of objects, one way is:

1, make the constructor private (or at least protected) so that the outside class cannot produce an object by reference

2. At the same time, in order to ensure the availability of the class, you must provide your own object and a static method to access it.

Singleton patterns can be divided into stateless and stateless.

Stateful singleton objects are generally variable singleton objects, and multiple singleton objects together can provide services as a state repository.

A singleton object without state, that is, an invariant singleton object, is only used to provide utility functions.

UML class diagram:

Achieve:

Java:

1. Hungry Han style:

Singleton1.java:

/ *

* founder: Yan Chao

* creation time: 2013-6-26

* File name: singleton1.java

* create a design pattern

* single case (singleton)

* hungry Han style

, /

Public class Singleton1 {

/ / define your own instance internally

/ / Note this is private for internal calls only

Private static Singleton1 instance = new Singleton1 ()

/ / set the constructor to private

Private Singleton1 () {

System.out.println ("new an instance!")

}

/ / static factory method, which provides a static method for external access to get objects

Public static Singleton1 getInstance () {

Return instance

}

Public static void main (String [] args) {

Singleton1.getInstance ()

}

}

Second, lazy style:

Singleton2.java:

/ *

* founder: Yan Chao

* creation time: 2013-6-26

* File name: singleton2.java

* create a design pattern

* single case (singleton)

* lazy style

, /

Public class Singleton2 {

Private static Singleton2 instance = null

Private Singleton2 () {

System.out.println ("new an instance!")

}

/ / A pair of static factory methods are synchronized for obvious reasons-to prevent multiple instances in a multithreaded environment

/ / defer the class's instantiation of itself until it is referenced for the first time. On the other hand, the "hungry Chinese style" is instantiated when the class is loaded, so multiple loads will result in multiple instantiations.

Public static synchronized Singleton2 getInstance () {

If (instance = = null) {

Instance = new Singleton2 ()

}

Return instance

}

Public static void main (String [] args) {

/ / Singleton1 S1 = new Singleton1 ()

Singleton2.getInstance ()

}

}

3.

The above two implementations have lost their polymorphism and are not allowed to be inherited. There is another implementation of the flexibility point, which sets the constructor to be protected, which allows inheritance to generate subclasses.

Singleton3.java:

Import java.util.HashMap

Public class Singleton3 {

Private static HashMap sinRegistry = new HashMap ()

Private static Singleton3 instance = new Singleton3 ()

Protected Singleton3 () {

System.out.println ("Construction for Singleton3!")

}

Public static Singleton3 getInstance (String name) {

If (name = = null) {

Name = "Singleton3"

}

If (sinRegistry.get (name) = = null) {

Try {

SinRegistry.put (name, Class.forName (name). NewInstance ())

} catch (Exception e) {

E.printStackTrace ()

}

}

Return (Singleton3) (sinRegistry.get (name))

}

Public void test () {

System.out.println ("get Class Success!")

}

}

Class Singleton3Child1 extends Singleton3 {

Public Singleton3Child1 () {

System.out.println ("Construction for Singleton3Child1!")

}

Public static Singleton3Child1 getInstance () {

Return (Singleton3Child1) Singleton3.getInstance ("Singleton3Child1")

}

Public void test () {

System.out.println ("get Child1 Class Success!")

}

}

Class Singleton3Child2 extends Singleton3 {

Public Singleton3Child2 () {

System.out.println ("Construction for Singleton3Child2!")

}

Public static Singleton3Child2 getInstance () {

Return (Singleton3Child2) Singleton3.getInstance ("Singleton3Child2")

}

Public void test () {

System.out.println ("get Child2 Class Success!")

}

}

TestMain.java:

Public class testMain {

/ * *

* @ param args

, /

Public static void main (String [] args) {

System.out.println ("#")

Singleton3Child1 s3c1 = new Singleton3Child1 ()

Singleton3Child2 s3c2 = new Singleton3Child2 ()

/ / because the key value of hashmap is unique, the following three parts can only be displayed one part at a time

System.out.println ("#")

Singleton3Child1.getInstance (); / / add Singleton3Child1 into hashmap

Singleton3Child2.getInstance (); / / add Singleton3Child2 into hashmap

System.out.println ("#")

Singleton3.getInstance ("Singleton3Child1"); / / add Singleton3Child1 into hashmap

Singleton3.getInstance ("Singleton3Child2"); / / add Singleton3Child2 into hashmap

System.out.println ("#")

Singleton3Child1.getInstance ("Singleton3Child1"); / / add Singleton3Child1 into hashmap

Singleton3Child1.getInstance ("Singleton3Child2"); / / add Singleton3Child2 into hashmap

Singleton3Child2.getInstance ("Singleton3Child1"); / / add Singleton3Child1 into hashmap

Singleton3Child2.getInstance ("Singleton3Child2"); / / add Singleton3Child2 into hashmap

}

}

Since the scope of the constructor of a subclass in java cannot be smaller than that of the parent class, there may be irregular customers

The program uses its constructor to generate instances, causing singleton mode to fail.

Caterpillar:

Singleton.cpp:

# include

Using namespace std

Class Singleton {

Public:

Static Singleton* getInstance () {

If (instance = = NULL) {

Cout

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.