Black Horse Programmer--a single case design pattern

-------<a href= "http://www.itheima.com" target= "blank" >android training </a> <a href= "/http/ Www.itheima.com "target=" blank ">java training </a>, look forward to communicating with you! ----------

The role of a singleton design pattern: To make a class exist in memory only one object.

Using code to implement a singleton design pattern requires three parts:

1, initialize the constructor function.

Example: Private single () {}

2. Create an object of this class in the class.

Example: private static single s= newsingle ();

3. Provides an access method that can be obtained to the object.

Example: public static single getinstance ()

{

Returns

}

The singleton design pattern is just to make sure that the objects in memory are unique, what else to describe in the class, or how to describe them.

The singleton design pattern is written in two ways:

1, a hungry man: that is, just three examples in the statement. It is characterized by initializing the object first. For example, if the single class is in memory, the object is already created. In the actual development, the

For safety reasons, it is recommended to use the A hungry man type.

The complete code is as follows:

 

1. Class single
2. {
3. private Static single s=new single ();
4. Private single () {}
5. public Static single getinstance ()
6. {
7. return s;
8. }
9. }

2, lazy type: It is the characteristics of the object is called when the method is initialized, which is also called the object's delay loading. For example: In the following complete code, the single class enters memory, and the object has not

exists, the object is created only when the getinstance () method is called.

The complete code is as follows:

2. Class single
4. {
6. private static single s=null;
8. Private single () {}
10. public Static single getinstance ()
12. {
14. if (s==null)
16. s=new single ();
18. return s;
20. }
22. }

Black Horse Programmer--a single case design pattern