代码重构 +设计模式六大原则 + 23种设计模式

类的设计  类的使用(组合 泛华)

1 让它的职责尽量单一  2 让它尽可能通过方法参数的输入输出就能完成相关的功能  3 让依赖的类都尽量改为接口而不是实例()

学会单元测试,培养你的重构意识

可能上面说了这么多,还是有很多人并不理解重构。没关系,在这里我教你们一个快速入门的办法,就是单元测试。什么是单元测试,请自行google。单元测试有什么要求?就是要求你要把每个方法都弄成尽量可以测试的。尽量让你的方法变成是可测试的,就是培养你重构意识的利器。


在你要求把方法变成可测试的过程,你就会发现你必须得不断的修改你的方法,让它的职责尽量单一,让它尽量的与上下文无关,让它尽可能通过方法参数的输入输出就能完成相关的功能,让依赖的类都尽量改为接口而不是实例。最终,你就会发觉,这就是重构!而且是在不知不觉中,你重构的功力就会大大提升,你编程的水平也会大大提升!


看到这里,有经验的程序员就会问,你这是在鼓励我使用TDD吗?不,不是的。TDD(Test-Driven Development)鼓励的是测试驱动开发,未开发之前先编写单元测试用例代码,测试代码确定需要编写什么产品代码。这是一种比较先进的开发方法,但是在编程的实践过程中,我认为它过于繁琐,很多中小企业很难实施,更别提我们个人开发者。我这里提倡你用单元测试培养你的重构意识,可以说是一种后驱动,用于提高你的重构能力和重构愿望,你完全可以把我的这个方法称为“TDR(Test-Driven Refactoring)——测试驱动重构”。


当然,在开发之前如果你有意识的让方法可测试,那么你写出来的函数将会是比较高质量的代码。当你的函数都是一个个可重用性高的函数之时,你将会发现,写代码其实就像堆积木一样,可以把一个大型的需求分解成无数细小的功能,很快的把需求实现。


以下是一个超大方法中的一段代码,如果你懂得怎样让这段代码编程一个可测试的方法,那么,恭喜你,你入门了。



面向接口编程<郭新泉>


参数输入输出: 


改进:


 
 openGl 在申请内存存放纹理时,是按照2的幂次方申请的,即480*320的图片,它申请512*512的内存。
 所以在设计时图片时,最好时2的N方。由于不是所有图片都是2的N方。所以通过“拼图”的方法解决。即why要用texturePacker的原因


所谓重构       《重构,改善既有代码的设计》

如果你有耐心看到这里,你应该知道,我并非一个标题党,而这篇文章也许称为“如何在编程中应用重构的思想”更为贴切,但是我不想用这么严肃的标题。


很多编程初学者,或者有多年编程经验的人都觉得阅读别人的代码非常困难,重构更是无从谈起,他们要么对这些代码望洋兴叹,要么就是推翻从来。但是,如果我们有重构的意识,以及在编程的过程中熟悉一些代码调整和优化的小技巧,你自然而然就会培养出重构的能力。


重构,其实很简单:


  • 把基础打牢固

  • 多看点优秀的代码

  • 避免复制粘贴,如果看见重复代码时应该有意识要消灭它

  • 减少对代码生成器的依赖

  • 在处理现有代码时尽量用重构代替重写,在重写之前一定要先重构

  • 尽量让所有的方法都是可测试的


如果你坚持这么去做了,一段时间之后感觉自然就出来了。


重构的目的,是让你的代码更为精简、稳定、能够重用,是最大程度的让功能和业务分离。在重构的过程中,你的阅读代码的能力、写出优秀代码的能力以及系统架构能力都会稳步提升。你成为一个优秀的程序员将指日可待。

等你无法重构的时候再考虑重写

我带过很多优秀的程序员,也与很多优秀的程序员共事过。有一大部分的程序员在看到一套系统不是那么满意,或者存在某些明显的问题,就总是忍不住要把整套系统按自己觉得可以优化的方向来重写,结果,重写结构往往并不令人满意。系统中确实存在很多不合理的地方,但是有不少的这种代码,恰恰是为了解决一些特定场景下的问题的。也就是说,所有的规范以及编程的原则,其实也是有条件限制的,他可能在大部分的时候是正确的,能够指导你完成你的任务,但是,并不是在所有地方都是适用的。比如数据库范式,但实际中我们的设计往往会考虑冗余,这是违背范式的,但是为什么还有那么多人趋之若鹜呢?因为我们可能需要用空间换时间。


