两者的特点以及在什么场合使用？？

求大神支招

当我们需要在内存中生成唯一对象时就可以用单例。比如说要向同一个银行账户存钱，取钱，这个就可以用单例。
饿汉式在对象一初始化就创建对象，而懒汉是在判断对象为空时才创建对象。
一般建议使用饿汉式，因为没有线程同步问题。懒汉式存在同步问题，有可能在线程抢占资源时重复创建对象，
解决方法就是加上同步代码块。

饿汉式：上来就new 一个实例，懒汉式：用到时才new一个实例
懒汉式存在死锁问题，若解决了死锁问题，效率就会比较低
写程序时建议使用饿汉式

二楼正解     其实从恶汉式和懒汉式这名字上就能看出来

是饿汉，哈哈 不过看情况而定了。 对内存方面要求的话不知道怎么使用。

来学习一下

谢谢了，学习了，自己还是有很多不足

都是getInstance()获取对象
饿汉式是在
private Single instance=null;
getInstance(){
instance=new Single();
return instance;
}
懒汉式是在
private Single instance=new Single();
public Single getInstance(){
return instance;
}

一般提倡使用饿汉式，因为线程安全

饿汉是来什么吃什么，二话不说直接建立一个对象。懒汉是等有人用它了 才建立对象

懒汉式不安全，第一次加载慢，因为要new对象，建议用饿汉式，保证只有一个实例对象，

饿汉式：先初始化对象
懒汉式：对象是方法被调用时才初始化，也叫做对象的延时加载

饿汉式类一加载就存在了；懒汉式类一加载就为null（调用方法的时候才在内存中建立对象）
饿汉式：Single类一进内存，就已经创建好了对象，
懒汉式：Single类进内存，对象还没有存在，只有调用方法时才建立对象

学习一下

学习了，说的很清楚啊

视频貌似有讲啊:)

学习一下！

单例设计模式的作用：使一个类在内存中只存在一个对象。
我们知道，既然在内存中有且只有一个对象，我们知道构造方法可以创建对象，那么产生一个对象的前提即让构造方法私有化，不让外部访问。这样只能在内部访问，外部不可访问，既然是单个对象，则是类名直接调用，所以其中变量应该被static。那么我来详细概述下单例设计模式的细节。
单例设计模式实现步骤：
①将构造函数初始化。
例如：private Single(){}
②在类中创建一个本类对象。
例如：private static Single s= newSingle()；
③提供一个访问方法可以获取到该对象。
例如：public static Single getInstance（）
                             {
                                 return s ;
                        }
好了，罗嗦了这么多，我们还是看看如何用代码实现单例的细节吧！

单例设计模式有两种表现形式：
①“饿汉式”
②“懒汉式”
我们先来看看传说中的饿汉式：
public class Single
{
        private Single(){}//构造方法私有化
        private static Single instance = new Single();//实例化对象
        public static Single getInstance()
        {
                return instance;//暴露方法返回instance的对象
        }
}
饿汉式的特点：创建对象的同时就直接实例化对象。
那我们在看看“懒汉式”：
public class Single
{
        private Single(){}//构造方法私有化
        private static Single instance = null;
        public static Single getInstance()
        {
                if (instance==null)//这里判断看instance是否为空
                {
                        instance = new Single();//对象为空，实例化对象
                }
                return instance;//返回对象
        }
}
懒汉式的特点：方法被加载时才进行初始化操作，“懒汉式”又被称为延迟加载设计模式。
仔细观察，懒汉式的代码是有弊端的，我们来看看。
当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。
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;//返回变量
        }
}
上面加了几处判断，我们来分析下：
① s==null 是为了减少判断，增加效率
②synchronized (Single.class)为了保证线程安全
③if (s == null)是为了判断对象是否为空
为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。所以我们不建议使用“懒汉式”，饿汉式简单高效，安全。

好了，到这里，我们的单例设计模式也基本接近尾声了，发现对于单例的解读也不是非常难，本身设计模式的目的就是为了方便编程才有了它的用武之地，所以设计模式掌握了其本质，也不会有那种“高大上”的阴影啦，好了，我们继续加油吧！

写的不错啊

饿汉式，懒汉式。都是只创建一个对象，只是懒汉式有延时性。

都是大神啊，学习了