//这是  看  视频，银行系统的  类，百度也不是很理解，各位大神能不能为小弟讲解一下


package cn.com.stone.interview;

public class NumberMachine {
        //单例
        private NumberMachine(){}
        private static NumberMachine instance = new NumberMachine();
        public static NumberMachine getInstance(){
                return instance;
        }
       
        private NumberManager commonManager = new NumberManager();
        private NumberManager expressManager = new NumberManager();
        private NumberManager vipManager = new NumberManager();
        public NumberManager getCommonManager() {
                return commonManager;
        }
        public NumberManager getExpressManager() {
                return expressManager;
        }
        public NumberManager getVipManager() {
                return vipManager;
        }
       
}

建议把单例看一下 所谓单例就是唯一的 因为银行只有一个取号机器 所以为单例 而机器里面可以选择多种类型的取号器 所以设置为单例

设计模式：解决某一类问题最行之有效的方法。
        单例设计模式：保证一个类在内存中只存在一个对象。
        ：想要保证对象唯一
        1)为了避免其他程序过多的建立该类对象。先禁止其他程序建立该类对象。
        2)还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
        3)为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
        a)将构造函数私有化。
        b)在类中创建一个本类对象。
        c)提供一个方法可以获取到该类对象。

银行里只有一台取票机，取票机可以取3种票。
只能有一台取票机对应的就是只有一个取票机器类的实例对象进行操作。
这个唯一的实例对象操作3种不同的票，酱紫

1. class Single
   
2. {
   
3.         /*
   
4.         private static Single a = new Single();//单例之一的：饿汉式。
   
5.         private Single(){}
   
6.         public static Single getA()
   
7.         {
   
8.                 return a;
   
9.         }*/
   
10.         private static Single a = null;//单例之二的：懒汉式。
    
11.         private Single(){}
    
12.       
    
13.         public static Single getA()
    
14.         {
    
15.                 if(a==null)
    
16.                 {
    
17.                         if(a==null)
    
18.                         {
    
19.                                 synchronized (Single.class)//同步锁。
    
20.                                 {
    
21.                                         a = new Single();
    
22.                                 }
    
23.                         
    
24.                         }
    
25.                 return a;
    
26.                 }
    
27.         }
    
28. }
    
29. class  SingleTest
    
30. {
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 Single x = Single.getA();//保证了对象的唯一性。
    
34.         }
    
35. }
    

复制代码

单例模式的目的是为了保证对象的唯一性。就是要保证其他程序不能随时new对象，所以就需要将构造函数私有化，这样一来其他程序就不能创建本类的对象了。
将构造函数私有化后，在本类中创建一个本类对象。在定义一个方法，返回值类型是本类类型。让其他程序通过该方法就可以获取到该类对象。
单例设计模式分为饿汉式和懒汉式。其代码体现如下：

1. //饿汉式:
   
2. class Single
   
3. {
   
4.         private static Single s = new Single();
   
5.         private Single(){}
   
6.         public static Single getInstance()
   
7.         {               
   
8.                 return s;
   
9.         }
   
10. }
    
11. //懒汉式：
    
12. //单例的延迟加载方式。
    
13. class Single2
    
14. {
    
15.         private static Single2 s = null;
    
16.         private Single2(){}
    
17.         public static Single2 getInstance()
    
18.         {
    
19.                 if(s==null)
    
20.                         s=new Single2();
    
21.                 return s;
    
22.         }
    
23. }
    

复制代码

首先你要理解单列是什么意思，和作用。
在java中，单例存在的意义就是让一个类只存在一个对象，所有访问当他的都是这一个对象，而不是多个对象。
结合上面童鞋的举例，银行取票，就是采用了单列，
假设它不是单列，那么每一个人去取票，就是不同的对象去new一个不同的号，这样岂不是乱套了。
这一对比， 单列不难理解了吧，

下面结合老师讲的视频，
单例常用代码的：饿汉式。
private static Single a = new Single();//
        private Single(){}
        public static Single getA()
        {
                return a;
        }
具体代码和视频，请返回查看比老师的视频详解。
该代码自己new了一个对象放在这里，别提供一个方法传递出对象名，
别人使用时，就是这个对象，用完了，还是这个对象，再来一个人，需要用也是这个对象。
好比你电脑里的记事本，你打开一个记事本，命名，笔记1，你打开一次，改一下，保存，再打开改一下，再保存，始终都是这个笔记1，而你新建一个笔记2，笔记1 是不会变的。（这个举例似乎有点晕，哈哈。）

至于单列的注意事项等，2楼的童鞋具体提到了，非常详细，就不在说了。

以上都是个人理解，有什么不对的地方还请指正，同在学习的苦逼党。

         private NumberMachine(){}
         private static NumberMachine instance = new NumberMachine();
         public static NumberMachine getInstance(){
                 return instance;
         }
这是你的代码，单例很简单，就是为了保证对象的唯一性
一共就三步：
一：私有化构造函数，外面不能创建对象实例；
二：创建本类私有对象，保证可以访问到本类对象；
三：对外提供唯一获取对象的方法；