如果我们一开始就考虑重写,那么你可能会陷入以下的困境:

  • 需要花更大的精力来完成一些看似简单的BUG


你要知道,有一部分看似错误或者非常不优美的代码,其实恰恰是为了解决一些非常刁钻的问题的。

  • 再也无法兼容老的系统了


你急于把原有系统重写,却往往忽略了对原有系统的兼容,那么你新的系统的推进则会十分缓慢。而老系统的维护,又会陷入及其尴尬的情况。

  • 过度设计,导致重写计划迟迟无法完成


有重写冲动的程序员往往是在架构设计上有一些读到的见解,他们善于利用所学的各种设计模式和架构技巧来建立系统,但是越是想尽可能的利用设计模式,越是陷入过度设计的困局,导致重写的计划迟迟都无法完成。

  • 无法有效利用现有系统已经完成并测试的代码


如果你确实有必要进行重写,我还是建议你把代码尽可能的重构。因为重构之后的系统,能够让你更轻易的重写,又最大限度了保留以前可用的业务代码。


我举个例子,说明如何通过重构更好的利用现有代码的。


我有一个非常庞大的系统,其中有一块功能是用于数据采集、存储、告警管理以及电话、短信等告警通知。大致的结构如下:


class="brush:js;toolbar:false">class MainEngine:IEngine{ public MainEngine(ConfigSettings config){ } public void Start(); public void Stop(); }


需要增加新的业务功能时,程序员写的代码往往是这样的:首先时修改配置类

1
2
3
4
5
6
class ConfigSettings{
public bool NewFuncEnable{get;private set;}
public ConfigSettings(){
NewFuncEnable=xx; //从配置文件读取
}
}

接着修改主程序:


在修改的过程中,往往是根据配置文件来判断新功能是否启用。上面代码会造成什么问题呢:


  • 主程序代码和扩展功能耦合性太强,每增加一个功能都要修改主程序代码,这里非常非常容易出错。尤其是新的人进度开发组,很容易就忘主程序中增加了一些致命性的代码。比如上述的扩展功能,可能是在特定的项目中才会有这个扩展功能,但是,写代码的人忘记增加是否启用的配置选项了,导致所有的项目都应用了这个功能,而这个功能需要特定的表,这样就悲剧了。即使是你增加了配置,也是非常的不美观,因为在通用的版本中使用了这个配置,往往会让定制项目以外的人员感到困惑。

  • 增加扩展功能的人还需对整个MainEngine代码有一定的熟悉,否则,他根本就不知道在Start方法和Stop方法进行newClas的对应方法的调用

  • 如果你打算对这段代码进行重写,那么,你会感到非常的困难,因为你分不清楚newCls这个新实例的作用,要么你花大精力去把所有代码理清楚,要么直接就把这段新增的业务代码去掉了。


那么我们如何对这段代码进行重构呢。首先,我们把新功能注册的代码抽取出来,通过反射来实现新的功能的注册。

修改MainEngine代码

OK,现在我们再来看看怎么实现原来的新增功能:你只需按规范新建一个类,继承ITaskHandler接口,并实现接口的方法。最后在XTGL_ServiceBundle表中新增一条记录即可。我们再来看看这么做有什么好处:


  • 新增的类只需按规范写即可,完全对MainEngine代码没有任何影响。你甚至可以把这个MainEngine代码写在一个新建的Dll中。

  • 新增功能的这个业务类跟原来的代码解耦,非常方便进行新功能的业务测试,而无需考虑原有框架的影响

  • 新增功能的业务类与架构完全分离,我们在重写代码中只要保证接口的稳定性,无论我们怎么把系统架构重写,我们可以马上就重用上原有的业务功能代码。


重构的目标之一,就是把框架和业务完全分离。


有志于深入了解的同学,可以了解下反射、Ioc和插件话编程等。


----------------------------------------------------------------------------------------------------------------------------------------------

class ReadStory
{
public:
    virtual void getContent() = 0;   //二者都应该依赖其抽象;
};


// 将类A修改为依赖接口I,类B和类C各自实现接口I
class  Book : public ReadStory    //
{
public:
    void  getContent()
    {
        CCLOG("by“读书”来讲故事");
    }
};


class Newspaper : public ReadStory
{
public:
    void  getContent()
    {
        CCLOG("by读”报纸“讲故事");
    }
};


//class Tv
//{
//    
//};


