分为饿汉式和懒汉式，他们的区别是什么呢？

饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象.
饿汉式单例和懒汉式单例只是两种比较主流和常用的单例模式方法，从理论上讲，任何可以实现一个类只有一个实例的设计模式，都可以称为单例模式。

class Single//饿汉式 调用时直接时初始化
{
        private Single(){}//将构造方法私有化
        private static Single s = new Single();
        public static Single getInstance()
        {
                return s;
        }
}


class Single//懒汉式
{
        private Single(){}
        private static Single s = null;
        public static Single getInstance()//在调用静态方法时才去实例化，较饿汉式就是延迟了一些
        {
                if (s==null)
                {
                        s=new Single();
                       
                }
                return s;
        }
}

/饿汉式
class Single//类一加载，对象就已经存在了。
{
        private static Single s = new Single();

        private Single(){}

        public static Single getInstance()
        {
                return s;
        }
}

//懒汉式
class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
                        //延迟加载形式。
{
        private static Single2 s = null;
        private Single2(){}
        public static Single2 getInstance()
        {
                if(s==null)
                        s = new Single2();
                return s;
        }
}

单例模式指的是整个应用中有且只有一个实例，所有指向该类型实例的引用都指向这个实例。

饿汉式单例：直接将对象定义出来
懒汉式单例：只给出变量，并不将其初始化；

饿汉式，static修饰，随着类的加载而加载，会损耗性能，但是方法相对简单
懒汉式  第一次用的时候相对较慢，因为需要加载！线程，不安全！

下面是单例模式的懒汉式和饿汉式：

public class MySingleton
       {
            //该类只能有一个实例
            //私有无参构造方法
            private MySingleton() { }   

            //该类必须自行创建
            //有2种方式
            private static final  MySingleton ms = new MySingleton();//饿汉式
            //private static TestStream ts = null; //懒汉式

            //提供唯一实例对象
            public static MySingleton getTest()
            {
                 //懒汉式时进行判断
                //if (ms == null) {
                //    synchronized (MySingleton.class) {
                //        if(ms == null) {
                //            ms = new MySingleton();
                //        }
               //    }
               //}     
               return ms;
          }
      }

懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的
时候才会加载。。。。。。

饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。