求解，单例模式的作用是什么，什么时候设计成单例模式?这是一个面试题呢，求解

单例类的作用：让一个类只能创建一个实例（因为频繁的创建对象，回收对象会造成系统性能下降。）。
使用单例类条件：在一定的场景中，只有一个这样的实例，比如说银行的号码管理器等。
单例类的书写格式：

class Singleton
{
        //使用一个变量来缓存曾经创建的实例
        private static Singleton instance;
        //对构造器使用private修饰，隐藏构造器
        private Singleton(){}
        //提供一个静态方法，用于返回Singleton实例
        //该方法可以加入自定义控制，保证只产生一个Singleton对象
        public static Singleton getInstance()
        {
                //如果instance为null,则表明还不曾创建Singleton对象
                //如果instance不为null,则表明已经创建了Singleton对象
                //将不会重新创建新的实例。
                if (instance ==null)
                {
                        //创建一个Singleton对象，并将其缓存起来
                        instance = new Singleton();
                }
                return instance;
        }
}

单例设计模式解决的问题
                        保证某个类的对象只有一个所有的人所使用的是同一个对象。


        单例模式的步骤:

                1.构造方法私有化
                                让外部不可以直接创建本类对象

                2.在类内实例化一个本类对象 ,属性一般都会private
                                必须在内部得到一个本类对象。是可以让外部访问到的。但是属性一般都要私有化

                3.在本类内提供一个外部可以访问的获得本类对象的static方法。
                                提供一个可以被外部访问的方法，这个方法构造方法私有化了，所以要做在类方法。
                               
        单例模式什么时候使用?
               
                当前对象的创建比较消耗资源，我们在使用这个对象时只需要有一个就可以应用。
                这个时候就可以将其设计成单例的模式。

                实际操作：java连接数据库，与数据库的连接会比较消耗资源。我们可以将其做成单例的，
                这个时候在内存中就有一个，所有人操作的都是一个。

                //饿汉式(工作中)
                class Single
                {
                        //在本类内创建一个对象.
                        private static Single s=new Single();
                        //私有构造方法
                        private Single(){
                       
                        }
                        //对外提供公共的可以获得本类对象的方法.
                        public static Single getInstance(){
                                return s;
                        }
                }
                       
               
                //笔试中
                //延迟加载的方式(懒汉式)  不完善，讲多线程还要对其进行改进.
                class Single
                {
                        //在本类内创建一个对象.
                        private static Single s;
                        //私有构造方法
                        private Single(){
                       
                        }
                        //对外提供公共的可以获得本类对象的方法.
                        public static Single getInstance(){
                                if(s==null){
                                        s=new Single();
                                }
                                return s;
                        }
                }

单例模式：解决对象的唯一性，保证了内存中一个对象是唯一的
解决步骤
   1. 不能让你 new 对象
   2. 但是，我可以自己建立自己的对象
   3. 对外界提供一个方法，返回自己建立的这个对象
   4. 不能用new建立对象，但是我调用类中的一个对外方法，获取到该类的对象

代码实现
   1.私有化构造函数
   2.自己可以访问自己的构造函数，这个对象能是匿名的吗？不能
   3.提供公共函数，返回自己建立的对象  s 就OK了
   4.既然不能建立对象，调用getInstance方法，但是方法可以被类名调用
*/  
  
饿汉式

1. class Single{  
   
2.     private Single(){} //构造函数帮对象进行初始化  
   
3.     private static Single s = new Single();//private是为了不让外部类访问变量改值  
   
4.     //因为下面静态了，静态不能访问非静态，所以之类也要加上static  
   
5.     public static Single getInstance(){   
   
6.     //Single是类类型变量,static是为了给类调用  
   
7.       return s;//返回s的值  
   
8.     }  
   
9.     public void show(){  
   
10.       System.out.pringln("你好，我好大家好")；  
    
11.     }  
    
12. }  
    
13.   
    
14. class SingTest{  
    
15.     public static void main(String[] args){  
    
16.         Single s  = Single.getInstance();  
    
17.         Single s1 = Single.getInstance();//调用类方法， 类名.方法  
    
18.         s.show();  
    
19.         s1.show();//打印输出语句  
    
20.         System.out.println(s);  
    
21.         System.out.println(s1);//打印2个返回来的地址值，看是不是同一个堆内存里的对象  
    
22.     }  
    
23. }  

复制代码