设计模式

框架模式和设计模式的区别框架、设计模式这两个概念总容易被混淆，其实它们之间还是有区别的。框架通常是代码重用，而设计模式是设计重用，架构则介于两者之间，部分代码重用，部分设计重用，有时分析也可重用。在软件生产中有三种级别的重用：内部重用，即在同一应用中能公共使用的抽象块;代码重用，即将通用模块组合成库或工具集，以便在多个应用和领域都能使用；应用框架的重用，即为专用领域提供通用的或现成的基础结构，以获得最高级别的重用性。 框架与设计模式虽然相似，但却有着根本的不同。设计模式是对在某种环境中反复出现的问题以及解决该问题的方案的描述，它比框架更抽象；框架可以用代码表示，也能直接执行或复用，而对模式而言只有实例才能用代码表示;设计模式是比框架更小的元素，一个框架中往往含有一个或多个设计模式，框架总是针对某一特定应用领域，但同一模式却可适用于各种应用。可以说，框架是软件，而设计模式是软件的知识。

B

　　ZooKeeper作为发现服务的问题　　ZooKeeper(注：ZooKeeper是著名Hadoop的一个子项目，旨在解决大规模分 布式应用场景下，服务协调同步(Coordinate Service)的问题;它可以为同在一个分布式系统中的其他服务提供：统一命名服务、配置管理、分布式锁服务、集群管理等功能)是个伟大的开源项目，它 很成熟，有相当大的社区来支持它的发展，而且在生产环境得到了广泛的使用;但是用它来做Service发现服务解决方案则是个错误。　　在分布式系统领域有个著名的 CAP定理(C- 数据一致性;A-服务可用性;P-服务对网络分区故障的容错性，这三个特性在任何分布式系统中不能同时满足，最多同时满足两个);ZooKeeper是个CP的，即任何时刻对ZooKeeper的访问请求能得到一致的数据结果，同时系统对网络分割具备容错性;但是它不能保证每次服务请求的可用性(注：也就是在极端环境下，ZooKeeper可能会丢弃一些请求，消费者程序需要重新请求才能获得结果)。但是别忘了，ZooKeeper是分布式协调服务，它的职责是保证数据(注：配置数据，状态数据)在其管辖下的所有服务之间保持同步、一致;所以就不难理解为什么ZooKeeper被设计成CP而不是AP特性的了，如果是AP的，那么将会带来恐怖的后果(注：ZooKeeper就像交叉路口的信号灯一样，你能想象在交通要道突然信号灯失灵的情况吗?)。而且， 作为ZooKeeper的核心实现算法 Zab，就是解决了分布式系统下数据如何在多个服务之间保持同步问题的。　　作为一个分布式协同服务，ZooKeeper非常好，但是对于Service发现服务来说就不合适了;因为对于Service发现服务来说就算是 返回了包含不实的信息的结果也比什么都不返回要好;再者，对于Service发现服务而言，宁可返回某服务5分钟之前在哪几个服务器上可用的信息，也不能 因为暂时的网络故障而找不到可用的服务器，而不返回任何结果。所以说，用ZooKeeper来做Service发现服务是肯定错误的，如果你这么用就惨 了!　　而且更何况，如果被用作Service发现服务，ZooKeeper本身并没有正确的处理网络分割的问题;而在云端，网络分割问题跟其他类型的故障一样的确会发生;所以最好提前对这个问题做好100%的准备。就像 Jepsen在 ZooKeeper网站上发布的博客中所说：在ZooKeeper中，如果在同一个网络分区(partition)的节点数(nodes)数达不到 ZooKeeper选取Leader节点的逗法定人数地时，它们就会从ZooKeeper中断开，当然同时也就不能提供Service发现服务了。　　如果给ZooKeeper加上客户端缓存(注：给ZooKeeper节点配上本地缓存)或者其他类似技术的话可以缓解ZooKeeper因为网络故障造成节点同步信息错误的问题。 Pinterest与 Airbnb公 司就使用了这个方法来防止ZooKeeper故障发生。这种方式可以从表面上解决这个问题，具体地说，当部分或者所有节点跟ZooKeeper断开的情况 下，每个节点还可以从本地缓存中获取到数据;但是，即便如此，ZooKeeper下所有节点不可能保证任何时候都能缓存所有的服务注册信息。如果 ZooKeeper下所有节点都断开了，或者集群中出现了网络分割的故障(注：由于交换机故障导致交换机底下的子网间不能互访);那么ZooKeeper会将它们都从自己管理范围中剔除出去，外界就不能访问到这些节点了，即便这些节点本身是逗健康地的，可以正常提供服务的;所以导致到达这些节点的服务请求 被丢失了。(注：这也是为什么ZooKeeper不满足CAP中A的原因)　　更深层次的原因是，ZooKeeper是按照CP原则构建的，也就是说它能保证每个节点的数据保持一致，而为ZooKeeper加上缓存的做法的 目的是为了让ZooKeeper变得更加可靠(available);但是，ZooKeeper设计的本意是保持节点的数据一致，也就是CP。所以，这样一来，你可能既得不到一个数据一致的(CP)也得不到一个高可用的(AP)的Service发现服务了;因为，这相当于你在一个已有的CP系统上强制栓了 一个AP的系统，这在本质上就行不通的!一个Service发现服务应该从一开始就被设计成高可用的才行!　　如果抛开CAP原理不管，正确的设置与维护ZooKeeper服务就非常的困难;错误会 经常发生， 导致很多工程被建立只是为了减轻维护ZooKeeper的难度。这些错误不仅存在与客户端而且还存在于ZooKeeper服务器本身。Knewton平台 很多故障就是由于ZooKeeper使用不当而导致的。那些看似简单的操作，如：正确的重建观察者(reestablishing watcher)、客户端Session与异常的处理与在ZK窗口中管理内存都是非常容易导致ZooKeeper出错的。同时，我们确实也遇到过 ZooKeeper的一些经典bug： ZooKeeper-1159 与 ZooKeeper-1576; 我们甚至在生产环境中遇到过ZooKeeper选举Leader节点失败的情况。这些问题之所以会出现，在于ZooKeeper需要管理与保障所管辖服务 群的Session与网络连接资源(注：这些资源的管理在分布式系统环境下是极其困难的);但是它不负责管理服务的发现，所以使用ZooKeeper当 Service发现服务得不偿失。　　做出正确的选择：Eureka的成功　　我们把Service发现服务从ZooKeeper切换到了Eureka平台，它是一个开 源的服务发现解决方案，由Netflix公司开发。(注：Eureka由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用作服务注册服务器。Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持。)Eureka一开 始就被设计成高可用与可伸缩的Service发现服务，这两个特点也是Netflix公司开发所有平台的两个特色。( 他们都在讨论Eureka)。自从切换工作开始到现在，我们实现了在生产环境中所有依赖于Eureka的产品没有下线维护的记录。我们也被告知过，在云平台做服务迁移注定要遇到失败;但是我们从这个例子中得到的经验是，一个优秀的Service发现服务在其中发挥了至关重要的作用!　　首先，在Eureka平台中，如果某台服务器宕机，Eureka不会有类似于ZooKeeper的选举leader的过程;客户端请求会自动切换 到新的Eureka节点;当宕机的服务器重新恢复后，Eureka会再次将其纳入到服务器集群管理之中;而对于它来说，所有要做的无非是同步一些新的服务注册信息而已。所以，再也不用担心有逗掉队地的服务器恢复以后，会从Eureka服务器集群中剔除出去的风险了。Eureka甚至被设计用来应付范围更广的网络分割故障，并实现逗0地宕机维护需求。当网络分割故障发生时，每个Eureka节点，会持续的对外提供服务(注：ZooKeeper不会)：接收新 的服务注册同时将它们提供给下游的服务发现请求。这样一来，就可以实现在同一个子网中(same side of partition)，新发布的服务仍然可以被发现与访问。　　但是，Eureka做到的不止这些。正常配置下，Eureka内置了心跳服务，用于淘汰一些逗濒死地的服务器;如果在Eureka中注册的服务， 它的逗心跳地变得迟缓时，Eureka会将其整个剔除出管理范围(这点有点像ZooKeeper的做法)。这是个很好的功能，但是当网络分割故障发生时，这也是非常危险的;因为，那些因为网络问题(注：心跳慢被剔除了)而被剔除出去的服务器本身是很地健康逗的，只是因为网络分割故障把Eureka集群分割 成了独立的子网而不能互访而已。　　幸运的是，Netflix考虑到了这个缺陷。如果Eureka服务节点在短时间里丢失了大量的心跳连接(注：可能发生了网络故障)，那么这个 Eureka节点会进入地自我保护模式逗，同时保留那些逗心跳死亡逗的服务注册信息不过期。此时，这个Eureka节点对于新的服务还能提供注册服务，对于地死亡逗的仍然保留，以防还有客户端向其发起请求。当网络故障恢复后，这个Eureka节点会退出地自我保护模式逗。所以Eureka的哲学是，同时保 留地好数据逗与地坏数据逗总比丢掉任何地好数据逗要更好，所以这种模式在实践中非常有效。　　最后，Eureka还有客户端缓存功能(注：Eureka分为客户端程序与服务器端程序两个部分，客户端程序负责向外提供注册与发现服务接口)。 所以即便Eureka集群中所有节点都失效，或者发生网络分割故障导致客户端不能访问任何一台Eureka服务器;Eureka服务的消费者仍然可以通过Eureka客户端缓存来获取现有的服务注册信息。甚至最极端的环境下，所有正常的Eureka节点都不对请求产生相应，也没有更好的服务器解决方案来解 决这种问题时;得益于Eureka的客户端缓存技术，消费者服务仍然可以通过Eureka客户端查询与获取注册服务信息，这点很重要。　　Eureka的构架保证了它能够成为Service发现服务。它相对与ZooKeeper来说剔除了Leader节点的选取或者事务日志机制，这 样做有利于减少使用者维护的难度也保证了Eureka的在运行时的健壮性。而且Eureka就是为发现服务所设计的，它有独立的客户端程序库，同时提供心 跳服务、服务健康监测、自动发布服务与自动刷新缓存的功能。但是，如果使用ZooKeeper你必须自己来实现这些功能。Eureka的所有库都是开源 的，所有人都能看到与使用这些源代码，这比那些只有一两个人能看或者维护的客户端库要好。　　维护Eureka服务器也非常的简单，比如，切换一个节点只需要在现有EIP下移除一个现有的节点然后添加一个新的就行。Eureka提供了一个 web-based的图形化的运维界面，在这个界面中可以查看Eureka所管理的注册服务的运行状态信息：是否健康，运行日志等。Eureka甚至提供 了Restful-API接口，方便第三方程序集成Eureka的功能。

