单例设计模式，到底要怎么用呢，具体来说什么是单例设计模式？饿汉式和懒汉式区别又是什么呢？
饿汉式。
class Single
{
        private static final Single s = new Single();
        private Single(){}
        public static Single getInstance()
        {
                return s;
        }
}
懒汉式

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;
        }
}

单例的意思就是 只有一个实例可供使用.
比如,系统只有一个窗口管理,或者一个数据库访问点等,创建太多的类完全是没有意义的.

通过static final类修饰该Field,使其不可被重复创建.
饿汉式,就是在单例类被创建时,该类的对象就被创建了,随时可以使用..
很方便,但是如果没有使用该单例类的话,则可能会浪费资源.

懒汉式,是在被调用时,才创建对象. 因为CPU的切换机制的问题,
懒汉式存在安全问题,或者多线程访问时,出现异常而创建多个对象.
这样就违背了单例类的初衷.
所以懒汉式一般需要对其加锁 (synchronized) 来同步.
虽然同步的都是线程安全的,但是效率低下.

饿汉式单例类是为了应用设计出来的,所以一般都会使用,资源也就不是浪费了.

//饿汉式
class Single
{
        private static final Single s = new Single();//特点什么都不管首先new一个对象放在那里
        private Single(){}//为了保证对象就那么一个，私有构造函数
        public static Single getInstance()//返回那个对象
        {
                return s;
        }
}
懒汉式

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;
        }
}

单例就是不管什么时候，别人调用的都是那一个对象，不会出现第二个，节省资源，也是为了不出现别的对象

单例设计模式的特点

• 单例设计模式保证一个类只有一个实例。
• 要提供一个访问该类对象实例的全局访问点。
  

单例设计模式要点
     对一些类来说，只有一个实例是很重要的。例如很多时候对于某个系统只需要拥有一个全局对象，这样有利于我们协调系统的整体行为。再比如说某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。从而简化了在比较复杂的环境下配置管理。
     单例模式最重要的就是要保证一个类只有一个实例并且这个类易于被访问，那么要怎么做才能保证一个类具有一个实例呢？一个全局变量使得一个对象可以被访问，但是这样做却不能防止你实例化多个对象。一个更好的办法就是，让该类自身负责保存它的唯一实例。并且这个类保证没有其他的实例可以被创建。
保证一个对象的唯一总结如下

• 为了避免其它程序过多的建立该类的对象，先禁止其它程序建立该类对象实例（将构造器私有化）
• 为了方便其它程序访问该类的对象，只好在本类中自定义一个对象，由1可知该对象是static的，并对外提供访问方式。
  

饿汉式举例

1. class Singleton1
   
2. {
   
3.     //保存该类对象的一个实例，饿汉式的做法即在声明的同时初始化该对象
   
4.     private static Singleton1 modle = new Singleton1();
   
5.     //将构造函数私有化，不对外提供构造函数
   
6.     private Singleton1(){}
   
7.     //向外提供访问该对象的方法
   
8.     public static Singleton1 getInstance()
   
9.     {
   
10.         return modle;
    
11.     }
    
12. }
    

复制代码

懒汉式举例

1. 
   
2. class Singleton2
   
3. {
   
4.     //保存该对象的一个实例，懒汉式的做法即在声明的同时并不初始化对象
   
5.     private static Singleton2 modle = null;
   
6.     //将构造函数私有化，不对外提供函数
   
7.     private Singleton2(){}
   
8.     //向外提供访问该类对象的方法
   
9.     public static Singleton2 getINstance()
   
10.     {
    
11.         if(modle == null)
    
12.             modle = new Singleton2();
    
13.         return modle;
    
14.     }
    
15. }

复制代码

单例模式存在的原因是为了不让外界通过构造方法来创建对象
也就是说只能创建一个对象
由它的定义就可以总结它的特点有：
1、构造必须是私有的，这样外界才不会通过构造方法来创建这个类的对象
2、要想外界创建一个单例的对象，它就必须要有一个返回类型为自身类型的静态方法
3、因为这个静态方法的返回值是自身类型，所以他就要有一个静态的、本类类型的属性，并且要给这个属性进行初始化
由单例的特点我们可以总结出他的基本格式是

1. //定义一个单例
   
2. public class SingleDemo {
   
3.         /*
   
4.          * 这是饿汉式的代码
   
5.          * 饿汉式是指属性在创建的时候就已经进行了初始化，
   
6.          * 每次创建单例对象的时候都会为属性进行一个初始化
   
7.          */
   
8.         //创建一个静态的自身类型的属性，并进行初始化，
   
9.         private static SingleDemo instance = new SingleDemo();
   
10.         //私有的构造方法
    
11.         private SingleDemo(){}
    
12.         //公共的静态的自身类型的方法
    
13.         public static SingleDemo getInstance(){
    
14.                 return instance;
    
15.         }
    
16. }
    
17. /*
    
18. * 这是懒汉式
    
19. * 懒汉式只有当你调用他的属性的时候，也就是通过调用它的方法来创建对象的时候，才会进行初始化
    
20. * 当懒汉式完成一个初始化后，再调用就不用再进行初始化了，这样提高了效率，但是会造成线程的不安全
    
21. * 所以一般单例都是用饿汉式
    
22. */
    
23. class Single{
    
24.         //创建一个静态的自身类型的属性
    
25.         private static Single instance;
    
26.         //私有的构造方法
    
27.         private Single(){}
    
28.         //公共的静态的额返回值是自身类型的方法
    
29.         public static Single getInstance(){
    
30.                 //在这进行判断，这个属性是不是已经完成过赋值，如果没有完成那么就给属性进行初始化
    
31.                 if(instance == null){
    
32.                         //为属性进行初始化
    
33.                         instance = new Single();
    
34.                 }
    
35.                 //如果完成过初始化，那么就直接返回
    
36.                 return instance;
    
37.         }
    
38. }

复制代码