单例设计模式：
1，        懒汉式：（单例延迟加载）
class Single
{
        private static Single s = null; // 将成员变量私有化静态化，将其共享在静态区中并禁止外界访问。
        private Single() // 将构造函数私有化，禁止外界创建对象
        {
        }
        public static Single getInstance()  // 提供公开的得到对象的方法。
        {
                if(s==null)
                {
                        s = new Single();
                }
                return s;
        }
       
}
2，饿汉式
class Single
{
        // 将其私有并共享。
        private static final Single s = new Single();
        // 私有化构造函数，防止外界创建构造函数。
        private Single()
        {
               
        }
        // 提供公开的得到对象的构造方法。
        public static Single getInstance()
        {
                return s;
        }
       
}

学习了。。

lz懒汉式的getInstance()方法还得加上同步锁啊，否则的话几个线程并发调用，就可能创建多个对象，还造成内存泄漏，就不是单例模式了 修改代码如下：
class Single
{
        private static Single s = null; // 将成员变量私有化静态化，将其共享在静态区中并禁止外界访问。
        private Single() // 将构造函数私有化，禁止外界创建对象
        {
        }
        public synchronized static Single getInstance()  // 提供公开的得到对象的方法。
        {
                if(s==null)
                {
                        s = new Single();
                }
                return s;
        }
        
}

楼上代码还可优化，给锁再加一个if，通过双层判断提高效率
class Single
{
        private static Single s = null;
        private Single()
        {
        }
        public static Single getInstance()//提供getInstance方法获取对象
        {
                if(s==null)
                {
                        synchronized(Single.class)
                        {                               
                                if(s==null)
                                        s = new Single();
                        }
                }
                return s;
        }
}

许涛 发表于 2012-2-9 20:19
楼上代码还可优化，给锁再加一个if，通过双层判断提高效率
class Single
{

你加上这句有必要么？

最初的理想 发表于 2012-2-9 21:04
你加上这句有必要么？

这貌似毕老师课上讲的。

public static synchronized Single getInstance()
{
        if(s==null)
        {
                s = new Single();
        }
        return s;
}
代码如果这样写，是不是每次都要对锁进行判断，代码执行效率自然比较低

if(s==null)
{
        synchronized(Single.class)
        {                                
                if(s==null)
                        s = new Single();
        }
}
而给锁加一个if判断，当第一个对象被创建后，s!=null，外层if为false，不再对锁判断，锁的判断次数减少 不是提高了效率吗

你要是不考虑执行效率问题 自然是没必要

许涛 发表于 2012-2-9 22:05
public static synchronized Single getInstance()
{
        if(s==null)

受教了，{:3_47:}

最初的理想 发表于 2012-2-10 18:47
受教了，

: ) 互相学习~看到你考试通过了，恭喜~