class Mother
{
public:
    void setObj(  ReadStory *obj)  // getself() {return s_self;}
    {
        readStory = obj;
    }
    
    void toSonReadStory()
    {
        CCLOG("妈妈开始讲故事");
        
        readStory->getContent() ;
    }
    
    
private:
    ReadStory *readStory;
};

    Mother *_mother = new Mother();
    _mother->setObj(new Newspaper());
    _mother->toSonReadStory();

 

设计模式六大原则(3):依赖倒置原则

定义:高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。

问题由来:类A直接依赖类B,假如要将类A改为依赖类C,则必须通过修改类A的代码来达成。这种场景下,类A一般是高层模块,负责复杂的业务逻辑;类B和类C是低层模块,负责基本的原子操作;假如修改类A,会给程序带来不必要的风险。

解决方案:将类A修改为依赖接口I,类B和类C各自实现接口I,类A通过接口I间接与类B或者类C发生联系,则会大大降低修改类A的几率。

         依赖倒置原则基于这样一个事实:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建起来的架构比以细节为基础搭建起来的架构要稳定的多。在java中,抽象指的是接口或者抽象类,细节就是具体的实现类,使用接口或者抽象类的目的是制定好规范和契约,而不去涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成。

         依赖倒置原则的核心思想是面向接口编程,我们依旧用一个例子来说明面向接口编程比相对于面向实现编程好在什么地方。场景是这样的,母亲给孩子讲故事,只要给她一本书,她就可以照着书给孩子讲故事了。代码如下:

[java]  view plain copy
  1. class Book{  
  2.     public String getContent(){  
  3.         return "很久很久以前有一个阿拉伯的故事……";  
  4.     }  
  5. }  
  6.   
  7. class Mother{  
  8.     public void narrate(Book book){  
  9.         System.out.println("妈妈开始讲故事");  
  10.         System.out.println(book.getContent());  
  11.     }  
  12. }  
  13.   
  14. public class Client{  
  15.     public static void main(String[] args){  
  16.         Mother mother = new Mother();  
  17.         mother.narrate(new Book());  
  18.     }  
  19. }  

运行结果:

妈妈开始讲故事
很久很久以前有一个阿拉伯的故事……

        运行良好,假如有一天,需求变成这样:不是给书而是给一份报纸,让这位母亲讲一下报纸上的故事,报纸的代码如下:

[java]  view plain copy
  1. class Newspaper{  
  2.     public String getContent(){  
  3.         return "林书豪38+7领导尼克斯击败湖人……";  
  4.     }  
  5. }  

        这位母亲却办不到,因为她居然不会读报纸上的故事,这太荒唐了,只是将书换成报纸,居然必须要修改Mother才能读。假如以后需求换成杂志呢?换成网页呢?还要不断地修改Mother,这显然不是好的设计。原因就是Mother与Book之间的耦合性太高了,必须降低他们之间的耦合度才行。

我们引入一个抽象的接口IReader。读物,只要是带字的都属于读物:

[java]  view plain copy
  1. interface IReader{  
  2.     public String getContent();  
  3. }  

Mother类与接口IReader发生依赖关系,而Book和Newspaper都属于读物的范畴,他们各自都去实现IReader接口,这样就符合依赖倒置原则了,代码修改为:

[java]  view plain copy
  1. class Newspaper implements IReader {  
  2.     public String getContent(){  
  3.         return "林书豪17+9助尼克斯击败老鹰……";  
  4.     }  
  5. }  
  6. class Book implements IReader{  
  7.     public String getContent(){  
  8.         return "很久很久以前有一个阿拉伯的故事……";  
  9.     }  
  10. }  
  11.   
  12. class Mother{  
  13.     public void narrate(IReader reader){  
  14.         System.out.println("妈妈开始讲故事");  
  15.         System.out.println(reader.getContent());  
  16.     }  
  17. }  
  18.   
  19. public class Client{  
  20.     public static void main(String[] args){  
  21.         Mother mother = new Mother();  
  22.         mother.narrate(new Book());  
  23.         mother.narrate(new Newspaper());  
  24.     }  
  25. }  

运行结果:

