思想：
对象的唯一性（解决一个类在内存只存在一个对象）
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象；
2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义对象；
3、为了方便其他程序对自定义的访问，可以对外提供一些访问方式。

代码步骤：
1、将构造函数私有化
2、在类中创建一个本类对象
3、提供一个方法可以获取到该对象
注意：
对于事物该怎么描述，还是怎么描述
当需要将该事物的对象保证在内存中唯一性时，就将以上的三部加上即可
下面是例子

1. package com.hupingyan.Static;
   
2. 
   
3. class DesginTool
   
4. {
   
5.         private int num;
   
6.         public void setNum(int num)
   
7.         {
   
8.                 this.num = num;
   
9.         }
   
10.         public int getNum()
    
11.         {
    
12.                 return num;
    
13.         }       
    
14.         //单例设计模式三部曲 Start
    
15.         private DesginTool(){}
    
16.         private static DesginTool desgin = new DesginTool();
    
17.         public static DesginTool getObject()
    
18.         {
    
19.                 return desgin;
    
20.         }
    
21.         //单例设计模式三部曲 End
    
22. }
    
23. 
    
24. 
    
25. public class Desgin {
    
26.         public static void main(String[] args)
    
27.         {
    
28.                 DesginTool aa = DesginTool.getObject();
    
29.                 DesginTool aa1 = DesginTool.getObject();
    
30.                 aa.setNum(50);
    
31.                 System.out.println(aa.getNum());
    
32.                 System.out.print(aa1.getNum());
    
33.         }
    
34. }

复制代码

单例设计模式可以分为饿汉式和懒汉式
饿汉式：single 类一进内存，就已经创建好了对象
例子：

1. class single
   
2. {
   
3.        private single(){}
   
4.        private single s = new single();
   
5.        public static single getSingle()
   
6.     {
   
7.         return s;
   
8.     }
   
9. }

复制代码

懒汉式：single类进内存，对象还没存在，只有调用了getSingle方法时，才建立对象。
例子：

1. class single
   
2. {
   
3.     private single(){}
   
4.     private static single s = null;
   
5.     public static single getSingle()
   
6.     {
   
7.         if(s==null)
   
8.         {
   
9.             s = new single();      
   
10.         }
    
11.         return s;
    
12.     }
    
13. }

复制代码

一般开发中用饿汉式 ，而懒汉式面试时会碰到

学习了。