这个模式也是属于创建型模式  ----因为这个模式是学习开发的基本工，都写烂了，我就简单的再给大家写写，加深一下印象。

使用单例模式可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实力对象。

//传说中的饿汉式--开发也都用它，效率高，也安全
public class Singleton {
        //1.静态成员变量，类加载进内存，就创建该对象。独此一份
        private static Singleton mInstance = new Singleton();
        //2.首先私有构造
        private Singleton() {}
        //3.对外提供方法，得到改类实例
        public static Singleton getSingleInstance(){
                return mInstance;
        }
}


//传说中的懒汉式--面试用
public class SingletonLazy {
        //1.静态成员变量
        private static SingletonLazy mInstance = null;
        //2.首先私有构造
        private SingletonLazy() {}
        //3.对外提供方法，得到改类实例
        public static SingletonLazy getSingleInstance(){
                if(mInstance ==null){  //提到效率，可以少加锁，也可以不判断空
                        synchronized(SingletonLazy.class){//保证线程安全
                                if(mInstance == null){//正常的判断是否为null
                                        mInstance = new SingletonLazy();
                                }
                        }
                }
                return mInstance;
        }
}


//静态内部类，单例模式
public class SingletonH {
       
        private static class Holder{
                private static SingletonH INSTANCE = new SingletonH();
        }
        private SingletonH(){}
        public static SingletonH getInstance(){
                //利用静态内部类的方式，也可以保证实例的唯一
                return Holder.INSTANCE;
        }
}

是不是很easy！有什么问题，可以随时提问！

666666666666

66666666666666