MVC设计模式早在面向对象语言Smalltalk-80中就被提出并在此后得到业界的广泛接受。它包括三类对象：（1）模型（Model）对象：是应用程序的主体部分。（2）视图（View）对象：是应用程序中负责生成用户界面的部分。（3）控制器（Control）对象：是根据用户的输入，控制用户界面数据显示及更新Model对象状态的部分.MVC模式不仅实现了功能模块和显示模块的分离，同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性。尽管MVC设计模式很早就提出，但在Web项目的开发中引入MVC却是步履维艰。主要原因：一是在早期的Web项目的开发中，程序语言和HTML的分离一直难以实现。CGI程序以字符串输出的形式动态地生成HTML内容。后来随着脚本语言的出现，前面的方式又被倒了过来，改成将脚本语言书写的程序嵌入在HTML内容中。这两种方式有一个相同的不足之处即它们总是无法将程序语言和HTML分离。二是脚本语言的功能相对较弱，缺乏支持MVC设计模式的一些必要的技术基础。直到基于J2EE的JSP Model 2问世时才得以改观。它用JSP技术实现视图的功能，用Servlet技术实现控制器的功能，用EJB技术实现模型的功能。

《Head First 设计模式（中文版）》（Elisabeth Freeman）电子书网盘下载免费在线阅读资源链接：链接：https://pan.baidu.com/s/1iDv1U3He4WkA09UYtakyeA 提取码：2bn9书名：Head First 设计模式（中文版）作者：Elisabeth Freeman译者：O"Reilly Taiwan公司豆瓣评分：9.2出版社：中国电力出版社出版年份：2007-9页数：637内容简介：《Head First设计模式》(中文版)共有14章，每章都介绍了几个设计模式，完整地涵盖了四人组版本全部23个设计模式。前言先介绍这本书的用法；第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、Abstract Factory、Factory Method、Singleton，Command、Adapter、Facade、TemplateMethod、Iterator、Composite、State、Proxy。最后三章比较特别。第12章介绍如何将两个以上的设计模式结合起来成为新的设计模式(例如著名的MVC模式)，作者称其为复合设计模式(这是作者自创的名称，并非四人组的标准名词)，第13章介绍如何进一步学习设计模式，如何发觉新的设计模式等主题，至于第14章则很快地浏览尚未介绍的设计模式，包括Bridge、Builder、Chain of Responsibility、Flyweight、Interpreter、Mediator、Memento、Prototype，Visitor。第1章还介绍了四个○○基本概念(抽象、封装、继承、多态)，而第1章到第9章也陆续介绍了九个○○原则(Principle)。千万不要轻视这些○○原则，因为每个设计模式背后都包含了几个○○原则的概念。很多时候，在设计时有两难的情况，这时候我们必须回归到○○原则，以方便判断取舍。可以这么说：○○原则是我们的目标，而设计模式是我们的做法。

有关“设计模式”的啊世界上第一本设计模式书，堪称经典的GOF《设计模式》基于C++的。不过我推荐你看《HeadFirst设计模式》，虽然基于java语言，但是这本书写的比较简单生动一些，比较好理解。有关“设计模式”的比较经典的书有：GOF《设计模式》、《HeadFirst设计模式》、《设计模式解析2》《大话设计模式》。这几本书只有第一个GOF《设计模式》是基于C++的。这几本书按难易程度是《大话设计模式》最简单，《HeadFirst设计模式》次之，《设计模式解析2》第三简单，GOF《设计模式》最枯燥但也可能是最深入的。如果你非要C#的，也有，库珀(JamesW.Cooper)编著,叶斌翻译的《C#设计模式》。

减少代码数量。《headfirst》设计模式第二版，根据产品介绍，其中修改了书本中的代码数量，并且提高了知识点详细解读，该产品价格优惠性价比高。

【答案】：A本题考查设计模式的概念，对行为模式进行比较。行为型模式对类或对象怎样交互和怎样分配职责进行描述。很多行为模式注重封装变化。当一个程序的某个方面的特征经常发生改变时，这些模式就定义一个封装这个方面的对象。这样，当该程序的其他部分依赖于这个方面时，它们都可以与此对象协作。一些模式引入总是被用作参数的对象。有些模式定义一些可作为令牌进行传递的对象，这些对象将在稍后被调用。在Visitor模式中，一个Visitor对象是一个多态的accept操作的参数，这个操作作用于该Visitor对象访问的对象。因此本题选择A选项。在Command模式中，令牌代表一个请求。在Memento模式中，它代表在一个对象在某个特定时刻的内部状态。在Command模式和Memento模式这两种情况下，令牌都可以有一个复杂的内部表示，但客户并不会意识到这一点。在Observer模式中，通过引入Observer和Subject对象来分布通信。

1、破解过吗？可能强力破解会损坏软件部分功能。2、如果有源码，源代码本身有问题，导致没有什么显示。解决：1、可以新建一个空工程，在入口mxml中打开设计模式，尝试拖一两个控件看看，运行可否显示。2、如果正常，就是你项目可能在入口mxml的初始化中有远程调用等init函数，而这个调用的函数或类在后台服务器，而在设计模式中并没有启动服务器功能，这好比eclipse 预览jsp页面一样，会乱码。设计模式只是预览静态效果。PS：这只是我 的猜测，因为FZ并没有提供更多的信息。还有现在的fb并不成熟，有很多的BUG和不爽。有一些奇怪问题见怪不怪了。

