前言：
推荐几本相关的书：
（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个鸡胗。。。。一会老板就给你上来了。这就是工厂模式。老板烤串就是工
创建型结构型行为型 类Factory Method Adapter In terpreter Template Method 对象 Abstract Factory Builder Prototype Si ngleto n Apapter(对象) Bridge Composite Decorator Fa?ade Flyweight Proxy Chain of Resp on sibility Comma nd Iterator Mediator Meme nto Observer State Strategy Visitor （抽象工厂） 提供一个创建一系列相关或互相依赖对象的接口，而无须制定它们具体的类。 图10-25抽象工厂模式结构图 Abstract Factory 抽象工厂 class Program { static void Main(string[] args) { AbstractFactory factory1 = new Con creteFactory1(); Clie nt c1 = new Clie nt(factory1); c1.Ru n(); AbstractFactory factory2 = new Con creteFactory2(); Clie nt c2 = new Clie nt(factory2); c2.Ru n(); Co nsole.Read(); abstract class AbstractFactory { public abstract AbstractProductA CreateProductA(); public abstract AbstractProductB
设计模式心得体会 7月初的一个周末，准确的说应该是7月1号周六，在网上看到一本《大话设计模式》的书，而且看到很多很好的评论，于是乎，下载了电子书看看，一下子看了几章之后，对设计模式有了个了解，于是继续上网搜些其他资料，进一步了解设计模式。。。最终结论：设计模式是个好东西，具体怎么好，一两句话是无法概括的，也是从那天起，我就决定学习设计模式，于是就看《大话设计模式》，至七月十多号，大概看了一百多页后，感觉有点难，有点看不下去的感觉，于是上网找其他的好方法，无意间发现了李建忠老师的《c#设计模式纵横谈》系列讲座，微软的web cast课程，主要讲解gof的23个设计模式，每个一讲，加上一头一尾，共25讲，试听了一节课后，感觉很有用，于是就抽时间去边听课边看书，并在我的博客里写下笔记，依赖加深印象，二来可以督促我的进度。。。 三个月以来，总算把设计模式学完一遍了，原计划是两个月学完（一星期三个模式），由于。。。计划两个月学完实际花了三个月，感触多多，收获多多——对c#语言有了更进一步的认识，对oo的思想有了更全面的了解。。。 下一步在设计模式方面的计划：巩固并运用设计模式，巩固：把《大话设计模式》，《设计模式》，《设计模式——可
复用的面向对象基础》，《敏捷软件开发：原则、模式与实践》这些书再结合起来系统的看一看，当然还会去买一些我手头上没有的关于设计模式的书；运用：部门前几天也提倡用c#来改版vb程序，我想这是一个很好的平台，正好有机会把理论的东西在实际中应用，理论加实际——唯一的学习方法。。。 下面对各个模式再简单总结一下： 1、创建型模式： singleton：解决的是实例化对象的个数的问题，比如抽象工厂中的工厂、对象池等，除了singleton之外，其他创建型模式解决的都是 new 所带来的耦合关系。 abstract factory：创建一系列相互依赖对象，并能在运行时改变系列。 factory method：创建单个对象，在abstract factory 有使用到。 prototype：通过拷贝原型来创建新的对象。 factory method，abstract factory, builder都需要一个额外的工厂类来负责实例化“一边对象”，而prototype 则是通过原型（一个特殊的工厂类）来克隆“易变对象”。 如果遇到“易变类”，起初的设计通常从factory method 开始，当遇到更多的复杂变化时，再考虑重构为其他三种工
2015程序员个人工作学习计划 程序员个人工作学习计划 新的一年，一切事物充满了活力与生机。新生活意味着新开始，新开始意味着新的挑战。作为即将毕业跨入社会的大学生，我将在这学校生活和社会生活相交织的一年，努力适应变化，迎接新的挑战。 一、工作方面 作为公司的新员工，首先要与同事们相互熟悉，不说认识所有人，至少要认识大部分同事，与大家和睦相处，互相帮助。 分配的工作任务要积极及时的完成，作为新员工，分配到的任务肯定是非重点，繁琐的基础性的事，但是即使是这样，也不能松懈，敷衍了事，基础中才能学到真本事，对待这样的任务更要认真仔细。做好了这样的事，才有可能获得信任和肯定，被任命重要的任务，才能成长起来。 二、学习方面 最为初出校园的新人，必然有很多在实际开发中常用而我却从没有接触过的东西，学校教授的只是基础，进了公司，仍然不能停下学习的步伐。 首先最重要的一点就是在学习过程中有了问题就得及时解决。我的步骤一般是先自己思考问题的答案，自己无法解决则到网络上寻求答案，网上也无法找到可靠的答案则询问周围的同事帮忙解决。认真听他们的讲解，牢牢记住分析问题的思路和方法，以便下次遇到时能尽量自己就能解决问题。 14年需要学习的东西有很多，作为从事web应用开发的的程序员，首先mvc规范必然是要熟练掌握的，这是学校中只是简单提到的东西。首先通过李刚的《轻量级javaee企业应用实战》，对ssh这样的一个mvc思想的架构有一个初步宽泛的了解，()然后在分别对struts，spring，hibernate进行深入了解。根据网上资料，国内较好的struts方面的书是孙卫琴的《精通struts：基于mvc的javaweb设计与开发》，在大体学习了ssh后，就从这本书开始细致的学习这方面的知识，然后是林信良的《spring技术手册》和《prospring中文版》，最后是夏昕的《深入浅出hibernate》。 其次，设计模式的学习也是成为一个好的程序员，甚至是编程艺术家的必经之路。首先看完程杰的《大话设计模式》，对设计模式有一个初步的认识，然后再看gof的《设计模式：可复用面向对象软件的基础》， ericfreeman&elisabethfreemanwithkathysierra&bertbates的《headfirstdesignpatterns》，joshuakerievsky的《重构与模式》等等书籍。要成为一个好的java程序员，还有很长的路要走，只是看些肯定是不够的，最重要的还是实践经验，希望2015年能让向前迈出一大步。篇二：程序员的2015年9个计划 程序员的2015年9个计划 制定新年计划是我们最喜欢做的事情之一，我们总是会在年底的时候对新的一年有一个很好的计划，但后来就把它们都抛到脑后了，直到最后全部忘记。也许，我们的计划总是过于宏伟，很多事情都是做不到的，甚至显得遥不可及。但是，今年一定会有所不同，这篇文章就是专为程序员准备的九大新年计划，供各位程序员参考。 1. 学习一门新的不同风格的编程语言 这是很需要的一件事，因为如果你只了解一种语言，它就会局限你解决问题的能力和你的职业发展。所以在新的一年，你应该花些时间学习一门新的语言，体验不同的编程风格，并学以致用。 2. 提高你的已有技能 3. 活动你的手指，但不是在键盘上
Java设计模式之心得 UML 1.案例图:系统角色和使用案例和它们之间的关系 2.类图: 类图中的关系 1.一般化关系：继承,接口 2.关联关系：类与类之间的联系Driver中的Car 3.聚合关系：整体与个体之间的关系 4.合成关系：强关联，整体包含部分，整体代表部分的生命周期，不能共享 5.依赖关系：类与类之间的连接，如Person包含Car和House 3.时序图： 每个步骤的流程图 4.状态图：一系列对象的内部状态及状态变化和转移 5.合作图：相互关系图 6.构建图：部署的软件构件之间的关系 7.活动图： 8.部署图： 面向对象的设计原则： 1.设计目标：可扩展性、可维护性、可插入性、可复用性 2.设计原则：开闭原则、里氏替换原则、依赖倒转原则、接口隔离原则、组合\聚合复用原则、迪米特法则 开闭原则：
OCP作为OO的高层原则，主张使用“抽象(Abstraction)”和“多态(Polymorphism)”将设计中的静态结构改为动态结构，维持设计的封闭性。 一句话：“Closed for Modification;Open for Extension”——“对变更关闭；对扩展开放”。开闭原则其实没什么好讲的，我将其归结为一个高层次的设计总则。OCP的动机很简单：软件是变化的。不论是优质的设计还是低劣的设计都无法回避这一问题。OCP说明了软件设计应该尽可能地使架构稳定而又容易满足不同的需求。 重要的步骤： 1.抽象化 2.对可变性的封装原则 里氏替换原则： 1.分析对象时必须明确是Is-a还是Has-a的关系,任何基类适应的地方，子类一定适用依赖倒转原则： 要依赖于抽象，不要依赖于具体。简单的说，依赖倒置原则要求客户端依赖于抽象耦合。原则表述：抽象不应当依赖于细节；细节应当依赖于抽象；要针对接口编程，不针对实现编程。 接口隔离原则： 使用多个专门的接口比使用单一的总接口要好。广义的接口：一个接口相当于剧本中的一种角色，而此角色在一个舞台上由哪一个演员来演则相当于接口的实现。因此一个接口应当简单的代表一个角色，而不是一个角色。，如果系统设计多个角色的话，则应当每一个角色都由一个特定的接口代表。狭义的接口（Interface）:接口隔离原则讲的就是同一个角色提供宽、窄不同的接口，以对付不同的客户端。 组合\聚合复用原则： 要尽量使用组合/聚合，而不是使用继承来达到目的 原因： 继承复用的缺点：静态复用 什么使用使用继承：a.满足is-a的关系，而不是has-a的关系 b.满足lsp原则 优点：a.简洁 b.父类修改某个方法，子类能获得 迪米特法则： 一个对象或模块应该和其它对象和模块尽量少的通信（高内聚），涉及的模式有：门面模式，调停者模式，前端控制器模式，业务代表模式，dao模式
注： 文档内容基本上来自于网上，并加上自己的理解而成。有的觉得网友总结得非常好，就完全照搬下来，供学习之用。然而，有的摘抄并没有加上原链接和出处，请谅解。 通过命令模式，通过在客户端和具体的命令之间添加一层Invoker，剪断了客户端和具体服务提供者之间的耦合，降低了两者之间的耦合度，同时也增加了灵活性，比如我们可以灵活的某一个请求的服务提供者，通过单独的服务提供者Command类，可以很方便的提供redo和undo的功能等等，这些都是命令模式的优势。 在软件系统中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合，比如要对行为进行“记录、撤销/重做、事务”等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为抽象为对象，实现二者之间的松耦合。这就是命令模式（Command Pattern） 即命令模式的核心是要解决“行为请求者”和“行为实现”都之间的耦合，以达到灵活多变的效果。 目标： 客户只需要发命令，而不需要管命令是如何被执行的！Command pattern From Wikipedia,the free encyclopedia In object-oriented programming,the command pattern is the method and values for the method parameters.
?
? ? ? ? ? ? ? ? ? ? [edit]Uses
[edit]Structure
UPDATE:The explanation for the Receiver block above should be "The actual work to be done by the command(action)" [edit]Terminology 1.Ambiguity. 2.The term command is ambiguous.For example,move up,move up may refer to a single
23种设计模式趣味讲解 对设计模式很有意思的诠释，呵呵，原作者不详。 创立型模式 1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，固然口味有所不同，但不管你带MM往麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类离开。花费者任何时候需要某种产品，只需向工厂恳求即可。花费者无须修正就可以接纳新产品。毛病是当产品修正时，工厂类也要做相应的修正。如：如何创立及如何向客户端供给。 2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同处所的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM 我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这必定比美军在伊拉克用的翻译机好卖） 建造模式：将产品的内部表象和产品的天生过程分割开来，从而使一个建造过程天生具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变更，客户不必知道产品内部组成的细节。建造模式可以强迫履行一种分步骤进行的建造过程。 3、FACTORY METHOD—请MM往麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。 工厂方法模式：核心工厂类不再负责所有产品的创立，而是将具体创立的工作交给子类往做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的串口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE—跟MM用QQ聊天，必定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要） 原始模型模式：通过给出一个原型对象来指明所要创立的对象的类型，然后用复制这个原型对象的方法创立出更多同类型的对象。原始模型模式容许动态的增加或减少产品类，产品类不需要非得有任何事先断定的等级结构，原始模型模式实用于任何的等级结构。毛病是每一个类都必须配备一个克隆方法。 5、SINGLETON—俺有6个美丽的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，
课程名称设计模式课程设计 设计题目设计模式在FileUpload 组件中的应用 班号专业软件工程 学生姓名 ###### 指导教师（签字） 课程设计说明书
目录 第一章设计模式概述 1.1模式与设计模式 1.2设计模式的定义 1.3设计模式的基本要素 1.4设计模式的分类 第二章FileUpload组件简介 2.1FileUpload组件由来及使用 2.2 FileUpload组件的工作原理 2.3 FileUpload组件中的部分接口、类简介 第三章设计模式在FileUpload组件中的应用 3.1 工厂方法模式在FileUpload组件中的应用 3.2 策略模式在FileUpload组建中的应用 3.3 迭代器模式在FileUpload组建中的应用 3.4 FileUpload组件中的重要类图 第四章结束语 4.1 收获与总结 4.2 参考文献 第一章设计模式概述
1.1模式与设计模式 模式起源于建筑业而非软件业，模式(Pattern)之父—美国加利佛尼亚大学环境结构中心研究所所长Christopher Alexander博士。Alexander给出了关于模式的经典定义:每个模式都描述了我们环境中不断出现的问题，然后描述了解决这个问题解决方案的核心，通过这种方式，我们可以无数次的重用那些已有的解决方案，无需再重复相同的工作，也可以用一句话概括为：模式是在特定环境中解决问题的一种方案。 最早将Alexander博士的模式思想引入软件工程方法学的是以四人组（Gang of Four,GoF）自称的四位著名软件工程学者，他们在1949归纳发表的23中在软件开发中使用频率较高的设计模式，旨在用模式来统一沟通面向对象方法学在分析、设计和实现间的鸿沟。 GoF将模式的概念引入软件工程领域，标志着软件模式的诞生，软件模式是将模式的一般概念应用于软件开发领域，即软件开发的总体指导思想或参照样板软件模式并非仅限于设计模式，还包括架构模式、分析模式、和过程模式等。 从1987年Kent Beck和Ward Cunningham借鉴Alexander的模式思想在程序开发中开始应用一些模式到目前设计模式在软件开发的广泛应用,Sun公司的Java SE/Java EE平台和Microsoft公司的.net平台设计中就应用了大量的设计模式。再设计模式领域，下一的设计模式是指GoF的《设计模式：可复用面向对象软件的基础》一书中包含的23中经典设计模式，不过设计模式并不仅仅只有这23中，随着软件开发技术的发展，越来越多的模式不断诞生并得以广泛应用。 1.2设计模式的定义 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码的可靠性。 1.3设计模式的基本要素 1.3.1模式名称(Pattern name)
Gof的23种设计模式 从2005年初听说设计模式，到现在虽然已经8年多了，但GoF的23种模式依然盛行，当然GoF提出这些模式的 年代更加久远（1995年）。在工作的过程中，陆陆续续接触了GoF的大部分模式，我记得在2008年的时候就想总结一下设计模式（最近想做的两件事情），最后因为各种原 因也没有完成。最近这段时间正好是职业空档期，没什么事儿做，就把之前看过的设计模式翻出来整理了一下，于是就有了上面几篇文章。整理设计模式的过程，也是一个深刻理解面向对象设计的过程。通过对各个模式的回顾，让我更能够明白前辈们关于面向对象设计提出的各种“最佳实践”，特别是S.O.L.I.D，我觉得在这里再说一次，也不算矫情。S：单一职责原则（Single Responsibility Principle, SRP），一个类只能有一个原因使其发生改变，即一个类只承担一个职责。 O：开放-封闭原则（Open-Close Principle, OCP），这里指我们的设计应该针对扩展开放，针对修改关闭，即尽量以扩展的方式来维护系统。 L：里氏替换原则（Liskov Subsititution Principle, LSP），它表示我们可以在代码中使用任意子类来替代父类并且程 序不受影响，这样可以保证我们使用“继承”并没有破坏父类。
I：接口隔离原则（Interface Segregation Principle, ISP），客户端不应该依赖于它不需要的接口，两个类之间的依赖应该建立在最小接口的基础上。这条原则的目的是为了让那些使用相同接口的类只需要实现特定必要的一组方法，而不是大量没用的方法。 D：依赖倒置原则（Dependence Inversion Principle, DIP），高层模块不应该依赖于低层模块，两者应该都依赖于抽象；抽象不依赖于细节，而细节应该依赖于抽象。这里主要是提倡“面向接口”编程，而非“面向实现”编程。设计模式，从本质上讲，是针对过去某种经验的总结。每种设计模式，都是为了在特定条件下去解决特定问题，离开这些前提去讨论设计模式，是没有意义的。下面，我们快速回顾GoF的23种模式。工厂方法 意图：定义一个用户创建对象的接口，让子类去决定具体使用哪个类。 适用场合：1）类不知道它所要创建的对象的类信息；2）类希望由它的子类来创建对象。抽象工厂 意图：提供一个创建一系列相关或者相互依赖的对象的接口，而无须指定它的具体实现类。 适用场合：1）系统不依赖于产品是如何实现的细节；2）系统的产品族大于1，而在运行时刻只需要某一种产品族；3）属于同一个产品族的产品，必须绑在一起使用；4）所有的
23种设计模式的通俗理解【转】 1、FACTORY 工厂方法 追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER 抽象工厂 MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱 你”builder。（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD 建造者模式 请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE 原型模式 跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 5、SINGLETON 单态模式 俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。[b:9ceca65206]结构型模式[/b:9ceca65206] 6、ADAPTER 适配器模式 在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我) 适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，
设计模式总结 一、创建型模式 简单工厂 简单工厂最大优点在于工厂类中包含了必要的逻辑判断（switch），根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。 工厂方法 工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 工厂方法模式实现时，客户端要觉定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在时修改客户端。 抽象工厂 抽象工程模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无需制定它们具体的类。 原型模式 原型模式（Prototype）,用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。（拷贝对象的引用地址《浅表副本》）。.NET在System命名空间中提供了ICloneable接口（里面唯一的方法Clone()）,只要实现这个接口就可以完成原型模式。 建造者模式 建造者模式（Builder）,将一个复杂对象的构造过程与它的表示分离，使得同样的构造过程可以创建不同的表示。
如果使用建造者模式，那么用户就只需建造的类型就可以得到它们，而具体建造的过程和细节就不需要知道了。——抽象不应该依赖细节，细节应该依赖于抽象。建造者模式主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。 单例模式 单例模式（Singleton），保证一个类仅有一个实例，并提供一个访问它的全局访问点。 二、行为型模式 观察者模式 观察者模式（Observer），定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生改变时，会通知所有观察者对象，使它们能自动更新自己。 当一个对象的改变需要同时改变其他对象的时候，而且他不知道具体有多少对象有待改变，应该考虑使用观察者模式。观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不依赖于具体，从而使得各自的变化都不会影响另一边的变化。 模板方法模式 模板方法模式（TemplateMethod），定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构可重复定义该算法的某些特定的步骤。 模板方法模式是通过把不变行为搬移到超类，去除子类中德重复代码来体现它的优势。模板方法模式就是提供了一个很好的代码复用平台。 状态模式 状态模式（State），当一个对象的内在状态发生改变时允许改变其行为，这个对象看起来像是改变了其类。
创建型模式 1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM 去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖） 建造模式：将产品的部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的部表象的产品对象。建造模式使得产品部表象可以独立的变化，客户不必知道产品部组成的细节。建
造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。 工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要） 原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。
设计模式学习总结 引子 刚开始学习设计模式的时候.感到这些模式真的非常抽象。今年下半年以来.随着我们组工作重点的转移.以及我在小组中角色的变化.我开始有条件提出自己对新系统的设计想法。在设计过程中.我发现了很多设计模式的用处.也确实应用了很多设计模式.这让我越来越感到设计模式的重要性.因此我写了这十余篇专门介绍设计模式的文章.作为我的学习笔记。 《设计模式——可复用的面向对象软件的基础》（有趣的是.梅宏一再在组会上强调应该译成重用）中介绍了一共23种设计模式.我一共写了19个设计模式（其中三个和在一篇文章中）.余下四个.考虑到该模式的应用范围我就没有介绍。在写这些文章时.其中的很多例子都是我在实践中提炼出来的.当然也有很大一部分是《设计模式》中的例子。不过.这四个人（四人团）生活的年代里现在已经很远了.所以它们的例子也很古老。 让我们更加设计模式 设计模式是个好东西.它给出了很多设计中的技巧与思路.对于很多优秀的设计.它加以总结与提炼。设计模式并非四人团拍脑瓜想出来的.而是他们搜集了其他人优秀的设计.加以整理出来的.他们不是这些模式的创造者.仅仅是整理者。 应用设计模式会给我们带来很多好处：软件将变得更加灵活.模块之间的耦合度将会降低.效率会提升.开销会减少。更重要的.设计模式就好像美声唱法中的花腔.让你的设计更加漂亮。总的来说.设计模式似乎将软件设计提升到艺术的层次。 设计模式已经被广泛的应用了.在现在很多的图形界面框架都使用了MVC模式.大量跌代器模式的应用.彻底改变了我们对集合的操作方式。不仅如此.应用了设计模式的设计.往往被看成为优秀的设计。这是因为.这些设计模式都是久经考验的。 模式不是模型 在学习和使用设计模式的时候.往往出现一个非常严重的误区.那就是设计模式必须严格地遵守.不能修改。但是设计模式不是设计模型.并非一成不变。正相反.设计模式中最核心的要素并非设计的结构.而是设计的思想。只有掌握住设计模式的核心思想.才能正确、灵活的应用设计模式.否则再怎么使用设计模式.也不过是生搬硬套。
设计模式概念：一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。设计模式要素：模式名称、问题、举例、末态环境、推理、其他有关模式、已知的应用。设计模式分类：创建型、结构型、行为型。 创建型模式功能：1.统所使用的具体类的信息封装起来； 2.类的实例是如何被创建和组织的。 创建型模式作用：1.封装创建逻辑，不仅仅是new一个对象那么简单。 2.封装创建逻辑变化，客户代码尽量不修改，或尽量少修改。 常见的创建型模式：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。常见的结构型模式：代理模式、装饰模式、适配器模式、组合模式、桥梁模式、外观模式、享元模式。 常见行为型模式：模板方法模式、命令模式、责任链模式、策略模式、迭代器模式、中介者模式、观察者模式、备忘录模式、访问者模式、状态模式、解释器模式。单一职责原则：一个类应该只有一个职责。 优点：降低类的复杂性；提高类的可读性；提高代码的可维护性和复用性；降低因变更引起的风险。 里氏替换原则： 优点：代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；提高代码的可重用性；提高代码的可扩展性；提高产品或项目的开放性。 缺点：1.继承是入侵式的。只要继承，就必须拥有父类所有属性和方法。 2.降低代码的灵活性。子类必须拥有父类的属性和方法，使子类收到限制。 3.增强了耦合性。当父类的常量、变量和方法修改时，必须考虑子类的修改，这种 修改可能造成大片的代码需要重构。 依赖倒置原则：高层模块不应该依赖低层模块，两者都依赖其抽象；抽象不依赖细节；细节应该依赖于抽象。 在Java中的表现：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；接口或抽象类不依赖于是实现类； 实现类依赖于接口或抽象类。 接口隔离原则：1.一个类对另外一个类的依赖性应当是建立在最小的接口上的 2.一个接口代表一个角色，不应当将不同的角色交给一个接口。 3.不应该强迫客户使用它们的不同方法。 如图所示的电子商务系统在三个地方会使用到订单类：一个是门户，只能有查询方法；一个是外部系统，有添加订单的方法；一个是管理后台，添加、删除、修改、查询都要用到。“原子”在实践中的衡量规则： 1.一个接口只对一个子模块或者业务逻辑进行分类。 2.只保留接口中业务逻辑需要的public方法。 3.尽量修改污染了的接口，若修改的风险较大，则可采用适配器模式进行转化处理。 4.接口设计应因项目而异，因环境而异，不能照搬教条。 迪米特法则：（表述）只与你直接的朋友们通信；不要跟“陌生人”说话；每一个软件单位 对其他的单位都只有最少的了解，这些了解仅局限于那些与本单位密 切相关的软件单位。 对迪米特法则进行模式设计有两个：外观模式、中介者模式。 开闭原则：一个软件实体应当对扩展开放，对修改关闭。 重要性体现：提高复用性；提高维护性；提高灵活性；易于测试
桥接模式——Bridge 将抽象部分与它的实现部分分离，使它们都可以独立地变化。 什么叫抽象与它的实现分离，这并不是说，让抽象类与其派生类分离，因为这没有任何 意义。实现指的是抽象类和它的派生类用来实现自己的对象。由于实现的方式有多种，桥接模式的核心意图就是把这些实现独立出来，让它们独自地变化。这就使得每种实现的变化不会影响其他实现，从而达到应对变化的目的。 桥接模式的结构图如下： 将抽象部分与它的实现部分分离，这不是很好理解，我的理解就是实现系统可能有很多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。也就是说，在发现我们需要多角度去分类实现对象，而只用继承会造成大量的类增加，不能满足开放—封闭原则时，就应该要考虑桥接模式。 单例模式——Singleton 单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。 通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象，一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且他可以提供一个访问该实例的方法。 单例模式的结构图如下：
单例模式因为Singletion类封装它的唯一实例，这样它可以严格控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。 当在多线程情景下使用时，需要对GetInstance全局访问点加锁。适配器模式(Adapter) 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼 容而不能一起工作的哪些类可以一起工作。 也就是说系统的数据和行为都是正确的但接口不符时，我们应该考虑用适配器模式，目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致的情况，比如说需要对早期代码复用一些功能等应用上很有实际价值。 适配器又两种类型，类适配器模式和对象适配器模式。但由于类适配器通常是通过多重继承实现的，而C#、https://www.doczj.com/doc/b618171446.html,、JAVA等语言都不支持多重继承，也就是一个类只有一个父类，所以，我们这里主要讲对象适配器。 适配器模式的结构图如下：
23种设计模式UML 类图及对应示例代码(一) 收藏 1.DoFactory.GangOfFour.Abstract.Structural Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 using System; namespace DoFactory.GangOfFour.Abstract.Structural { ///
class MainApp { ///
Java设计模式
目录 1. 设计模式3 1.1 创建型模式4 1.1.1 工厂方法5 1.1.2 抽象工厂9 1.1.3 建造者模式14 1.1.4 单态模式20 1.1.5 原型模式22 1.2 结构型模式25 1.2.1 适配器模式26 1.2.2 桥接模式29 1.2.3 组合模式35 1.2.4 装饰模式40 1.2.5 外观模式45 1.2.6 享元模式50 1.2.7 代理模式55 1.3 行为型模式59 1.3.1 责任链模式59 1.3.2 命令模式64 1.3.3 解释器模式69 1.3.4 迭代器模式73
1.3.5 中介者模式79 1.3.6 备忘录模式83 1.3.7 观察者模式88 1.3.8 状态模式94 1.3.9 策略模式98 1.3.10 模板方法102 1.3.11 访问者模式106
1. 设计模式(超级详细) 内容简介 有感于设计模式在日常开发中的重要性，同时笔者也自觉对设计模式小有心得，故笔者*写二十三种设计模式的简单例子、 并整理二十三种设计模式的理论部分，综合汇总成这份Java设计模式（疯狂J*va联盟版），希望对大家有所帮助。 本份帮助文档主要是为了向读者介绍二十三种设计模式，包括模式的描述，适用性，模*的组成部分，并附带有简单的例 子和类*，目的是为了让读*了解二十三种*计模式，并能方便的查阅各种设计模*的用法及注意点。 所附的例子非常简单，慢慢的引导读者从浅到深了解设计模式，并能从中享受设计的乐趣。 由于每个人对设计*式的理解都不尽一致，因此，可能本文档的例子*有不恰当的地方，还望各位读者指出不恰当的地方。 欢迎登录疯狂J*va联盟进行技术交流，疯狂Java联盟的论坛宗旨是： 所有的技术发帖，均有回复。 疯狂Java联盟网址： 笔者简介
前言： 推荐几本相关的书： （1）Head First Design Patterns 曾经买Head First系列的时候买的一本书，是java语言的案例，但是完全不影响你了解设计模式。这系列的书就是有很多图，做快速了解建议买。 （2）大话设计模式 1个月前买的，看作者简介是名老师，里面就是菜鸟和大鸟的对话举出很多例子，案例也相当不错。这本书最起码让我感觉特别不错。 （3）重构与模式 这本是必须要看的一本书，前几张讲了什么是重构，什么是模式。然后两者之间的关系。后边是是讲设计模式的动机，做法，实例，变体。也不分什么创建，行为，结构什么的。最后一章是重构的实现。 一．设计原则 单一职责原则告诉我们实现类要职责单一；里氏替换原则告诉我们不要破坏继承体系；依赖倒置原则告诉我们要面向接口编程；接口隔离原则告诉我们在设计接口的时候要精简单一；迪米特法则告诉我们要降低耦合。而开闭原则是总纲，他告诉我们要对扩展开放，对修改关闭。 1.开闭原则OCP(Open-Close Principle) 【开指的是对扩展开放，关指的对修改关闭。】 我把它理解为“一国两制”原则。一国两制怎么说：香港澳门继承了中国这个类，表示说：一个中国不可改变，但针对与港澳实际情况，他们实行的是资本主义经济。 2.单一职责原则RRP（Single Responsibility Principle） 【一个类应该只有一个发生变化的原因。】 高内聚低耦合这就是我们写程序的目标，但是很多时候高耦合会在不经意间就产生了，这大多是因为职责扩散造成的。这个原则最好理解，又最容易违背这个原则。原因就是职责这个家伙不好确认。
设计模式课程设计 题目：画图程序 学院：信息科学与技术学院 专业：软件工程 学号：20092384 姓名：陈志
1．需求分析 该系统是一个画图程序，我们要用设计模式的思想来设计系统结构，然后实现基本图形的绘制功能。 1.1 设计模式要求 至少在其中运用 6 种模式，其中涉及到的模式有装饰模式、策略模式、桥梁模式三种。 1.2 画图基本要求 能实现基本图形的绘制功能 1.3 画图高级要求 实现图形的操作（如选取、移动、放大、缩小、改变颜色、改变线形等）和持久化（利用文件或利用数据库）。 2.系统设计 首先，画图程序可以实现绘制圆形、矩形和按钮，这里可以将圆形、矩形和按钮看作三个不同的类，那么我们可以采用抽象工厂的方式来创建它们。对于画组合图，我们可以采用组合模式将二者结合起来。而对于图形颜色或者粗细的改变，我们可以使用外观模式。然后，我们可以使用原型模式来实现对于最后一个图形的复制。在系统中可以使用代理模式来实现显示图片。下面是对需要用到的设计模式进行的分析。 2.1 使用设计模式 2.1.1 桥梁模式 桥梁模式 , 结构型模式一种 .设计程序过程中 , 会经常使用到抽象类或者接口来完成抽象的过程。 继承或实现的类通过不同的实现方式来完成抽象类或接口的变化 , 也就是实现过程的变化 , 但可能会有这样的情况 , 抽象过程同样需要进行变化 , 也就是抽象类或者接口需要变化 , 这样就会造成原有的继承或实现关系复杂 , 关系混乱 .桥梁模式利用将抽象层和实现层进行解耦 , 使两者不再像继承或实现这样的较强的关系 , 从而使抽象和实现层更加独立的完成变化的过程 . 使系统更加清晰。 桥梁模式主要由抽象类、修正抽象类、实现类以及具体实现类组成 . 抽象类 , 制定接口 , 同时给出一个实现化的引用。 修正抽象类 , 扩展抽象类 , 修正或改变抽象类中指定的接口。 实现类 , 提供实现化角色的接口 , 但不进行具体实现过程 , 该接口不一定给出与抽象类相同的接口 , 只是提供实现的方式。 具体实现类 , 完成实现类中定义的实现接口的具体实现过程。 具体代码如下： package BridgePattern; import java.awt.Color;