A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© jackwang 中级黑马   /  2015-3-22 01:04  /  868 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

/*
设计模式:对于解决某一问题最行之有效的解决方案

问题:一个类在内存中只有一个对象存在
解决方案:单例模式

单例模式:饿汉式、懒汉式
实现思想:
1、禁止其他类创建类的对象
2、自己在本类中创建本类对象
3、对外提供一个对该对象的访问方式
实现步骤:
1、将构造函数私有化
2、在类中创建一个本类的对象。
3、用一个方法对外提供本类对象。

*/
/*懒汉式,会出现安全问题,所以需要改进一下,利用的是多线程的技术*/

class Single
{
        private static Single s = null;
        private String name ;
        public void setName(String name)
        {
                this.name = name;
        }
        public  String getName()
        {
                return name;
        }
        private Single(){}
////        为了防止多线程同时进入getInstance()函数内,导致出现创建多个对象存在。
////        而使用了synchronized关键字,使得在任意时间内,只有一个线程可以进入该函数内,其他函数在进入时,
////        需对其进行判断。但是假如了关键字synchronized之后,整个程序的运行效率就降低了,使得所有线程在执行到
////        getInstance()函数时,都要对其进行判断,是否有其他线程正在函数中,有则等待,无则进入,从而使得程序效率降低
//        public static synchronized Single getInstance()
//        {
//                if(s == null)
//                {
//                        s = new Single();
//                }
//                return s;
//        }
        /*懒汉式终极版*/
        public static Single getInstance()
        {
                if(s == null)
                {
                        synchronized (Single.class) //在此处加锁,而不是整个函数加锁,使得判断锁的次数减少,
                        {                                                        //从而使得效率提高
                                if(s == null)
                                {
                                        s = new Single();
                                }
                        }
                }
                return s ;
        }
}

///*懒汉式
//        类的对象延迟创建。
//*/
//class Single
//{
//        private String name;
//        private static Single s = null;
//        public void setName(String name)
//        {
//                this.name = name;
//        }
//        public String getName()
//        {
//                return name;
//        }
//        private Single(){}
//        public static Single getInstance()
//        {
//                if(s == null)
//                {
//                        s = new Single();
//                }
//                return s;
//        }
//}
/*饿汉式:饿汉式是在实际开发中使用的技术,因为其是安全的,类的对象随着类的加载而创建。因为是随着类的
加载而创建,所以是一旦加载该类,类对象就在堆内存中创建了,并将对象的引用赋值给了方法区中的静态类对象的引用。
无论是饿汉式,还是懒汉式,获取类对象的方法必须是静态的,因为只有这样才能够通过类名调用该方法,因为唯一的类
对象在类中成员函数中或者成员变量初始化中才会被创建的。
        实现单例模式必须满足下满几点:
        1、类的初始化函数必须被私有化,也就是必须禁止在类的外部用new创建对象。

        2、因为1存在,所以必须使用 “类名.方法” 的方式获得在类内部用new创建的对象。

        3、因为2存在,所以必须将 “类对象的获取方法” 静态化,从而使得通过类名可以访问到类的成员。

        4、因为3存在,所以必须将类对象的引用静态化,否则不能够在方法中返回类对象的引用(句柄)。

        综上:
                1、类的构造函数必须被私有化
                2、类对象的引用必须是私有化而且是静态化
                3、类对象的获取方法必须是公有化且静态化
                4、类对象的获取方法的调用必须是“类名.方法”的形式

*/
//class Single
//{
//        private String name ;
//       
//        private static Single s = new Single();
//        private Single(){}
//        public void setName(String name)
//        {
//                this.name = name;
//        }
//        public String getName()
//        {
//                return name;
//        }
//        public static Single getInstance()
//        {
//                return s;
//        }
//}
class SingleDemo
{
        public static void main(String[] args)
        {
                Single s1 = Single.getInstance();
                s1.setName("张三");
                System.out.println(s1.getName());
                Single s2 = Single.getInstance();
                s2.setName("李四");
                System.out.println(s2.getName());
        }
}


0 个回复

您需要登录后才可以回帖 登录 | 加入黑马