上边这句话，从字面来看很简单。但是如何在开发过程中去应用，仅凭一个定义依然是一头雾水。以笔者曾经做过的商户进销存系统为例：某超市准备举行促销活动，市场人员经过调查分析制定了一些促销策略：购物满100减10购物满200减30购物满300减50。。收银软件的界面是这样的（简单示意）：我们应该如何计算实际消费金额？最初的实现是这样的：//方便起见，我们把各个促销策略定义为枚举值：0,1,2...var getActualTotal = function(onSaleType,originTotal){ if(onSaleType===0){ return originTotal-Math.floor(originTotal/100)*10 } if(onSaleType===1){ return originTotal-Math.floor(originTotal/200)*30 } if(onSaleType===0){ return originTotal-Math.floor(originTotal/300)*50 }}getActualTotal(1,2680); //2208上面这段代码很简单，而且缺点也很明显。随着我的满减策略逐渐增多，getActualTotal函数会越变越大，而且充满了if判断，稍一疏忽就容易弄错。OK，有人说我很懒，虽然这样不够优雅但并不影响我的使用，毕竟满减策略再多也多不到哪去。我只能说，需求永远不是程序员定的。这时，市场人员说我们新版程序添加了会员功能，我们需要支持以下的促销策略：会员促销策略：会员充300返60，且首单打9折会员充500返100，且首单打8折会员充1000返300，且首单打7折...这个时候，如果你还在原先的getActualTotal函数中继续添加if判断，我想如果你的领导review你这段代码，可能会怀疑自己当初怎么把你招进来。OK，我们终于下定决心要重构促销策略的代码，我们可以这么做：var vipPolicy_0=function(originTotal){ return originTotal-Math.floor(originTotal/100)*10}var vipPolicy_1=function(originTotal){ return originTotal-Math.floor(originTotal/200)*30}...//会员充1000返300var vipPolicy_10=function(account,originTotal){ if(account===0){ account+=1300; return originTotal*0.9 }else{ account+=1300; return originTotal; } return originTotal-Math.floor(originTotal/200)*30}...var vipPolicy_n=function(){ ...}var getActualTotal=function(onSaleType,originTotal,account){ switch(onSaleType){ case 0: return vipPolicy_0(originTotal); case 1: return vipPolicy_0(originTotal); ... case n: return ... default: return originTotal; }}好了，现在我们每种策略都有自己独立的空间了，看起来井井有条。但是还有两个问题没有解决：随着促销策略的增加，getActualTotal的代码量依然会越来越大系统缺乏弹性，如果需要增加一种策略，那么除了添加一个策略函数，还需要修改switch...case..语句让我们再来回顾一下策略模式的定义：定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换在我们的例子中，每种促销策略的实现方式是不一样的，但我们最终的目的都是为了求得实际金额。策略模式可以把我们对促销策略的算法一个个封装起来，并且使它们可互相替换而不影响我们对实际金额的求值，这正好是我们所需要的。下面我们用策略模式来重构上面的代码：var policies={ "Type_0":function(originTotal){ return originTotal-Math.floor(originTotal/100)*10 }, "Type_1":function(originTotal){ return originTotal-Math.floor(originTotal/200)*30 }, ... "Type_n":function(originTotal){ ... }}var getActualTotal=function(onSaleType,originTotal,account){ return policies["Type_"+onSaleType](originTotal,account)}//执行getActualTotal(0,2680.00);//2208分析上面的代码我们发现，不管促销策略如何增加，getActualTotal函数完全不需要再变化了。我们要做的，就是增加新策略的函数而已。通过策略模式的代码，我们消除了让人反胃的大片条件分支语句，getActualTotal本身并没有计算能力，而是将计算全权委托给了策略函数。由此我们可以总结出策略模式实现的要点：将变化的算法封装成独立的策略函数，并负责具体的计算委托函数，该函数接受客户请求，并将请求委托给某一个具体的策略函数用一张UML图表示如下：怎么样？现在看到上面这张图是不是有了了然于胸的感觉？那就赶紧去试一试策略模式吧！参考书籍：《设计模式：可复用面向对象软件的基础》《大话设计模式》《Javascript设计模式与开发实践》做前端开发已经好几年了，对设计模式一直没有深入学习总结过。随着架构相关的工作越来越多，越来越能感觉到设计模式成为了我前进道路上的一个阻碍。所以从今天开始深入学习和总结经典的设计模式以及面向对象的几大原则。今天第一天，首先来讲策略模式。什么是策略模式？GoF四兄弟的经典《设计模式》中，对策略模式的定义如下：定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换。上边这句话，从字面来看很简单。但是如何在开发过程中去应用，仅凭一个定义依然是一头雾水。以笔者曾经做过的商户进销存系统为例：某超市准备举行促销活动，市场人员经过调查分析制定了一些促销策略：购物满100减10购物满200减30购物满300减50。。收银软件的界面是这样的（简单示意）：我们应该如何计算实际消费金额？最初的实现是这样的：//方便起见，我们把各个促销策略定义为枚举值：0,1,2...var getActualTotal = function(onSaleType,originTotal){ if(onSaleType===0){ return originTotal-Math.floor(originTotal/100)*10 } if(onSaleType===1){ return originTotal-Math.floor(originTotal/200)*30 } if(onSaleType===0){ return originTotal-Math.floor(originTotal/300)*50 }}getActualTotal(1,2680); //2208上面这段代码很简单，而且缺点也很明显。随着我的满减策略逐渐增多，getActualTotal函数会越变越大，而且充满了if判断，稍一疏忽就容易弄错。OK，有人说我很懒，虽然这样不够优雅但并不影响我的使用，毕竟满减策略再多也多不到哪去。我只能说，需求永远不是程序员定的。这时，市场人员说我们新版程序添加了会员功能，我们需要支持以下的促销策略：会员促销策略：会员充300返60，且首单打9折会员充500返100，且首单打8折会员充1000返300，且首单打7折...这个时候，如果你还在原先的getActualTotal函数中继续添加if判断，我想如果你的领导review你这段代码，可能会怀疑自己当初怎么把你招进来。OK，我们终于下定决心要重构促销策略的代码，我们可以这么做：var vipPolicy_0=function(originTotal){ return originTotal-Math.floor(originTotal/100)*10}var vipPolicy_1=function(originTotal){ return originTotal-Math.floor(originTotal/200)*30}...//会员充1000返300var vipPolicy_10=function(account,originTotal){ if(account===0){ account+=1300; return originTotal*0.9 }else{ account+=1300; return originTotal; } return originTotal-Math.floor(originTotal/200)*30}...var vipPolicy_n=function(){ ...}var getActualTotal=function(onSaleType,originTotal,account){ switch(onSaleType){ case 0: return vipPolicy_0(originTotal); case 1: return vipPolicy_0(originTotal); ... case n: return ... default: return originTotal; }}好了，现在我们每种策略都有自己独立的空间了，看起来井井有条。但是还有两个问题没有解决：随着促销策略的增加，getActualTotal的代码量依然会越来越大系统缺乏弹性，如果需要增加一种策略，那么除了添加一个策略函数，还需要修改switch...case..语句让我们再来回顾一下策略模式的定义：定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换在我们的例子中，每种促销策略的实现方式是不一样的，但我们最终的目的都是为了求得实际金额。策略模式可以把我们对促销策略的算法一个个封装起来，并且使它们可互相替换而不影响我们对实际金额的求值，这正好是我们所需要的。下面我们用策略模式来重构上面的代码：var policies={ "Type_0":function(originTotal){ return originTotal-Math.floor(originTotal/100)*10 }, "Type_1":function(originTotal){ return originTotal-Math.floor(originTotal/200)*30 }, ... "Type_n":function(originTotal){ ... }}var getActualTotal=function(onSaleType,originTotal,account){ return policies["Type_"+onSaleType](originTotal,account)}//执行getActualTotal(0,2680.00);//2208分析上面的代码我们发现，不管促销策略如何增加，getActualTotal函数完全不需要再变化了。我们要做的，就是增加新策略的函数而已。通过策略模式的代码，我们消除了让人反胃的大片条件分支语句，getActualTotal本身并没有计算能力，而是将计算全权委托给了策略函数。由此我们可以总结出策略模式实现的要点：将变化的算法封装成独立的策略函数，并负责具体的计算委托函数，该函数接受客户请求，并将请求委托给某一个具体的策略函数用一张UML图表示如下：怎么样？现在看到上面这张图是不是有了了然于胸的感觉？那就赶紧去试一试策略模式吧！相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：怎样使用JS+H5实现微信摇一摇如何对微信小程序进行开发

