• 设计模式(一)单例模式:创建模式


    先聊一下关于设计的几个原则
    (1)单一原则(SRP):一个类应该仅有一个引起它变化的原因 :意思就是 (一个类,最好只负责一件事情,并且只有一个引起它变化的原因
    (2)开闭原则(OCP): 应该对扩展开放,但是对修改关闭:意思是(模块通过扩展的方式去应对需求的变化,应该尽量在不修改源代码的基础上面扩展)
    (3)依赖倒置原则(DIP):高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象
             高层模块不应该直接依赖于底层模块的具体实现,而应该依赖于底层的抽象。模块间的依赖是通过抽象发生,不发生直接的依赖关系,依赖关系是通过接口或抽象类为中间件产生的。
    (4)LisKov 替换原则(LSP)(里式替换原则) :子类对象可以替换父类对象的位置    这里如果想了解的更清晰的话 了解一下 (斜变/逆变)
    (5) 接口的隔离原则(IPS):(1)是不应该强行要求客户端依赖于它们不用的接口;(2)是类之间的依赖应该建立在最小的接口上面。简单点说,客户端需要什么功能,就提供什么接口,对于客户端不需要的接口不应该强行要求其依赖;类之间的依赖应该建立在最小的接口上面,这里最小的粒度取决于单一职责原则的划分。
          还有其他 理解不深可就没敢说出来.

    设计模式(1)单例模式(创建模式)

    注意事项:

    1.  允许子类派生
    2. 不要实现 icloneable 接口  https://msdn.microsoft.com/zh-cn/library/system.icloneable.aspx 这个接口继承后可能会导致生成多个示例,违背了模式的原本意思
    3. 不要序列化  理由同上
    4. 不要再多线程下使用,(如果需要再多线程下使用的话见下面举例)

    单利模式作用
     (1)确保一个类只有一个实例;

     (2)提供一个访问它的全局访问点

    利用代码实现一个简洁的单例

     class SingletonClass
        {
            private static volatile SingletonClass instance = new SingletonClass();
            //私有的构造函数
            private SingletonClass()
            {
            }
            public static SingletonClass Newinstance
            {
                get
                {
                    return instance;
                }
            }
        }

               这个类在被调用时 SingletonClass.Newinstance();

               优点:(1)确保一个类只有一个实例;

                         (2)提供一个访问它的全局访问点

               缺点:(多线程环境下就会破坏单利的初衷:会形成多个类的实例)

    利用代码实现  在多线程环境下的单例

      通过双重判断 对资源进行锁定 确保再多线程环境下确保只有一个实例

      注意:代码注释

        class multithreading_Singleton
        {
            //为了以防万一的出现
            //volatile  关键字作用  当编译编译过程中  会对代码进行细微的调整,为了防止代码发生改变保证代码原意不变  多线程使用时有可能会导致 顺序发生改变 导致多个实例的发生       
            private static volatile multithreading_Singleton example = null;
            //声明一个资源锁
            private static object Lock = new object();
            //私有的构造函数
            private multithreading_Singleton()
            {
    
            }
            public static multithreading_Singleton Newinstance
            {
                get
                {
                    //保证多个线程不会同时进入判断
                    if (example == null)
                    {
                        //对资源进行锁定  Lock 只要是object 下的类型就OK了
                        lock (Lock)
                        {
                            if (example == null)
                            {
                                example = new multithreading_Singleton();
                            }
                        }
                    }
                    return example;
                }
            }
        }

    利用代码实现   单线程多线程通用单例

    优点:静态构造函数 在调用时 只会产生一个,系统在默认的情况下仿佛已经对资源加过锁
    缺点是不能带参数   
    原因: (1):静态函数不允许不允许出现访问修饰符
                (2):静态构造函数必须无参数

        class SingletonCurrency
        {
            public static readonly SingletonCurrency example = new SingletonCurrency();
    
            private SingletonCurrency() { }
        }

             下面代码是读上面代码的解释代码:

                  public static readonly SingletonCurrency example = new SingletonCurrency();  等同于省略了静态构造函数,这里的省略不是编译上的省略而是代码上的省略,在系统编译时还是会有一个静态构造的

     class SingletonCurrency_Remark 
        {
            public static readonly SingletonCurrency_Remark example ;
            /// <summary>
            /// 静态构造函数
            /// </summary>
            static SingletonCurrency_Remark()
            {
                example = new SingletonCurrency_Remark();
            }
            private SingletonCurrency_Remark() { }
        }

    推荐书籍     大话设计模式 (中文)   《Head First 设计模式》

    希望大家指出不足之处  谢谢

  • 相关阅读:
    080626 雨(近期目标)
    6月25日 多云
    火一样的冷
    sgu107. 987654321 problem 简单打表 难度:0
    快速切题 sgu 111.Very simple problem 大数 开平方 难度:0 非java:1
    sgu114. Telecasting station 难度:1
    109. Magic of David Copperfield II 构造 难度:2
    sgu108. Selfnumbers 2 滚动数组 打表 难度:1
    快速切题 sgu115. Calendar 模拟 难度:0
    快速切题 sgu117. Counting 分解质因数
  • 原文地址:https://www.cnblogs.com/szlblog/p/8270491.html
Copyright © 2020-2023  润新知