private NumberMachine(){
               
        }
        public static NumberMachine getInstance(){
                return instance;
        }
        private static NumberMachine instance = new NumberMachine();

刚看了张老师的银行调度系统，，里面提到了很重要的单例模式，如上，问下大家这么写有什么好处呢

单例模式就是同一时间只能存在一个该类对象，这种对象一般都是有重要或特殊用途的，就像一个军队只能有一个司令一样。

对象建立一次并且只建立一次，别人访问的时候只是访问这一个对象，减少线程数，节省内存开支，除此外单例模式是为了确保在整个应用期间只有一个对象,以达到用户的特定的使用目的。

class Singleton
{
    //在内部产生本类的实例化对象，将属性封装
   private static Singleton instance = new Singleton();
   private Singleton(){}  //此处将构造方法进行封装
   public static Singleton getInatance()   //通过静态方法取得Singleton类的实例
   {
       return instance;
   }
}

public class SingleDemo
{
     public static void main(String args[])
    {
        Singleton s1 = Singleton.getInstance();   //访问类中的静态方法，取得对象实例
        Singleton s2 = Singleton.getInstance();

    }
}

以上程序中虽然声明了2个Singleton对象，但是实际上所有的对象都只使用instance的引用，即不管外面如何使用，最终结果只有一个实例化对象存在，内存占用情况如下图所示

有些东西单例是很自然的。比如说现在为太阳系设计一个系统。
有个接口 叫 Planet(星球),有一个实现类叫Earth表示地球，地球只有一个，怎么办，用单例。

这是从面相对象实践上说的。单纯从编程的角度出发，单例可以节省不必要的内存开销，屏蔽对象创建的复杂性，如果你知道spring并且知道bean默认是单例的，也许会有点感觉，为什么要这样。

单例设计模式的好处是对象的复用。
举个简单的例子：计算机的回收站就是一个单例模式，当你把D盘中的文件删除时这个文件会调用回收站把删除的文件暂时放在回收站中；当你在C盘中删除文件时，此时这个文件也会调用回收站把文件放在回收站中，并且这回收站和前面的那个回收站是同一个回收站。所以当你打开回收站时就可以同时看到D盘和C盘删除的文件。

单例设计模式分为懒汉式和饿汉式 你的这个应该这样写
public class NumberMachine{
     private static   NumberMachine instance = new NumberMachine(); //当然加个  final 更好，即不允许创建该类的更多对象   //凡是被静态所修饰的无论是属性或者函数都表示被对象所共享。 另该static对象在内存中的存储位置发生变化，不再存储在堆内存中  由于是共享的所以当是静态函数或者属性时无论创建几个对象，在内存中其实还是这一个，即节约内存空间
  private  NumberMachine(){}
         public static NumberMachine getInstance(){
                 return instance;
         }
}
懒汉式：
public class NumberMachine{
         private  static  NumberMachine  instance=null;
         private  void  NumberMachine(){}
         public  static  NumberMachine   getInstance(){
                               if(instance==null){
                                  instance= new  NumberMachine();//对象被延迟加载，所以叫做懒汉式
                      return  instance;}
}
}   //单例设计模式总体来说，就是只允许创建该类的一个对象。

{:soso_e179:}谢谢各位

这种方式的优点是： 因为只有一句话，线程比较安全（相对于懒汉式）
         
缺点： 类一加载，该对象就存在，如果对象太大。太浪费内存。而且生命周期随类的消失才消失。

懒汉式：

    优点：懒加载。在调用的时候才创建对象。
    缺点：线程不安全。如果方法上加锁会影响性能。就算用双重判断锁，也有缺点。

其实单例最好的实现方式是内部类：
代码如下：

class Single {
        private Single(){}
        
        private static class SingleHolder{
                public static final Single instance=new Single();
        }
        
        public static Single getInstance(){
                return SingleHolder.instance;
        }
        
}
这种方式兼具饿汉式和懒汉式优点。而且，JLS(Java Language Sepcification)会保证这个类的线程安全。

具体请看我的帖子：  http://bbs.itheima.com/thread-30600-1-1.html