创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：uf0d8 工厂方法模式（Factory Method Pattern）uf0d8 抽象工厂模式（Abstract Factory Pattern）uf0d8 建造者模式（Builder Pattern）uf0d8 原型模式（Prototype Pattern）uf0d8 单例模式（Singleton Pattern）结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：uf0d8 适配器模式（Adapter Pattern）

软件设计模式主要有以下三大类共23种：一、创建型模式：1、工厂方法模式工厂方法模式的创建是因为简单工厂模式有一个问题，在简单工厂模式中类的创建依赖工厂类，如果想要拓展程序，必须对工厂类进行修改，这违背了开闭原则，所以就出现了工厂方法模式，只需要创建一个工厂接口和多个工厂实现类。子类可以自己决定实例化哪一个工厂类，client类针对抽象接口进行编程，如果需要增加新的功能，继承工厂接口，直接增加新的工厂类就可以了，创建过程延迟到子类中进行，不需要修改之前的代码，满足了开闭原则，达到灵活地生产多种对象。2、抽象工厂模式抽象工厂模式是提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。区别于工厂方法模式的地方，工厂方法模式是创建一个工厂，可以实现多种对象；而抽象工厂模式是提供一个抽象工厂接口，里面定义多种工厂，每个工厂可以生产多种对象。前者的重点在于"怎么生产"，后者的重点在于"生产哪些"；前者是一个抽象产品类，可以派生出多个具体产品类，后者是多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。3、单例模式单例模式能保证一个类仅有一个实例，并提供一个访问它的全局访问点，同时在类内部创造单一对象，通过设置权限，使类外部无法再创造对象。单例对象能保证在一个JVM中，该对象只有一个实例存在。在创建的时候，省去了new操作符，降低了系统内存的使用频率，减轻了系统的压力。同时单例模式保证在一个jvm中仅存在一个实例的好处就在于好比一个军队当中只会存在一个最高级别的军官来指挥整个军队，这样才能保证独立控制整个过程，否则如果出现多个，肯定会杂乱无序。4、建造者模式建造者模式是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。在程序当中就是将一些不会变的基本组件，通过builder来进行组合，构建复杂对象，实现分离。这样做的好处就在于客户端不必知道产品内部组成的细节；同时具体的建造者类之间是相互独立的，对系统的扩展非常有利，满足开闭原则；由于具体的建造者类是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。5、原型模式原型模式是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。其实就是将对象复制了一份并返还给调用者，对象需继承Cloneable并重写clone()方法。原型模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。分为浅复制和深复制，前者是将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的；后者是将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。二、结构型模式：1、适配器模式适配器模式是使得原本由于接口不兼容而不能一起工作的那些类可以一起工作，衔接两个不兼容、独立的接口的功能，使得它们能够一起工作，适配器起到中介的作用。2、装饰模式装饰器模式是动态地给一个对象添加一些额外的职责，给一个对象增加一些新的功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。除了动态的增加，也可以动态的撤销，要做到动态的形式，不可以用继承实现，因为继承是静态的。3、代理模式代理模式是为其他对象提供一种代理以控制对这个对象的访问，也就是创建类的代理类，间接访问被代理类的过程中，对其功能加以控制。它和装饰器模式的区别在于，装饰器模式为了增强功能，而代理模式是为了加以控制。代理模式就是多一个代理类出来，替原对象进行一些操作，例如买火车票不一定在火车站买，也可以去代售点。再比如打官司需要请律师，因为律师在法律方面有专长，可以替我们进行操作。4、外观模式外观模式是为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。在客户端和复杂系统之间再加一层，提供一个容易使用的外观层。外观模式是为了解决类与类之家的依赖关系的，外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，比如搜狐门户网站，就利用了外观模式。5、桥接模式桥接模式是将抽象部分与实现部分分离，使它们都可以独立的变化。桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化（突然联想到了mvc模式）。将抽象化与实现化解耦，使得二者可以独立变化，就好比现在常说的mvc模式，view和model之间通过control来控制，达到高内聚低耦合来解耦的目的。6、组合模式组合模式是将对象组合成树形结构以表示"部分-整体"的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。创建了一个包含自己对象组的类，并提供修改对象组的方法。在系统的文件和文件夹的问题上就使用了组合模式，文件下不可以有对象，而文件夹下可以有文件对象或者文件夹对象。7、享元模式享元模式是运用共享技术有效地支持大量细粒度的对象。享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，重用现有的同类对象，若未找到匹配的对象，则创建新对象，这样可以减少对象的创建，降低系统内存，提高效率。三、行为型模式：1、策略模式策略模式是定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换，且算法的变化不会影响到使用算法的客户。为了统一接口下的一系列算法类（也就是多种策略），用一个类将其封装起来，使这些策略可动态切换。策略模式属于行为型模式，是为了使这些策略可以相互切换，是为了选择不同的行为。2、模版方法模式模板方法模式是定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。该模式就是在一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤，将一些固定步骤、固定逻辑的方法封装成模板方法。调用模板方法即可完成那些特定的步骤。3、观察者模式观察者模式是定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。也就是当被观察者状态变化时，通知所有观察者，这种依赖方式具有双向性，在QQ邮箱中的邮件订阅和RSS订阅，当用户浏览一些博客时，经常会看到RSS图标，简单来说就是当订阅了该文章，如果后续有更新，会及时通知用户。这种现象即是典型的观察者模式。4、迭代器模式迭代器模式是提供一种方法顺序访问一个聚合对象中各个元素,而又无须暴露该对象的内部表示。在Java当中，将聚合类中遍历各个元素的行为分离出来，封装成迭代器，让迭代器来处理遍历的任务；使简化聚合类，同时又不暴露聚合类的内部，在我们经常使用的JDK中各个类也都是这些基本的东西。5、责任链模式责任链模式是避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求。在生活中学生进行请假的过程中，会涉及到，学生请假会一级一级往上批，最终处理，具体由谁批准可能不清楚。在程序当中，现在使用的struts拦截器即用到了责任链模式。6、命令模式命令模式是将一个请求封装成一个对象，从而使发出者可以用不同的请求对客户进行参数化。模式当中存在调用者、接收者、命令三个对象，实现请求和执行分开；调用者选择命令发布，命令指定接收者。7、备忘录模式备忘录模式是在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。创建一个备忘录类，用来存储原始类的信息；同时创建备忘录仓库类，用来存储备忘录类，主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，也就是做个备份。在系统当中使用的撤销操作，即是使用了备忘录模式，系统可以保存有限次数的文件状态，用户可以进行上几个状态的恢复，也就是用到了备忘录模式。8、状态模式状态模式是允许对象在内部状态发生改变时改变它的行为。对象具有多种状态，且每种状态具有特定的行为。在网站的积分系统中，用户具有不同的积分，也就对应了不同的状态；还有QQ的用户状态有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态。9、访问者模式访问者模式主要是将数据结构与数据操作分离。在被访问的类里面加一个对外提供接待访问者的接口，访问者封装了对被访问者结构的一些杂乱操作，解耦结构与算法，同时具有优秀的扩展性。通俗来讲就是一种分离对象数据结构与行为的方法。通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。10、中介者模式中介者模式是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。例如，MVC模式中control就是model和view的中介者。与适配器区别在于，适配器是为了兼容不同的接口，而中介者是为了将显示和操作分离。11、解释器模式解释器模式是给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子，基本也就用在这个范围内，适用面较窄，例如：正则表达式的解释等。参考资料来源：百度百科-软件设计模式