妈妈开始讲故事
很久很久以前有一个阿拉伯的故事……
妈妈开始讲故事
林书豪17+9助尼克斯击败老鹰……

    这样修改后,无论以后怎样扩展Client类,都不需要再修改Mother类了。这只是一个简单的例子,实际情况中,代表高层模块的Mother类将负责完成主要的业务逻辑,一旦需要对它进行修改,引入错误的风险极大。所以遵循依赖倒置原则可以降低类之间的耦合性,提高系统的稳定性,降低修改程序造成的风险。

    采用依赖倒置原则给多人并行开发带来了极大的便利,比如上例中,原本Mother类与Book类直接耦合时,Mother类必须等Book类编码完成后才可以进行编码,因为Mother类依赖于Book类。修改后的程序则可以同时开工,互不影响,因为Mother与Book类一点关系也没有。参与协作开发的人越多、项目越庞大,采用依赖导致原则的意义就越重大。现在很流行的TDD开发模式就是依赖倒置原则最成功的应用。

         传递依赖关系有三种方式,以上的例子中使用的方法是接口传递,另外还有两种传递方式:构造方法传递setter方法传递,相信用过Spring框架的,对依赖的传递方式一定不会陌生。
在实际编程中,我们一般需要做到如下3点:

  • 低层模块尽量都要有抽象类或接口,或者两者都有。
  • 变量的声明类型尽量是抽象类或接口。
  • 使用继承时遵循里氏替换原则。

        依赖倒置原则的核心就是要我们面向接口编程,理解了面向接口编程,也就理解了依赖倒置。

---------------------

类图:

类图知识点:

1.类图分为三部分,依次是类名、属性、方法

2.以<<开头和以>>结尾的为注释信息

3.修饰符+代表public,-代表private,#代表protected,什么都没有代表包可见。

4.带下划线的属性或方法代表是静态的。

5.对类图中对象的关系不熟悉的朋友可以参考文章:设计模式中类的关系

设计模式六大原则(6):开闭原则

定义:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。

问题由来:在软件的生命周期内,因为变化、升级和维护等原因需要对软件原有代码进行修改时,可能会给旧代码中引入错误,也可能会使我们不得不对整个功能进行重构,并且需要原有代码经过重新测试。

解决方案:当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化。

         开闭原则是面向对象设计中最基础的设计原则,它指导我们如何建立稳定灵活的系统。开闭原则可能是设计模式六项原则中定义最模糊的一个了,它只告诉我们对扩展开放,对修改关闭,可是到底如何才能做到对扩展开放,对修改关闭,并没有明确的告诉我们。以前,如果有人告诉我“你进行设计的时候一定要遵守开闭原则”,我会觉的他什么都没说,但貌似又什么都说了。因为开闭原则真的太虚了。

         在仔细思考以及仔细阅读很多设计模式的文章后,终于对开闭原则有了一点认识。其实,我们遵循设计模式前面5大原则,以及使用23种设计模式的目的就是遵循开闭原则。也就是说,只要我们对前面5项原则遵守的好了,设计出的软件自然是符合开闭原则的,这个开闭原则更像是前面五项原则遵守程度的“平均得分”,前面5项原则遵守的好,平均分自然就高,说明软件设计开闭原则遵守的好;如果前面5项原则遵守的不好,则说明开闭原则遵守的不好。

         其实笔者认为,开闭原则无非就是想表达这样一层意思:用抽象构建框架,用实现扩展细节。因为抽象灵活性好,适应性广,只要抽象的合理,可以基本保持软件架构的稳定。而软件中易变的细节,我们用从抽象派生的实现类来进行扩展,当软件需要发生变化时,我们只需要根据需求重新派生一个实现类来扩展就可以了。当然前提是我们的抽象要合理,要对需求的变更有前瞻性和预见性才行。

         说到这里,再回想一下前面说的5项原则,恰恰是告诉我们用抽象构建框架,用实现扩展细节的注意事项而已:单一职责原则告诉我们实现类要职责单一;里氏替换原则告诉我们不要破坏继承体系;依赖倒置原则告诉我们要面向接口编程;接口隔离原则告诉我们在设计接口的时候要精简单一;迪米特法则告诉我们要降低耦合。而开闭原则是总纲,他告诉我们要对扩展开放,对修改关闭。

         最后说明一下如何去遵守这六个原则。对这六个原则的遵守并不是是和否的问题,而是多和少的问题,也就是说,我们一般不会说有没有遵守,而是说遵守程度的多少。任何事都是过犹不及,设计模式的六个设计原则也是一样,制定这六个原则的目的并不是要我们刻板的遵守他们,而需要根据实际情况灵活运用。对他们的遵守程度只要在一个合理的范围内,就算是良好的设计。我们用一幅图来说明一下。

        图中的每一条维度各代表一项原则,我们依据对这项原则的遵守程度在维度上画一个点,则如果对这项原则遵守的合理的话,这个点应该落在红色的同心圆内部;如果遵守的差,点将会在小圆内部;如果过度遵守,点将会落在大圆外部。一个良好的设计体现在图中,应该是六个顶点都在同心圆中的六边形。

        在上图中,设计1、设计2属于良好的设计,他们对六项原则的遵守程度都在合理的范围内;设计3、设计4设计虽然有些不足,但也基本可以接受;设计5则严重不足,对各项原则都没有很好的遵守;而设计6则遵守过渡了,设计5和设计6都是迫切需要重构的设计。

         到这里,设计模式的六大原则就写完了。主要参考书籍有《设计模式》《设计模式之禅》《大话设计模式》以及网上一些零散的文章,但主要内容主要还是我本人对这六个原则的感悟。写出来的目的一方面是对这六项原则系统地整理一下,一方面也与广大的网友分享,因为设计模式对编程人员来说,的确非常重要。正如有句话叫做一千个读者眼中有一千个哈姆雷特,如果大家对这六项原则的理解跟我有所不同,欢迎留言,大家共同探讨。

 下面是前面5项设计原则的链接

