设计模式学习总结(一)

前言：推荐几本相关的书：（1）Head First Design Patterns曾经买Head First系列的时候买的一本书，是java语言的案例，但是完全不影响你了解设计模式。

这系列的书就是有很多图，做快速了解建议买。

（2）大话设计模式1个月前买的，看作者简介是名老师，里面就是菜鸟和大鸟的对话举出很多例子，案例也相当不错。

这本书最起码让我感觉特别不错。

（3）重构与模式这本是必须要看的一本书，前几张讲了什么是重构，什么是模式。

然后两者之间的关系。

后边是是讲设计模式的动机，做法，实例，变体。

也不分什么创建，行为，结构什么的。

最后一章是重构的实现。

一．设计原则单一职责原则告诉我们实现类要职责单一；里氏替换原则告诉我们不要破坏继承体系；依赖倒置原则告诉我们要面向接口编程；接口隔离原则告诉我们在设计接口的时候要精简单一；迪米特法则告诉我们要降低耦合。

而开闭原则是总纲，他告诉我们要对扩展开放，对修改关闭。

1.开闭原则OCP(Open-Close Principle)【开指的是对扩展开放，关指的对修改关闭。

】我把它理解为“一国两制”原则。

一国两制怎么说：香港澳门继承了中国这个类，表示说：一个中国不可改变，但针对与港澳实际情况，他们实行的是资本主义经济。

2.单一职责原则RRP（Single Responsibility Principle）【一个类应该只有一个发生变化的原因。

】高内聚低耦合这就是我们写程序的目标，但是很多时候高耦合会在不经意间就产生了，这大多是因为职责扩散造成的。

这个原则最好理解，又最容易违背这个原则。

原因就是职责这个家伙不好确认。

3.依赖倒转原则DIP(Dependency Inversion Principle)【抽象不应当依赖于细节，细节应当依赖于抽象；高层实现不依赖底层实现。

】想想让你封装一个类的时候你首先会做什么。

会先封装接口，再写实现。

｛#总工说这样处理才是合理的。

原因就在这#｝。

面向接口编程而非实现。

这个原则在我看来也是面向对象设计的标志。

举个例子：usb是不是所有的的电脑都能通过usb接口连接。

如果联想的usb接口和苹果的usb接口不一样，那么你买了一个200多的USB键盘，结果是不是就不能公用了。

4.里氏代换原则Liskov Subsitution Principle(LSP)【子类可以扩展父类的功能，但不能改变父类原有的功能】里氏代换原则是对“开-闭”原则的补充。

实现“开-闭”原则的关键步骤就是抽象化。

而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

有这么一句话：里氏代换原则是继承复用的一个基础。

检验你是否遵循了里氏代换原则的方法：如果调用的是父类的话，那么换成子类也完全可以运行。

动物 dongwu=new 猫（）；其中【把猫换成狗】也是正常的就说明你是遵循这个原则的。

｛注：我在网上看过一个“企鹅是鸟不会飞”的例子，这也是自己犯这个错误的原因。

这例子在这不说了，你可以试着去找一下去。

｝5.接口隔离原则Interface Segregation Principle(ISP)从字面上来讲就是一个不要把接口写的太臃肿。

查资料大致说的就是有两种分离方式一种是“定制服务”和“角色隔离”。

在工作当中有没有这样的问题存在：同一个模块，因为没有安排得当两个人都去开发，最后一定是有个人白做了。

所以有时候，项目管理软件就显的那么的有必要。

定制服务:大致来讲就是我针对一个客户端，我的一些方法放到一个接口里，另一个客户端我的一个类放在另一个接口里面。

角色隔离：是指一个客户端有多个方法，多个方法写多个接口。

【友情提醒：接口也不要分的太细，要不然结果就是接口太多。

】6.迪米特原则Law of Demeter 又称Least Knowledge Principle(LKP)最少知识原则【我的理解就是：这个原则不希望类与类之间不要建立直接联系。

】简单来说就是不和陌生人说话。

类与类之间一定会存在互相调用的？网上查了一下，说可以用友元类来转达。

降低类本身和成员的访问权限，达到【低耦合，高内聚】是其目的。

【和ISP接口隔离原则一样，限制类与类之间的通信。

ISP限制的是宽度，而LoD 迪米特原则限制的是通信的广度和深度。

】。

外观模式（Facade Pattern)和中介者模式（Mediator Pattern）就使用了迪米特法则。

一．设计模式【创建型的设计模式】1.单例模式原则：确保一个类只有一个实例,并提供一个全局访问点举例：打印机就是最好的例子，打印就是纸打印一个对象多的话就进行排队。

主要解决：一个全局使用的类频繁地创建与销毁。

优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

//懒汉模式public class SingletonClass{private static SingletonClass instance=null;public static synchronized SingletonClass getInstance(){if(instance==null{instance=new SingletonClass();}return instance;}private SingletonClass(){}}//饿汉式//对第一行static的一些解释// 允许我们在一个类里面定义静态类。

比如内部类（nested class）。

//把nested class封闭起来的类叫外部类。

//我们不能用static修饰顶级类（top level class）。

//只有内部类可以为static。

public class Singleton{//在自己内部定义自己的一个实例，只供内部调用private static final Singleton instance = new Singleton();private Singleton(){//do something }//这里提供了一个供外部访问本class的静态方法，可以直接访问public static Singleton getInstance(){return instance;}}// 双重锁的形式。

public class Singleton{private static Singleton instance=null;private Singleton(){//do something }public static Singleton getInstance(){if(instance==null){synchronized(Singleton.class){if(null==instance){instance=new Singleton();}}}return instance;}}1.简单工厂模式原则：封装改变，既然要封装改变，自然也就要找到改变的代码，然后把改变的代码用类来封装和降低对象之间的耦合度举例：夏天到了，去撸串的季节到了。

老板来10个板筋，5个腰子，20个串，10个鸡胗。

一会老板就给你上来了。

这就是工厂模式。

老板烤串就是工厂，你和你的兄弟们就是顾客。

只需要照着单子点即可，不需要知道老板具体是怎么做的。

主要解决：主要解决接口选择的问题。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

这并不是什么好事。

///<summary>///单位信息工厂模式///</summary>public class unit_factory{public static unit create_unit_factory(string unitname){unit unit = null;switch (unitname){case"room":{unit = new unti_rooms();break;}case"floor":{unit = new unti_floor();break;}case"building":{unit = new unti_building();break;}case"area":{unit = new unti_areas();break;}}return unit;}}///<summary>///单位信息基类///</summary>public class unit : wx_sbs_redis{public fee_power_query fee_power_query;public virtual result get_info(){result ret = null;return ret;}}///<summary>///楼称派生类///</summary>class unti_floor : unit{string sign = fee_power_id + "|"+ fee_power_query.uid + "|"+ fee_power_query.area_id + "|"+ fee_power_query.building_id + "|" + fee_power_query.cardno + "|" + fee_power_query.code;if (!fee_power_query.valid_floors())return Result((int)errcode.Interval,fee_power_query.msg);List<cs_power> list = new List<cs_power>();var recents = new fee_recents().pick("fee" +fee_power_query.uid, "power_floor");var ret = new wxwebapi<i_gate_fee_power>().invoke(i =>i.floors, gatapower);return ret;}}///<summary>///房间派生类///</summary>class unti_rooms : unit{}///<summary>///楼派生类///</summary>class unti_building : unit{}///<summary>///校区派生类///</summary>class unti_areas : unit{}1.工厂模式原则：一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。