软件设计模式主要有以下三大类共23种：一、创建型模式：1、工厂方法模式工厂方法模式的创建是因为简单工厂模式有一个问题，在简单工厂模式中类的创建依赖工厂类，如果想要拓展程序，必须对工厂类进行修改，这违背了开闭原则，所以就出现了工厂方法模式，只需要创建一个工厂接口和多个工厂实现类。2、抽象工厂模式抽象工厂模式是提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。区别于工厂方法模式的地方，工厂方法模式是创建一个工厂，可以实现多种对象；而抽象工厂模式是提供一个抽象工厂接口，里面定义多种工厂，每个工厂可以生产多种对象。3、单例模式单例模式能保证一个类仅有一个实例，并提供一个访问它的全局访问点，同时在类内部创造单一对象，通过设置权限，使类外部无法再创造对象。单例对象能保证在一个JVM中，该对象只有一个实例存在。4、建造者模式建造者模式是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。在程序当中就是将一些不会变的基本组件，通过builder来进行组合，构建复杂对象，实现分离。5、原型模式：原型模式是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。其实就是将对象复制了一份并返还给调用者，对象需继承Cloneable并重写clone方法。原型模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。二、结构型模式：1、适配器模式适配器模式是使得原本由于接口不兼容而不能一起工作的那些类可以一起工作，衔接两个不兼容、独立的接口的功能，使得它们能够一起工作，适配器起到中介的作用。2、装饰模式：装饰器模式是动态地给一个对象添加一些额外的职责，给一个对象增加一些新的功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。除了动态的增加，也可以动态的撤销，要做到动态的形式，不可以用继承实现，因为继承是静态的。3、代理模式代理模式是为其他对象提供一种代理以控制对这个对象的访问，也就是创建类的代理类，间接访问被代理类的过程中，对其功能加以控制。4、外观模式外观模式是为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。5、桥接模式桥接模式是将抽象部分与实现部分分离，使它们都可以独立的变化。桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化（突然联想到了mvc模式）。6、组合模式：组合模式是将对象组合成树形结构以表示"部分-整体"的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。7、享元模式：享元模式是运用共享技术有效地支持大量细粒度的对象。享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，重用现有的同类对象，若未找到匹配的对象，则创建新对象，这样可以减少对象的创建，降低系统内存，提高效率。三、行为型模式：1、策略模式：策略模式是定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换，且算法的变化不会影响到使用算法的客户。2、模版方法模式：模板方法模式是定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。该模式就是在一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤，将一些固定步骤、固定逻辑的方法封装成模板方法。调用模板方法即可完成那些特定的步骤。3、观察者模式：观察者模式是定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。也就是当被观察者状态变化时，通知所有观察者，这种依赖方式具有双向性，在QQ邮箱中的邮件订阅和RSS订阅，当用户浏览一些博客时，经常会看到RSS图标，简单来说就是当订阅了该文章，如果后续有更新，会及时通知用户。这种现象即是典型的观察者模式。4、迭代器模式：迭代器模式是提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。在Java当中，将聚合类中遍历各个元素的行为分离出来，封装成迭代器，让迭代器来处理遍历的任务；使简化聚合类，同时又不暴露聚合类的内部，在我们经常使用的JDK中各个类也都是这些基本的东西。5、责任链模式：责任链模式是避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。6、命令模式：命令模式是将一个请求封装成一个对象，从而使发出者可以用不同的请求对客户进行参数化。模式当中存在调用者、接收者、命令三个对象，实现请求和执行分开；调用者选择命令发布，命令指定接收者。7、备忘录模式：备忘录模式是在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。创建一个备忘录类，用来存储原始类的信息；同时创建备忘录仓库类，用来存储备忘录类，主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，也就是做个备份。8、状态模式：状态模式是允许对象在内部状态发生改变时改变它的行为。对象具有多种状态，且每种状态具有特定的行为。9、访问者模式：访问者模式主要是将数据结构与数据操作分离。在被访问的类里面加一个对外提供接待访问者的接口，访问者封装了对被访问者结构的一些杂乱操作，解耦结构与算法，同时具有优秀的扩展性。通俗来讲就是一种分离对象数据结构与行为的方法。10、中介者模式：中介者模式是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。11、解释器模式：解释器模式是给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子，基本也就用在这个范围内，适用面较窄，例如：正则表达式的解释等。扩展资料：软件设计的概念以及意义：软件设计模式是对软件设计经验的总结，是对软件设计中反复出现的设计问题的成功解决方案的描述。为了记录这些成功的设计经验并方便以后使用，软件设计模式通常包含 4 个基本要素：模式名称、问题、解决方案以及效果。模式名称实际上就是一个帮助记忆的名称，是用于软件设计的技术术语，有助于设计者之间的交流。问题描述了设计者所面临的设计场景，用于告诉设计者在什么情况下使用该模式。解决方案描述了设计的细节，通常会给出方案的原理图示（例如 UML 的类图，序列图等，也可能是一些示意图）及相关文字说明，如果可能，还会给出一些代码实例，以便对解决方案的深入理解。效果描述了设计方案的优势和劣势，这些效果通常面向软件的质量属性，例如，可扩展性、可复用性等。软件设计模式的重要意义在于设计复用。设计模式可以使设计者更加方便地借鉴或直接使用已经过证实的成功设计方案，而不必花费时间进行重复设计。一些设计模式甚至提供了显示的类图设计及代码实例，为设计的文档化及软件的开发提供了直接的支持。

Future设计模式从本质上是用来解决的根本的问题在于可以 让一个任务在异步执行，而任务执行完之后我们可以在未来的某一个时间点上去获取到这个任务执行的结果，不管这个任务是执行失败或成功 举个例子 比如我们要完成一件任务，正常情况是要等到这个任务执行完之后才能拿到任务执行的结果【单线程顺序执行逻辑】，而如果使用Future模式之后，则执行任务可以交由别的线程来执行，而我们可继续往下执行自己的事件，当在未来的某个时间点又能拿到这个任务的结果，其实也就是并行的方式。可能有的人说这不就是线程嘛，是的，但是普通的线程我们要等其执行完不得使用join()么，但是它会阻塞我们的继续往下执行。 一个Future代表了一个异步计算的结果，它提供了很多方法用来 检查此计算是否完成 ，或者 等待它的完成 ，以及 获取计算的结果 。只有当计算结果后才可以使用get()方法来获取结果，必要时会进行阻塞直到任务执行结束。可以通过cancel()方法对其任务进行取消，此外还提供了其他方法来确定任务是正常完成还是说被取消了。 对于Future而言它是一个接口，要使用还得用具体实现类，FutureTask就是Future的一个具体实现类之一，比较常见，观察FutureTask实现的接口，就知道它有什么样的能力 方法2 对于上面两个构造的使用场景其实也很好理解 看一下Callable接口的定义 输出 分析： new Thread(futureTask).start();执行的是开辟一个子任务，执行的是callable的内容并要求返回Integer类型的结果，而callable的内容作为变量传进FutureTask中。因此现在就 有两个线程一起执行，一个是主任务线程，一个是子任务线程，而后面主任务线程需要拿到子任务线程执行完的结果，因此一定要执行完futureTask.get()方法时，主任务线程才会继续执行下去，否则会一直进入等待状态 （如果get()方法是带时间参数的方法，若超过的指定的时间则主任务线程会抛出异常，而子任务线程不会抛出异常，因为和子任务线程无关） Future模式，它有一个最大的缺点就是调用get()方法来获取其任务的结果时会阻塞，还有一个CompletableFuture的实现类，弥补Future的不足，使得任务执行时和结果获取时都不阻塞，这里不做详细总结，具体看这里 https://mp.weixin.qq.com/s/cu09f_LD4SlywZMTCBeokA