1.  单一职责原则(Single Responsibility Principle)

2.  里氏替换原则(Liskov Substitution Principle)

3.  依赖倒置原则(Dependence Inversion Principle)

4.  接口隔离原则(Interface Segregation Principle)

5.  迪米特法则(Law Of Demeter)

同时为了方便想收藏的朋友,下面给出word版本的下载。

word版本下载链接:设计模式六大原则






  • 17
    点赞
  • 85
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
完整的C#设计模式PDF版 C#设计模式(1) 4 一、 C# 面向对象程序设计复习 5 二、 设计模式举例 5 三、 先有鸡还是先有蛋? 7 四、 大瓶子套小瓶子还是小瓶子套大瓶子? 8 五、 .net本质 9 C#设计模式(2) 11 一、 "开放-封闭"原则(OCP) 12 二、 里氏代换原则(LSP) 12 C#设计模式(3) 19 三、 依赖倒置原则(DIP) 19 四、 接口隔离原则(ISP) 20 五、 合成/聚合复用原则(CARP) 21 六、 迪米特法则(LoD) 22 C#设计模式(4)-Simple Factory Pattern 24 一、 简单工厂(Simple Factory)模式 24 二、 Simple Factory模式角色与结构: 24 三、 程序举例: 25 四、 Simple Factory模式演化 27 五、 优点与缺点: 29 C#设计模式(5)-Factory Method Pattern 30 一、 工厂方法(Factory Method)模式 30 二、 Factory Method模式角色与结构: 30 三、 程序举例: 31 四、 工厂方法模式与简单工厂模式 33 五、 Factory Method模式演化 34 六、 Factory Method模式与其它模式的关系 35 七、 另外一个例子 35 C#设计模式(6)-Abstract Factory Pattern 38 一、 抽象工厂(Abstract Factory)模式 38 二、 Abstract Factory模式的结构: 39 三、 程序举例: 41 四、 在什么情形下使用抽象工厂模式: 44 五、 抽象工厂的起源 45 六、 Abstract Factory模式在实际系统中的实现 46 七、 "开放-封闭"原则 50 C#设计模式(7)-Singleton Pattern 50 一、 单例(Singleton)模式 50 二、 Singleton模式的结构: 51 三、 程序举例: 51 四、 在什么情形下使用单例模式: 52 五、 Singleton模式在实际系统中的实现 53 六、 C#中的Singleton模式 55 C#设计模式(8)-Builder Pattern 57 一、 建造者(Builder)模式 57 二、 Builder模式的结构: 58 三、 程序举例: 58 四、 建造者模式的活动序列: 62 五、 建造者模式的实现: 62 六、 建造者模式的演化 68 七、 在什么情况下使用建造者模式 69 C#设计模式(9)-Prototype Pattern 70 一、 原型(Prototype)模式 70 二、 Prototype模式的结构: 71 三、 程序举例: 71 四、 带Prototype Manager的原型模式 73 五、 浅拷贝与深拷贝 77 六、 Prototype模式的优点与缺点 79 C#设计模式(10)-Adapter Pattern 80 一、 适配器(Adapter)模式 80 二、 类的Adapter模式的结构: 81 三、 类的Adapter模式示意性实现: 81 四、 对象的Adapter模式的结构: 83 五、 对象的Adapter模式示意性实现: 84 六、 在什么情况下使用适配器模式 85 七、 一个实际应用Adapter模式的例子 85 八、 关于Adapter模式的讨论 87 C#设计模式(11)-Composite Pattern 88 一、 合成(Composite)模式 88 二、 合成模式概述 88 三、 安全式的合成模式的结构 90 四、 安全式的合成模式实现 91 五、 透明式的合成模式结构 93 六、 透明式的合成模式实现 94 七、 使用合成模式时考虑的几个问题 97 八、 和尚的故事 98 九、 一个实际应用Composite模式的例子 98 C#设计模式(12)-Decorator Pattern 101 一、 装饰(Decorator)模式 101 二、 装饰模式的结构 102 三、 装饰模式示例性代码 103 四、 装饰模式应当在什么情况下使用 106 五、 装饰模式实际应用的例子 106 六、 使用装饰模式的优点和缺点 110 七、 模式实现的讨论 111 八、 透明性的要求 111 九、 装饰模式在.NET中的应用 112 C#设计模式(13)-Proxy Pattern 113 一、 代理(Proxy)模式 113 二、 代理的种类 114 三、 远程代理的例子 114 四、 代理模式的结构 115 五、 代理模式示例性代码 115 六、 高老庄悟空降八戒 117 七、 不同类型的代理模式 118 八、 代理模式实际应用的例子 119 设计模式(14)-Flyweight Pattern 122 一、 享元(Flyweight)模式 122 二、 单纯享元模式的结构 122 三、 单纯享元模式的示意性源代码 123 四、 复合享元模式的结构 125 五、 一个咖啡摊的例子 127 六、 咖啡屋的例子 130 七、 享元模式应当在什么情况下使用 133 八、 享元模式的优点和缺点 134 设计模式(15)-Facade Pattern 134 一、 门面(Facade)模式 134 二、 门面模式的结构 134 三、 门面模式的实现 135 四、 在什么情况下使用门面模式 135 五、 一个例子 136 六、 使用门面模式的设计 140 设计模式(16)-Bridge Pattern 144 一、 桥梁(Bridge)模式 144 二、 桥梁模式的结构 145 三、 桥梁模式的示意性源代码 146 四、 调制解调器问题 149 五、 另外一个实际应用Bridge模式的例子 153 六、 在什么情况下应当使用桥梁模式 158 设计模式(17)-Chain of Responsibility Pattern 158 一、 职责链(Chain of Responsibility)模式 160 二、 责任链模式的结构 160 三、 责任链模式的示意性源代码 160 四、 纯的与不纯的责任链模式 163 五、 责任链模式的实际应用案例 163 六、 责任链模式的实现 168 设计模式(18)-Command Pattern 168 一、 命令(Command)模式 168 二、 命令模式的结构 168 三、 命令模式的示意性源代码 169 四、 玉帝传美猴王上天 172 五、 命令模式的实现 172 六、 命令模式的实际应用案例 173 七、 在什么情况下应当使用命令模式 177 八、 使用命令模式的优点和缺点 178 设计模式(19)-Observer Pattern 178 一、 观察者(Observer)模式 178 二、 观察者模式的结构 179 三、 观察者模式的示意性源代码 180 四、 C#中的Delegate与Event 183 五、 一个实际应用观察者模式的例子 187 六、 观察者模式的优缺点 191 设计模式(20)-Visitor Pattern 192 一、 访问者(Visitor)模式 192 二、 访问者模式的结构 193 三、 示意性源代码 194 四、 一个实际应用Visitor模式的例子 198 五、 在什么情况下应当使用访问者模式 202 六、 使用访问者模式的优点和缺点 203 设计模式(21)-Template Method Pattern 204 一、 模板方法(Template Method)模式 204 二、 模版方法模式的结构 204 三、 模板方法模式的示意性代码 205 四、 继承作为复用的工具 207 五、 一个实际应用模板方法的例子 208 六、 模版方法模式中的方法 210 七、 重构原则 211 设计模式(22)-Strategy Pattern 211 一、 策略(Strategy)模式 211 二、 策略模式的结构 212 三、 示意性源代码 212 四、 何时使用何种具体策略角色 215 五、 一个实际应用策略模式的例子 215 六、 在什么情况下应当使用策略模式 218 七、 策略模式的优点和缺点 218 八、 其它 219 C#设计模式(1)

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值