在银行管理系统中分为三部分的设计 有一部分是取号机  在程序中用到了单例设计模式，对于单例设计模式有什么作用还是不明白 还有个地方  下面这段代码返回了自己的对象  为何下面还要实例化自己的对象  直接实例化不就行了吗  搞不懂
private NumberMachine(){}//这里看单例设计模式 忘了 首先构造方法私有化
         public static NumberMachine getInstance(){
                 return instance;//返回自己的对象
         }
         private static NumberMachine instance=new NumberMachine();//自己创建对象
       
      

单例模式 要保证内存只有一份，首先就要把构造方法私有化使外部不可调用。
外部不能实例化对象，那对象只能在类内部实例化，new NumberMachine();//自己创建对象
实例化后要把这个唯一的实例交给外界使用，就要向外提供操作这个实例的方法：getInstance()

单例模式是为了保证一个类在内存中只有一个对象.
1.在单例模式中构造方法是私有的，这样就保证了其他类无法创建本类对象。
2.为了让其他类可以访问本类对象，在本类中添加了一个公共方法（getInstance()），并将此方法设为静态的，通过这个方法其他类可以使用本类对象，而不需要创建。

单例设计模式，这个是老毕视频中的一个还算重要的知识点。单例模式分为懒汉式和饿汉式两种类型，第一种懒汉式是这样的
class single{
       
        private static single s=null;
        private single(){}
        public static single getInstance(){
                if(s==null){
                        synchronized (single.class) {
                                if(s==null)
                                        s=new single();
                        }
                }
                return s;
        }
}
饿汉式的是
class single{
       
        private static single s=new single();
        private single(){}
        public static single getInstance(){
               
                return s;
        }
}
为什么要这样呢？单例设计模式就是想只有一个实例，为了防止new出多个实例，就在本身private构造方法，
然后自身new出一个public实例，让其他类可以获得这个实例，第一个之所以叫懒汉式是因为这个类的s一开始就new出来了；
而后面的那个在方法里面才new出来了。

单例模式：保证内存中只有类的一个实例对象
应用场景：比如读取配置文件的对象，只需要一个，对数据库进行增删改的对象也应保证只有一个，还有游戏中起中央控制器作用的类，也应只有一个
单例模式的两种形态：饿汉式和懒汉式
首先来看饿汉式：提前加载

1. //饿汉式
   
2. public class Single1 {
   
3.         private static Single1 instance = new Single1();
   
4.         private Single1() {}
   
5.         public static Single1 getInstance() {
   
6.                 return instance;
   
7.         }
   
8. }

复制代码

再来看懒汉式：延迟加载

1. //懒汉式
   
2. public class Single2 {
   
3.         private static Single2 instance = null;
   
4.         private Single2() {}
   
5.         public static Single2 getInstance() {
   
6.                 if(instance == null) {
   
7.                         synchronized (Single2.class) {  //加锁防止程序在此处停止，造出创建多个对象
   
8.                                 if(instance == null) {
   
9.                                         instance = new Single2();
   
10.                                 }
    
11.                         }
    
12.                 }
    
13.                 return instance;
    
14.         }
    
15. }

复制代码

上面有位同学写的懒汉式没有加锁，可能会导致多个线程阻塞再唤醒后创建了多个对象，这就失去了单例的意义
因为单例模式的这个对象迟早都要用，所以无所谓延迟加载和提前加载，推荐使用饿汉式

要搞清楚单例的实质，就是你什么时候调用这个类，这个类都是同一个，你咋保证是同一个呢？
  
    假如一个类可以在外部实例化，那么每实例化一个在内存中就会新开辟内存，就无法保证每次调用都是同一个。怎么实现呢？

    就是把构造函数私有化，你外部无法实例化，然后在自己在内部实例化一个，你们谁用都来调这个，就保证了实例是唯一的。

关于单例模式的介绍其实百度已经说的很详细了。
private NumberMachine(){}//这里看单例设计模式 忘了 首先构造方法私有化
         public static NumberMachine getInstance(){
                 return instance;//假如你在这里new一个对象返回，那么就无法实现每次取得的都是同一个对象了。因为他每次都会new一个新的对象
         }
         private static NumberMachine instance=new NumberMachine();//自己创建对象

如果你想在其它类使用该类的对象，而又想只使用这同一个对象，只有一个办法：
当然不能在其它类new，因为你能new一个，就能new两个。
所以，只有在本类中提前把对象创建好，并私有构造方法，才能保证在其它类里面不能new。
但是怎么获得该类对象了？提供对外访问的方法呗。getInstance()应运而生！
要点：单例就是要你使用的对象是同一个。