　　 为什么要使用Proxy? 　　 授权机制 不同级别的用户对同一对象拥有不同的访问权利 如Jive 论坛系统中 就使用Proxy 进行授权机制控制 访问论坛有两种人:注册用户和游客(未注册用户) Jive 中就通过类似ForumProxy 这样的代理来控制这两种用户对论坛的访问权限 　　 某个客户端不能直接操作到某个对象 但又必须和那个对象有所互动 　　举例两个具体情况: 　　( )如果那个对象是一个是很大的图片 需要花费很长时间才能显示出来 那么当这个图片包含在文档中时 使用编辑器或浏览器打开这个文档 打开文档必须很迅速 不能等待大图片处理完成 这时需要做个图片Proxy 来代替真正的图片 　　( )如果那个对象在Internet 的某个远端服务器上 直接操作这个对象因为网络速度原因可能比较慢 那我们可以先用Proxy 来代替那个对象 　　总之原则是 对于开销很大的对象 只有在使用它时才创建 这个原则可以为我们节省很多宝贵的Java 内存 所以 有些人认为Java 耗费资源内存 我以为这和程序编制思路也有一定的关系 　　 如何使用Proxy? 　　以Jive 论坛系统为例 访问论坛系统的用户有多种类型:注册普通用户 论坛管理者 系统管理者 游客 注册普通用户才能发言;论坛管理者可以管理他被授权的论坛;系统管理者可以管理所有事务等 这些权限划分和管理是使用Proxy 完成的 　　Forum 是Jive 的核心接口 在Forum 中陈列了有关论坛操作的主要行为 如论坛名称 论坛描述的获取和修改 帖子发表删除编辑等 　　在ForumPermissions 中定义了各种级别权限的用户: 　　public class ForumPermissions implements Cacheable { 　　/*** Permission to read object */ 　　public static final int READ = ; 　　/*** Permission to administer the entire sytem */ 　　public static final int SYSTEM_ADMIN = ; 　　/*** Permission to administer a particular forum */ 　　public static final int FORUM_ADMIN = ; 　　/*** Permission to administer a particular user */ 　　public static final int USER_ADMIN = ; 　　/*** Permission to administer a particular group */ 　　public static final int GROUP_ADMIN = ; 　　/*** Permission to moderate threads */ 　　public static final int MODERATE_THREADS = ; 　　/*** Permission to create a new thread */ 　　public static final int CREATE_THREAD = ; 　　/*** Permission to create a new message */ 　　public static final int CREATE_MESSAGE = ; 　　/*** Permission to moderate messages */ 　　public static final int MODERATE_MESSAGES = ; 　　 　　public boolean isSystemOrForumAdmin() { 　　return (values[FORUM_ADMIN] || values[SYSTEM_ADMIN]); 　　} 　　 　　} 　　因此 Forum 中各种操作权限是和ForumPermissions 定义的用户级别有关系的 作为接口Forum 的实现:ForumProxy 正是将这种对应关系联系起来 比如 修改Forum 的名称 只有论坛管理者或系统管理者可以修改 代码如下: 　　public class ForumProxy implements Forum { 　　private ForumPermissions permissions; 　　private Forum forum; 　　this authorization = authorization; 　　public ForumProxy(Forum forum Authorization authorization 　　ForumPermissions permissions) 　　{ 　　this forum = forum; 　　this authorization = authorization; 　　this permissions = permissions; 　　} 　　 　　public void setName(String name) throws UnauthorizedException 　　ForumAlreadyExistsException 　　{ 　　//只有是系统或论坛管理者才可以修改名称 　　if (permissions isSystemOrForumAdmin()) { 　　forum setName(name); 　　} 　　else { 　　throw new UnauthorizedException(); 　　} 　　} 　　 　　} 　　而DbForum 才是接口Forum 的真正实现 以修改论坛名称为例: 　　public class DbForum implements Forum Cacheable { 　　 　　public void setName(String name) throws 　　ForumAlreadyExistsException { 　　 　　this name = name; 　　//这里真正将新名称保存到数据库中 　　saveToDb(); 　　 　　} 　　 　　} 　　凡是涉及到对论坛名称修改这一事件 其他程序都首先得和ForumProxy 打交道 由ForumProxy 决定是否有权限做某一样事情 ForumProxy 是个名副其实的 网关 安全代理系统 　　我们已经知道 使用Forum 需要通过ForumProxy Jive 中创建一个Forum 是使用Factory 模式 有一个总的抽象类ForumFactory 在这个抽象类中 调用ForumFactory 是通过getInstance()方法实现 这里使用了Singleton getInstance()返回的是ForumFactoryProxy 　　为什么不返回ForumFactory 而返回ForumFactory 的实现ForumFactoryProxy? 　　原因是明显的 需要通过代理确定是否有权限创建forum 　　在ForumFactoryProxy 中我们看到代码如下: 　　public class ForumFactoryProxy extends ForumFactory { 　　protected ForumFactory factory; 　　protected Authorization authorization; 　　protected ForumPermissions permissions; 　　public ForumFactoryProxy(Authorization authorization ForumFactory factory 　　ForumPermissions permissions) 　　{ 　　this factory = factory; 　　this authorization = authorization; 　　this permissions = permissions; 　　} 　　public Forum createForum(String name String description) 　　throws UnauthorizedException ForumAlreadyExistsException 　　{ 　　//只有系统管理者才可以创建forum 　　if (permissions get(ForumPermissions SYSTEM_ADMIN)) { 　　Forum newForum = factory createForum(name description); 　　return new ForumProxy(newForum authorization permissions); 　　} 　　else { 　　throw new UnauthorizedException(); 　　} 　　} 　　方法createForum 返回的也是ForumProxy Proxy 就象一道墙 其他程序只能和Proxy 交互操作 　　注意到这里有两个Proxy:ForumProxy 和ForumFactoryProxy 代表两个不同的职责:使用Forum 和创建Forum; 　　至于为什么将使用对象和创建对象分开 这也是为什么使用Factory 模式的原因所在:是为了 封装 分派 ;换句话说 尽可能功能单一化 方便维护修改 　　以上我们讨论了如何使用Proxy 进行授权机制的访问 Proxy 还可以对用户隐藏另外一种称为copy on write 的优化方式 拷贝一个庞大而复杂的对象是一个开销很大的操作 如果拷贝过程中 没有对原来的对象有所修改 那么这样的拷贝开销就没有必要 用代理延迟这一拷贝过程 　　比如:我们有一个很大的Collection 具体如hashtable 有很多客户端会并发同时访问它 　　其中一个特别的客户端要进行连续的数据获取 此时要求其他客户端不能再向hashtable 中增加或删除 东东 　　最直接的解决方案是:使用collection 的lock 让这特别的客户端获得这个lock 进行连续的数据获取 然后再释放lock 　　public void foFetches(Hashtable ht){ 　　synchronized(ht){ 　　//具体的连续数据获取动作 　　} 　　} 　　但是这一办法可能锁住Collection 会很长时间 这段时间 其他客户端就不能访问该Collection 了 　　第二个解决方案是clone 这个Collection 然后让连续的数据获取针对clone 出来的那个Collection 操作 这个方案前提是 这个Collection 是可clone 的 而且必须有提供深度clone 的方法 Hashtable 就提供了对自己的clone 方法 但不是Key 和value 对象的clone 关于Clone 含义可以参考专门文章 　　public void foFetches(Hashtable ht){ 　　Hashttable newht=(Hashtable)ht clone(); 　　} 　　问题又来了 由于是针对clone 出来的对象操作 如果原来的母体被其他客户端操作修改了 那么对clone 出来的对象操作就没有意义了 　　最后解决方案:我们可以等其他客户端修改完成后再进行clone 也就是说 这个特别的客户端先通过调用一个叫clone 的方法来进行一系列数据获取操作 但实际上没有真正的进行对象拷贝 直至有其他客户端修改了这个对象Collection lishixinzhi/Article/program/Java/gj/201311/27422

1、工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。6、适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。7、桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。8、合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。9、装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。10、门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。11、享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。12、代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。13、责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。14、命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。15、解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。16、迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。17、调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。18、备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。19、观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。20、状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。21、策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。22、模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。23、访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。

给你个代码看下吧。更直观一些<?phpclass db{ private static $instance=false; public static function instance($host,$name,$pass,$dbname) { if(self::$instance===false) { self::$instance=new db(......); } return self::$instance; } private function __construct() { /*这个函数必须是私有的，它保证了只能通过单例生成器来获得实例*/ } public function __clone() { /*什么也不做*/ }}?> 外部调用的时候，调用那个instance函数 ，以保证他的唯一性

其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 例如：随处可见，比如Servlet，sprigMVC创建时都是单例多线程的。完美的实例是：private static Singleton instance = new Singleton(); 创建线程的方式有很多种，但是很多都扛不住多线程的检验，上面是简单又实用的例子，多线程下也是安全的。 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 例如：虽然简单工厂（静态工厂）没有进入23种设计模式，但是java web中的很多配置文件玩的还是它。Spring中下面三种方式实例化bean： 1.使用类构造器实例化 <bean id="orderService" class="cn.itcast.OrderServiceBean"/> 2.使用静态工厂方法实例化　　<bean id="personService" class="cn.itcast.service.OrderFactory" factory- method="createOrder"/>　　public class OrderFactory { 　　public static OrderServiceBean createOrder(){ 　　 return new OrderServiceBean(); 　　}　　} 3.使用实例工厂方法实例化: <bean id="personServiceFactory" class="cn.itcast.service.OrderFactory"/> <bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/> public class OrderFactory { public OrderServiceBean createOrder(){ return new OrderServiceBean(); } } 第一种方法，IOC容易直接根据配置文件中的class属性通过反射创建一个实例，使用的是该类的默认构造方法。第二种则是调用class指定的工厂类的工厂方法，来返回一个相应的bean实例，值得注意的是工厂类的方法是静态方法，所以不用产生工厂本身的实例。而第三种则不同，它除了配置与第二种相同外，唯一的不同就是方法不是静态的，所以创建bean的实例对象时需要先生成工厂类的实例。实例了bean对象时，需要对其中的属性也进行赋值，这时就是经常被提及的依赖注入。以上其实有错误：Spring很多情况下创建对象很定是反射呀，尤其是注解和DI（依赖注入），小朋友，想什么呢？肯定不是用new()来创建：Class c = Class.forName("cn.itcast.OrderServiceBean");Object bean = c.newInstance(); 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 例如：jdk中的各种容器类的基础模式 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 例如：据说是jdk使用最多的模式,好比邮件订阅或RSS订阅 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 例如：comparator 比较器的实现利用了此模式 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 。此处强调一点就是，链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象例如：struts2 interceptor 用到的就是是责任链模式 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，facade提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问。例如：经典的体现在Spring AOP切面中，Spring中利用了俩种代理类型。其实，代理也分为静态和动态，但是我们一般常用动态，因为静态代理秀不起来 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。 其中对象的适配器模式是各种结构型模式的起源，分为三种：类，对象，接口的适配器模式。结一下三种适配器模式的应用场景：类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。例如：java io流中大量使用 二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。 对比：适配器模式主要是为了接口的转换，而装饰者模式关注的是通过组合来动态的为被装饰者注入新的功能或行为(即所谓的责任)。 二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。 二十三、Flyweight，享元模式：主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。例如：数据库连接池便是这个原理

那个男人，她认出来岂的确体质

面向对象，区别于c的面向过程

本文开始整个设计模式的系列学习，希望通过不断的学习，可以对设计模式有整体的掌握，并在项目中根据实际的情况加以利用。 单例模式是指一个类仅允许创建其自身的一个实例，并提供对该实例的访问权限。它包含静态变量，可以容纳其自身的唯一和私有实例。它被应用于这种场景——用户希望类的实例被约束为一个对象。在需要单个对象来协调整个系统时，它会很有帮助。 1、单例类只能有一个实例 2、单例类必须自己创建自己的唯一实例 3、单例类必须给其他所有对象提供这一实例 1.尽量使用懒加载 2.双重检索实现线程安全 3.构造方法为private 4.定义静态的Singleton instance对象和getInstance()方法 单例模式至少有六种写法。 作为一种重要的设计模式，单例模式的好处有： 1、控制资源的使用，通过线程同步来控制资源的并发访问 2、控制实例的产生，以达到节约资源的目的 3、控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信 Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。但其实通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。 虽然也是只有一个线程能够执行，假如线程B先执行，线程B获得锁，线程B执行完之后，线程 A获得锁，但是此时没有检查singleton是否为空就直接执行了，所以还会出现两个singleton实例的情况。 既然懒汉式是非线程安全的，那就要改进它。最直接的想法是，给getInstance方法加锁不就好了，但是我们不需要给方法全部加锁啊，只需要给方法的一部分加锁就好了。基于这个考虑，引入了双检锁（Double Check Lock，简称DCL）的写法： 使用volatile 的原因： 对于JVM而言，它执行的是一个个Java指令。在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间， 然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就使出错成为了可能，我们仍然以A、B两个线程为例： 加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。 枚举类实现单例模式是 effective java 作者极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。因为枚举类没有构造方法，可以防止反序列化操作。 1、除枚举方式外, 其他方法都会通过反射的方式破坏单例,反射是通过调用构造方法生成新的对象，所以如果我们想要阻止单例破坏，可以在构造方法中进行判断，若已有实例, 则阻止生成新的实例，解决办法如下: 2、如果单例类实现了序列化接口Serializable, 就可以通过反序列化破坏单例，所以我们可以不实现序列化接口,如果非得实现序列化接口，可以重写反序列化方法readResolve(), 反序列化时直接返回相关单例对象。 Runtime是一个典型的例子，看下JDK API对于这个类的解释"每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接，可以通过getRuntime方法获取当前运行时。应用程序不能创建自己的Runtime类实例。"，这段话，有两点很重要： 1、每个应用程序都有一个Runtime类实例 2、应用程序不能创建自己的Runtime类实例 只有一个、不能自己创建，是不是典型的单例模式？看一下，Runtime类的写法： 为了节约系统资源，有时需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，我们无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。为了确保对象的唯一性，我们可以通过单例模式来实现。 单例模式应用的场景一般发现在以下条件下： 　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。 　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。 关于单例模式的漫画分析： https://mp.weixin.qq.com/s/f-sJIZHr7JUa31gKTllSFQ 单例模式的优缺点、注意事项、使用场景

问题一：软件设计模式主要有哪几种 创建型模式用来处理对象的创建过程，主要包含以下5种设计模式： ? 工厂方法模式（Factory Method Pattern） ? 抽象工厂模式（Abstract Factory Pattern） ? 建造者模式（Builder Pattern） ? 原型模式（Prototype Pattern） ? 单例模式（Singleton Pattern） 结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式： ? 适配器模式（Adapter Pattern） ? 桥接模式（Bridge Pattern） ? 组合模式（posite Pattern） ? 装饰者模式（Decorator Pattern） ? 外观模式（Facade Pattern） ? 享元模式（Flyweight Pattern） ? 代理模式（Proxy Pattern） 行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式： ? 责任链模式（Chain of Responsibility Pattern） ? 命令模式（mand Pattern） ? 解释器模式（Interpreter Pattern） ? 迭代器模式（Iterator Pattern） uf0d8 中介者模式（Mediator Pattern） ? 备忘录模式（Memento Pattern） ? 观察者模式（Observer Pattern） ? 状态模式（State Pattern） ? 策略模式（Strategy Pattern） ? 模板方法模式（Template Method Pattern） ? 访问者模式（Visitor Pattern） 问题二：软件开发的设计模式有哪些 最常用的是设计模式是工厂模式或者单例模式。 问题三：什么是软件设计模式 你好。 软件设计模式就是Uml统一建模语言的技巧性概念。主要研究各个类模块和接口之间的安排与搭配，也是为程序员提供亥流的一个很好的平台。 利用软件设计模式您可以做出质量更高，代码更少，扩充更容易的软件。我个人理解它更像是一个工具箱，可以让你生产出更漂亮、更简洁的代码。 我的回答您还满意吗？ 问题四：常见的软件开发模式和设计模式有哪些 MVC 这个是JAVA ee中就经常用到的模式 将数据模型、界面视图和业务逻辑控制分开的模式在Android开发中体现的最明显 数据模型一定单独 界面视图在布局中实现 业务控制单独编写，典型的MVC 问题五：软件工程中的设计模式都有哪些 Builder模式：比如AlertDialog.Builder。 适配器模式：比如GridView、ListView与Adapter。 命令模式：比如Handler.post。 享元模式：比如Message.obtain。 单例模式：比如InputMethodManager.getInstance。 观察者模式：比如ContentObserver。 这是一些经常用到的设计模式以及举例。 问题六：列出几种软件开发中常见的设计模式并解释 设计模式主要分三个类型:创建型、结构型和行为型。 其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、mand，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、posite，组合模式：将对象组合成树形结构以表示部分整体的关系，posite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。 二十一、Decrator，装饰顶式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。......>> 问题七：设计模式都有哪些? 设计模式主要分三个类型:创建型、结构型和行为型。 其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、mand，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、posite，组合模式：将对象组合成树形结构以表示部分整体的关系，posite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。 二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。 二十二、Bridge，桥模式：将抽......>> 问题八：总共有几种设计模式？？？ 共有23种 简单工厂是设计模式中比较简单的创建型模式 其原理就是创建一个工厂类（接口），客户端调用的为接口的实现类，来实现代码的复用与简单恭耦，其实简单工厂也是工厂方法模式的一种特殊实现。 推荐你看篇文章，你就会更好的理解。 blog.csdn/ai92/article/details/209198 问题九：软件设计模式的四个要素 设计模式使人们可以更加简单方便地复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。模式名称一个助记名，它用一两个词来描述模式的问题、解决方案和效果。命名一个新的模式增加了我们的设计词汇。设计模式允许我们在较高的抽象层次上进行设计。基于一个模式词汇表，我们自己以及同事之间就可以讨论模式并在编写文档时使用它们。模式名可以帮助我们思考，便于我们与其他人交流设计思想及设计结果。找到恰当的模式名也是我们设计模式编目工作的难点之一。问题描述问题存在的前因后果，它可能描述了特定的设计问题，如怎样用对象表示算法等。也可能描述了导致不灵活设计的类或对象结构。有时候，问题部分会包括使用模式必须满足的一系列先决条件。解决方案描述了设计的组成成分，它们之间的相互关系及各自的职责和协作方式。因为模式就像一个模板，可应用于多种不同场合，所以解决方案并不描述一个特定而具体的设计或实现，而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象组合）来解决这个问题。效果描述了模式应用的效果及使用模式应权衡的问题。尽管我们描述设计决策时，并不总提到模式效果，但它们对于评价设计选择和理解使用模式的代价及好处具有重要意义。软件效果大多关注对时间和空间的衡量，它们也表述了语言和实现问题。因为复用是面向对象设计的要素之一，所以模式效果包括它对系统的灵活性、扩充性或可移植性的影响，显式地列出这些效果对理解和评价这些模式很有帮助。 问题十：有哪些比较好的设计模式 单例模式：这个是必须会的 观察者模式：这个最典型的应用就是mvc模式。 flyweight模式：这个也很常用 posite（组合）：这个很常见吧， 适配器模式：这个也很常用，比如我们一般会封装一些类库。然后成为我们用起来更方便的类。 其它的还很多的。总共23种。设计模式需要边学边用。很多不好理解。等以后觉得自己设计思路不太好了可以再翻翻。

【答案】：D抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类，而非单例模式

单例模式（Singleton Pattern）是一个比较简单的模式。定义：确保某一个类只有一个实例，而且自动实例化并向整个系统提供这个实例。通用类图：通用代码：Singleton类称为单例类，通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化的。/** * 线程安全的单例模式 * 饿汉式单例 * @author Administrator * */public class Singleton { private static final Singleton singleton = new Singleton(); // 限制产生多个对象 private Singleton() { } // 通过该方法获得实例对象 public static Singleton getSingleton() { return singleton; } // 类中其他方法尽量是static public static void doSomething() { }}单例模式的优点：由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显了。由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。单例模式的缺点：单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能用mock的方式虚拟一个对象。单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。单例模式的使用场景：要求生成唯一序列号的环境；在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。单例模式的注意事项： 1. 在高并发情况下，请注意单例模式的线程同步问题。/** * 懒汉式单例 * @author Administrator * */public class Singleton2 { private static Singleton2 singleton = null; // 限制产生多个对象 private Singleton2() { } // 通过该方法获得实例对象 public static Singleton2 getSingleton() { synchronized (singleton) { if (singleton == null) { singleton = new Singleton2(); } } return singleton; }}如果不加synchronized进行控制，如果第一个线程A执行到singleton = new Singleton2()，但还没有获得对象，第二个线程B也在执行，执行到if (singleton == null)判断，那么线程B获得判断条件为真，于是继续运行下去，线程A和B都获得了对象，内存中就出现了两个对象。建议使用饿汉式单例，那是线程安全的单例模式。 2. 需要考虑对象的复制情况。在Java中，若实现Cloneable接口，并实现了clone方法，则可以直接通过对象复制方式创建一个新对象，对象复制是不用调用类的构造函数的。 3. 注意JVM的垃圾回收机制，如果我们的一个单例对象在内存中长久不使用，JVM就认为这是一个垃圾对象，在CPU资源空闲的情况下该对象会被清理掉，下次再调用时就需要产生一个新对象。如果该对象作为有状态值的管理，则会出现状态恢复原状的情况，就会出现故障。有两种方法可以解决该问题1、由容器管理单例的生命周期Java EE容器或者框架级容器（如Spring）可以让对象长久驻留内存。2、状态随时记录可以使用异步记录的方式，或者使用观察者模式，记录状态的变化，写入文件或写入数据库中，确保即使单例对象重新初始化也可以从资源环境获得销毁前的数据，避免应用数据丢失。单例模式的扩展：能产生固定数量实例的单例模式/** * 能产生固定数量实例的单例模式 * @author Administrator * */public class Singleton3 { // 最多能产生的实例数 private static int maxNumOfSingleton = 2; // 定义一个列表，容纳所有实例 private static ArrayList<Singleton3> singletonList = new ArrayList<Singleton3>(); // 产生所有对象 static { for (int i = 0; i < maxNumOfSingleton; i++) { singletonList.add(new Singleton3()); } } // 限制其他类生成对象 private Singleton3() { } // 随机获得一个实例 public static Singleton3 getInstance() { Random random = new Random(); return singletonList.get(random.nextInt(maxNumOfSingleton)); }}

创建型：1. 单件模式(Singleton Pattern) 2. 抽象工厂（Abstract Factory） 3. 建造者模式(Builder) 4. 工厂方法模式（Factory Method) 5. 原型模式(Prototype)结构型：6. 适配器模式（Adapter Pattern) 7. 桥接模式（Bridge Pattern) 8. 装饰模式(Decorator Pattern) 9. 组合模式(Composite Pattern) 10. 外观模式（Facade Pattern) 11. 享元模式(Flyweight Pattern) 12. 代理模式(Proxy Pattern) 13. 模板方法(Template Method) 14. 命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 行为型：16. 观察者模式(Observer Pattern） 17. 解释器模式(Interpreter Pattern) 18. 中介者模式(Mediator Pattern) 19. 职责链模式(Chain ofPattern) 20. 备忘录模式(Memento Pattern) 21. 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)

