1. public class NumberMachine {
   
2.         
   
3.         private NumberMachine(){}
   
4.         private static NumberMachine instance = new NumberMachine();
   
5.         public static NumberMachine getInstance(){
   
6.                 return instance;
   
7.         }
   
8.         
   
9.         private NumberManager commonManager = new NumberManager();/此三个对象为什么不在NumberManager类中实例化，要在这里实例化。
   
10.         private NumberManager expressManager = new NumberManager();//这种是单例设计模式吗？
    
11.         private NumberManager vipManager = new NumberManager();
    
12.         public NumberManager getCommonManager() {
    
13.                 return commonManager;
    
14.         }
    
15.         public NumberManager getExpressManager() {
    
16.                 return expressManager;
    
17.         }
    
18.         public NumberManager getVipManager() {
    
19.                 return vipManager;
    
20.         }
    
21.         
    
22. }
    

复制代码

其实我的想法跟你一样，我看过视频后，自己写的时候就将他们在NumberManager类中实例化了，我认为在NumberManager类中实例化更好理解，上面并不是单例模式；

因为NumberManager是一个父类，是为了向上抽象，以便为外界提供相应的接口调用。而用父类（NumberManager）引用指向子类对象（各种Manager：common、express、vip）也使程序有更好的灵活性与扩展性，这样如果有需求再加个superVip什么的也不必对原有的代码做太大的改动。那么为什么不在NumberManager中实例化呢？我认为一是为了分离！即，将接口与实现分离。当然，在NumberManager中实例化也是可以的，而且刚开始我也是这么做的，不过使用Enum（枚举）实现的——因为我认为枚举也很好的符合了要求而且也有当前代码所实现的一些技术需求（比如：枚举也不允许你new出对象、类型可控制），但枚举的扩展性不好。这种是单例设计模式吗？是的，这是单例模式，针对当前程序来说，构造方法私有，提供公共接口获得类的实例

1. public class NumberMachine {
   
2.         
   
3.         private NumberMachine(){}//单例模式的操作：构造方法私有化
   
4.         private static NumberMachine instance = new NumberMachine();
   
5. //单例模式的操作：自己创建自己的对象
   
6.         public static NumberMachine getInstance(){
   
7. //单例模式的操作：提供获取对象的public方法
   
8.                 return instance;
   
9.         }
   
10.         
    
11.         private NumberManager commonManager = new NumberManager();/此三个对象为什么不在NumberManager类中实例化，要在这里实例化。
    
12. 
    
13. //首先NumberManager是号码机器类，而NumberMachine是管理器类，是生成号码机器的类，这个写是面向对象的思想，
    
14. 
    
15.         private NumberManager expressManager = new NumberManager();//这种是单例设计模式吗？
    
16. //这个不属于单例模式的操作，最上面的才是，构造方法私有化，自己new自己的对象，并且private static的，
    
17. 
    
18.         private NumberManager vipManager = new NumberManager();
    
19.         public NumberManager getCommonManager() {
    
20.                 return commonManager;
    
21.         }
    
22.         public NumberManager getExpressManager() {
    
23.                 return expressManager;
    
24.         }
    
25.         public NumberManager getVipManager() {
    
26.                 return vipManager;
    
27.         }
    
28.         
    
29. }

复制代码

1.         private NumberManager commonManager = new NumberManager();/此三个对象为什么不在NumberManager类中实例化，要在这里实例化。
   
2. 
   
3.         private NumberManager expressManager = new NumberManager();//这种是单例设计模式吗？
   
4. 
   
5.         private NumberManager vipManager = new NumberManager();

复制代码

这是为了提高程序的可扩展性，把NumberManager对于号码管理的共性封装成一个类，只需要使用其实例对象就好了。
NumberMachine提供了三种客户管理办法，就利用NumberManager生成三个对应的管理类对象。
如果需要再添加更多的客户类型，比如是集团客户 groupCustomer ,那么就需要对应的groupManager。
只要在NumberMachine进行构造对象就行了，不用去修改NumberManager的代码。

这更加符合软件设计的高聚合低耦合的要求，让各个部分的耦合性降低，软件扩展性就更好，差错控制也更容易。

并且在这里，NumberMachine设计成单例模式(楼主这里理解成NumberManager也设计成单例，但它不是)，私有化构造函数，内部封装一个唯一的实例对象，仅供调用。
号码生成的控制性就会唯一，不会在线程并发的过程里发生混乱：

NumberMachine-----> |------>commonManager  -----|------>synchronized
                              |------>expressManager -------|
                              |------>vipManager    -----------|

对于每个线程操作唯一的NumberMachine，也就同时利用唯一的commom/express/vipManager生成号码。
因为NumberManager里已经设置了同步函数。因此会保证共享的数据处于临界区内，不会发生并发带来的问题。