最近在看JDK源码，想在毕业前再好好提高一下写代码的能力，JDK是个优秀的源码阅读范本（spring的源码也不错）。JDK目录下的src.zip里可以直接获得源码，我也push到了我Github的一个repo里。网上搜了JDK设计模式，coolshell里也有一篇，不过我还是参照了Stackoverflow(原文链接)上的一个“Examples of GoF Design Patterns”的答复，详细列举了JDK里具体对应的类和函数，并结合了wiki上的许多整理好的优秀词条内容。放到这个博客上，也方便自己深入学习，好好体会下设计模式内涵，光看书也会很枯燥，况且纸质的代码看起来也不舒服。

接口在php只能起到约束类的定义作用，虽不像c#/java那么直观，但基于oop的封装要求，使用接口可以提高程序的可扩展性，如实现代理设计模式。复制代码代码如下:<?php//人类接口interfaceIHuman{functionGetName();}//男人类，实现人类接口classManClassimplementsIHuman{//获取姓名方法publicfunctionGetName(){return"I"mman."."<br>";}}//女人类，实现人类接口classWomanClassimplementsIHuman{//获取姓名方法publicfunctionGetName(){return"I"mWoman."."<br>";}}//类工厂，根据需要生产不同实例对象返回classManFactory{//根据参数获取实例对象publicfunctionGetIHuman($IHuman="man"){if($IHuman=="woman"){returnnewWomanClass();}elseif($IHuman=="man"){returnnewManClass();}else{returnnull;}}//直接获取woman类publicfunctionGetWoman(){returnnewWomanClass();//returnnewManClass();}//直接获取man类publicfunctionGetMan(){returnnewManClass();}}$ManFactory=newManFactory();$ManClass=$ManFactory->GetIHuman();echo$ManClass->GetName();$IHuman=$ManFactory->GetIHuman("woman");echo$IHuman->GetName();$Woman=$ManFactory->GetWoman();echo$Woman->GetName();$Man=$ManFactory->GetMan();echo$Man->GetName();?>运行结果:I"mman.I"mWoman.I"mWoman.I"mman.

关注这个问题