﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>C++博客-Tim-随笔分类-设计模式</title><link>http://www.cppblog.com/Tim/category/10025.html</link><description>灵活的思考，严谨的实现</description><language>zh-cn</language><lastBuildDate>Tue, 29 Mar 2011 16:13:59 GMT</lastBuildDate><pubDate>Tue, 29 Mar 2011 16:13:59 GMT</pubDate><ttl>60</ttl><item><title>学习和理解设计模式</title><link>http://www.cppblog.com/Tim/archive/2011/03/29/142731.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Tue, 29 Mar 2011 03:07:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2011/03/29/142731.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/142731.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2011/03/29/142731.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/142731.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/142731.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp; 摘要: 对任何事物或原理的研究和学习，一定要始终记住一个要点：只有思维先进入这一层，也就是在大脑里形成分析该问题的上下文环境，在这个基础上，然后再用想关的思维方式考虑问题，才是清晰的，才是正确的。尤其是对深层原理和技术，必须是这样。&nbsp;&nbsp;<a href='http://www.cppblog.com/Tim/archive/2011/03/29/142731.html'>阅读全文</a><img src ="http://www.cppblog.com/Tim/aggbug/142731.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2011-03-29 11:07 <a href="http://www.cppblog.com/Tim/archive/2011/03/29/142731.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————11、无熟人难办事？——迪米特法则</title><link>http://www.cppblog.com/Tim/archive/2009/04/21/80653.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Tue, 21 Apr 2009 15:25:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/04/21/80653.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/80653.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/04/21/80653.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/80653.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/80653.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; PADDING-TOP: 0pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">浅读《大话设计模式》————</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">11</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">、</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">无熟人难办事？——迪米特法则</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">迪米特法则（LoD），如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者调用。[J&amp;DP]</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">本法则强调的是，在类的设计上，应该尽量保证类之间的松耦合。类之间的关系不应该必须是直接调用的，而应该是通过抽象来实现各自的功能。就如同人际关系办事情，如果是必须要针对个人，那么没有熟人或者熟人不在，那就办不成了？这种体制显然不好！比如，希望政府办的事情，应该不需要知道要谁来处理，只是统一向政府提个需求，然后他们内部派人处理好！迪米特法则，最少知识原则。</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/80653.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-04-21 23:25 <a href="http://www.cppblog.com/Tim/archive/2009/04/21/80653.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————10、模板方法模式</title><link>http://www.cppblog.com/Tim/archive/2009/04/21/80648.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Tue, 21 Apr 2009 14:41:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/04/21/80648.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/80648.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/04/21/80648.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/80648.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/80648.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; PADDING-TOP: 0pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">浅读《大话设计模式》————</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">10</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">、</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">模板方法</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">模式</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">模板方法模式，定义一个操作中的算法的骨架，而将一些步聚延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定不聚。[DP]</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">模板方法的优点：通过把不变的行为放到父类，并在父类中提供模板方法，父类中还可能内部调用一些细节函数，但是这些细节函数是虚函数，由不同的子类实现不同的具体功能。这样子类完成特定的行为，但是不需要重复的代码。</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">好了，简单的模板方法模式，同样是面向对象中继承和多态的组合运用。学好了！</span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: 'Times New Roman'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/80648.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-04-21 22:41 <a href="http://www.cppblog.com/Tim/archive/2009/04/21/80648.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————9、简历复印——原型模式</title><link>http://www.cppblog.com/Tim/archive/2009/04/20/80572.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Mon, 20 Apr 2009 14:15:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/04/20/80572.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/80572.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/04/20/80572.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/80572.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/80572.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; PADDING-TOP: 0pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">浅读《大话设计模式》————</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">9</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">、</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">简历复印</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">——</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">原型</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">模式</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">原型模式，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。[DP]</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节。看到这些说明，我想这是不是可以理解为c++中的拷贝构造函数呢？这可能是需求中最常见的模式了。</span><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="PADDING-RIGHT: 0pt; MARGIN-TOP: 0pt; PADDING-LEFT: 0pt; MARGIN-BOTTOM: 0pt; PADDING-BOTTOM: 0pt; TEXT-INDENT: 21pt; PADDING-TOP: 0pt; TEXT-ALIGN: left"><span style="FONT-SIZE: 10.5pt; COLOR: rgb(0,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">如果从这个角度理解，无疑的，这个模式就可以通过了。只是他告诉我们：设计的时候考虑批量生产的情况，所以需要提供复制的方法。至于文中所讲的浅复制和深复制，好像C#中才考虑这个问题，c++中指针引用等是必须要特定处理的。学好了！</span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: 'Times New Roman'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/80572.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-04-20 22:15 <a href="http://www.cppblog.com/Tim/archive/2009/04/20/80572.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————8、雷锋依然在人间——工厂方法模式</title><link>http://www.cppblog.com/Tim/archive/2009/04/20/80571.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Mon, 20 Apr 2009 14:02:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/04/20/80571.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/80571.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/04/20/80571.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/80571.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/80571.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>浅读《大话设计模式》————8、雷锋依然在人间——工厂方法模式</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>简单工厂模式、工厂方法模式，这两者的区别我想顾名思义！前者讲的是这个模式用到一个简单工厂，但是后者强调的是工厂方法，其实意思就是该模式中工厂设计很重要。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>其实理解了简单工厂，基本上只要再稍微看一下工厂模式的设计，就很容易理解这两个模式。不过，似乎工厂方法模式是简单工厂模式的改进版，简单工厂没有存在的必要。但是事实并非如此，在扩展不经常的时候，一个简单工厂就可以了。但是要是经常有相似功能的扩展需求，那么工厂方法模式就要有价值一些。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>在代码形式上，简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是，工厂方法是把简单工厂的内部逻辑判断移到了客户端代码来进行。所以，想要增加功能，就同时需要修改客户端代码。但是这样代码结构还是很清晰的，所以两者各有千秋！</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/80571.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-04-20 22:02 <a href="http://www.cppblog.com/Tim/archive/2009/04/20/80571.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————7、为别人做嫁衣——代理模式</title><link>http://www.cppblog.com/Tim/archive/2009/04/16/80197.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Thu, 16 Apr 2009 14:41:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/04/16/80197.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/80197.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/04/16/80197.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/80197.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/80197.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp; 摘要: 代理模式中，真正动作人要代理做的事情，自己也要定义做的方法，就是自己要处理具体的事情。而代理，无非就是利用成员对象进行接口转移罢了。但是现实世界，代理是要全权处理所代理的事情的。游戏开发公司完全只是开发，与玩家的交互，服务器的维护则完全是运营代理商的事。所以，在学习代理模式时，我觉得应该首先明白在思想上对这两者进行弄明白。<br><br>代理模式：为其他对象提供一种代理以控制对这个对象的访问[DP]。<br><br>如果从以上这个定义，我们还可以挖掘出另一种层次的意思：代理模式为真实对象的访问提供了安全性屏障。<br>&nbsp;&nbsp;<a href='http://www.cppblog.com/Tim/archive/2009/04/16/80197.html'>阅读全文</a><img src ="http://www.cppblog.com/Tim/aggbug/80197.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-04-16 22:41 <a href="http://www.cppblog.com/Tim/archive/2009/04/16/80197.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————6、穿什么有这么重要？——装饰模式</title><link>http://www.cppblog.com/Tim/archive/2009/04/16/80183.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Thu, 16 Apr 2009 12:55:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/04/16/80183.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/80183.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/04/16/80183.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/80183.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/80183.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp; 摘要: 装饰模式总结：装饰模式是为了为已有功能动态的添加更多功能的一种方式。<br>他把每个要装饰的功能放在单独的类中，并让每个类包装他所要装饰的对象，因此，当需要执行特定行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了[DP]。&nbsp;&nbsp;<a href='http://www.cppblog.com/Tim/archive/2009/04/16/80183.html'>阅读全文</a><img src ="http://www.cppblog.com/Tim/aggbug/80183.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-04-16 20:55 <a href="http://www.cppblog.com/Tim/archive/2009/04/16/80183.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》————5、会修电脑不会修收音机？——依赖倒转原则</title><link>http://www.cppblog.com/Tim/archive/2009/03/31/78514.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Tue, 31 Mar 2009 15:10:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/03/31/78514.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/78514.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/03/31/78514.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/78514.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/78514.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>浅读《大话设计模式》————5、会修电脑不会修收音机？——依赖倒转原则</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>电脑比收音机简单吗？为什么拆开两者，很明显，收音机看起来还要比电脑更复杂呢？原来，好的架构好的设计在哪里都是通用的！电脑各部件缺一不可，但是绝不是只针对某一个或者某一类产品，所有不同产品的厂商都只服从一个统一的标准，这样，我们就看不出电脑中哪一个是高层了。CPU？内存？或者主板？。。。都不是，谁也不依赖谁，依赖的是一个统一的接口标准！</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>依赖倒转原则：抽象不应该依赖细节，细节应该依赖抽象。具体到一个实际问题编程，应该是定义好的接口，这个接口不属于哪一个具体的东西，应该是一个高层的抽象，然后就是针对接口编程，而不要对实现编程。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>讲到这里，似乎世界的一切问题都迎刃而解，一切显得是那样的轻而易举！慢！一定不要自负的轻视对手，好，谁都很听话的服从这个抽象接口，那么这个抽象接口怎么来？一切都在变，难道这个抽象类就是可以违背这个哲学上绝对真理的特例家伙？他可能自身都要不停的变！完了，到哪里去找这样一根标尺呀？</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>标尺也是自己定义的！无非是会需要随实际情况变化吗？不要忘了，我们已经学会的绝技——开放—封闭原则。我们保证提供基本功能的接口不变，实际需求增加时，只要做开放扩展即可，面向对象的继承能帮助我们找到正确适用实际问题的方法，问题不就解决了吗？恩，这样设计总结出统一的抽象接口或者抽象类是满足我们的需求的，不过，还有关键的一点，这一系列类必须要满足一个原则：里氏代换原则：子类型必须能够替换掉他们的父类型。这个原则在许多别的情况下，并不一定是完全满足的，但是此处用做标尺的抽象类，必须要满足！子类可以扩展做更多的事情，但是父类已经定义好的接口子类必须有实现，并且也必须是做一致的事情。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>依赖倒转原则说明了：好的面向对象设计不应该是依赖具体实现中的那一部分，应该是针对抽象编程而不是针对细节编程，即程序中所有的依赖关系都是终止于抽象类或者接口。那样，高层、底层的改变都不会导致另外一部分要做变化了。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>从北京去纽约喽，;-)，还有陆路还要海洋，哈哈，变化再大我也不管，因为我做的是飞机！不过，你要是愿意先客车再渡轮也可以的哦~都是交通工具的抽象嘛！应该不会还有那个大侠想着依赖道路的，先穿跑鞋再换个泳衣去的吧~</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/78514.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-03-31 23:10 <a href="http://www.cppblog.com/Tim/archive/2009/03/31/78514.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》---------------4、考研求职两不误----开放-封闭原则</title><link>http://www.cppblog.com/Tim/archive/2009/03/30/78427.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Mon, 30 Mar 2009 15:34:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/03/30/78427.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/78427.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/03/30/78427.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/78427.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/78427.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>浅读《大话设计模式》---------------4、考研求职两不误----开放-封闭原则</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>开放—封闭原则，是说软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。[ASD]。这个原则有两个特征：对于扩展是开放的，另一个是说对于更改是封闭的。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>本原则经过作者精辟的阐述，马上就让我们在哲学上对一些问题的看法豁然开朗：看起来两个完全抵触的东西，利用扩展与封闭原则就能很好的解决。什么东西必须关闭，什么东西可以扩展？主权和业绩是必须关闭修改的，但是制度却是可以扩展开放的！难道这仅仅是一种计算机理论吗？这简直是处事之道！</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>如何应对变化？——除非你足够强大，所有的人和事都无条件的服从你的，否则就需要面对无法预料的变化。事实上，对未来变化的估计和处理能力正是智慧的体现。好像离程序设计越来越远了哦~言归正传，既然变化是无法避免的，那么对已有的机制进行对应的修改也是必须的（真的有&#8220;以不变应万变&#8221;么？）。所以，&#8220;绝对的修改关闭是不可能的。无论模块是多么的&#8216;封闭&#8217;，都会存在一些无法对之封闭的变化。既然不可能完全封闭，设计人员必须对于他设计的模块应该对那种变化封闭做出选择。他必须先猜测出最有可能发生的变化种类，然后构造抽象来隔离那些变化[ASD]。&#8221;</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">&#8220;<font face=宋体>在我们最初编写代码时，假设变化不会发生。当变化发生时，我们就创建抽象来隔离以后发生的同类变化[ASD].&#8221;这里同时也反映了一个问题：要架构好的程序，我们需要善于分析程序的变化，善于总结善于抽象！当遇到问题了，我们应该思考这一类问题，并作出抽象改善程序的架构，提取出真正的封闭的和开放的部分。</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>大鸟的总结：&#8220;开放—封闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象，然而，对于应用程序中的每个部分都刻意地进行抽象同样不是一个好主意。拒绝不成熟的抽象和抽象本身一样重要[ASD]。&#8221;</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>很好，从本设计模式学到了很多很多，远远超过了程序设计的范畴！哈哈，考研的例子我觉得也很合适嘛。全力以赴是必须的，两手准备也是一种灵活。只要别忘了自己当前的重点——就像快乐一样，得到成功的目标是关闭的，但过程是开放的！</font></span><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt; TEXT-INDENT: 21pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/78427.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-03-30 23:34 <a href="http://www.cppblog.com/Tim/archive/2009/03/30/78427.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》----------------3、拍摄UFO------单一职责原则</title><link>http://www.cppblog.com/Tim/archive/2009/03/30/78426.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Mon, 30 Mar 2009 15:33:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/03/30/78426.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/78426.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/03/30/78426.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/78426.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/78426.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-ALIGN: center"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><font face=宋体>浅读《大话设计模式》----------------</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">3<font face=宋体>、拍摄UFO------单一职责原则</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><br></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>这个模式应该是最容易理解的一个模式了。不过解释意义还是比较有深度的：就有一个类而言，应该仅有一个引起它变化的原因[ASD]。职责越单一，功能就越独立。也就没有复杂度，就更好维护，也更利于复用了。</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-ALIGN: justify"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<font face=宋体>作者对这个模式的运用和解释已经很清楚了&#8220;软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离[ASD].其实要去判断是否应该分离出类来，也不难，那就是如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责[ASD],就应该考虑类的职责分离。&#8221;</font></span></p>
</div>
<!--endfragment-->
<img src ="http://www.cppblog.com/Tim/aggbug/78426.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-03-30 23:33 <a href="http://www.cppblog.com/Tim/archive/2009/03/30/78426.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》----------------2、商场促销-----策略模式</title><link>http://www.cppblog.com/Tim/archive/2009/03/29/78322.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Sun, 29 Mar 2009 15:25:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/03/29/78322.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/78322.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/03/29/78322.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/78322.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/78322.html</trackback:ping><description><![CDATA[<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<div class=Section0 style="LAYOUT-GRID:  15.6pt none">
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><font face=宋体>浅读《大话设计模式》</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><br></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'">----------------</span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">2</span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><font face=宋体>、</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>商场促销-----策略模式</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>从本章我首先得到的第一个信息是：策略模式的问题，简单工厂模式也能实现；推而广之，同一个问题，可能许多模式都能实现，但是这里总存在一个更优的问题。至于真正用那个模式，就是C++之父的那句话了：需要经验智慧了。</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>第二个马上引出问题的结论：&#8220;面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类&#8221;。这一句，我觉得是最深刻的道出类设计原则的精辟之语。意思：第一、类并非越多越好，设计一个类是有价值有意义的：是为了封装（简单工厂的那个工厂类就是一个纯封装作用的类，但大多数情况建立一个类还需要别的理由，可能简单工厂属于一个特例）。第二、何时设计类，当处理的看似一些杂乱无章的东西具有相同的属性和功能时，就有必要创建类，因为，用对象实现某些功能在可维护可复用等方面要比直接的函数过程似的编程要好得多。以上两点，可能就是怎样将实际问题抽象成类的秘诀了！</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>当时我看到现金收费工厂类时，我心里已经为&#8220;菜鸟&#8221;拍案叫绝了。他的学习能力好强呀！⊙﹏⊙b汗！然而，大鸟后面的那些一针见血的话同时也让我进入了沉思。。。当我们发现自己好不容易掌握了一样东西，我们似乎认为自己学得是易筋经，以后就可以以此横扫天下了，但是还没出走出山门，就被路上的山贼给鄙视了。。。这可能是少林寺有了易筋经还要有72绝技的原因。。。</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>被鄙视的原因：简单工厂模式只是解决了对象的创建问题，工厂需要包括所有的对象的创建，如果对象形式经常变化，就需要经常改动工厂，以致代码重新编译。结论：面对对象形式不断变化的情况，应该采取比工厂模式更好的武功！</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>幸亏这本秘籍并不难找：策略模式---它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。[DP]</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>问题：在2.7策略模式解析之上的部分，作者最终利用的方法是将策略模式与简单工厂模式结合起来用，当然与之对比的简单工厂模式显然稍逊一筹。但是我个人的观点是：此处采用单纯的策略模式而不是两者结合更好。即2.5的实现，因为我认为：加入工厂模式就同时将本问题中工厂模式的问题带进来了，策略模式的Context需要经常重新编译；而相对于算法经常变化的情况，将算法选择交给客户端应该还是可取的。现对而言，我认为前者更好操作。不够，当我读到本章最后时，我才又一次发现我的孤陋寡闻！还有更好的招！后面再学。</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>策略模式的关键之一----------Context:&#8220;策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能&#8221;。</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>策略模式理解核心-------------&#8220;</font></span><span style="FONT-SIZE: 9.5pt; COLOR: rgb(255,0,0); FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>策略模式就是用来封装算法的</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性[DPE]&#8221;。</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><font face=宋体>在基本的策略模式中，选择所用的具体实现的职责由客户端对象承担，并转给策略模式的Context对象[DPE]。这是策略模式本身纯粹的定义，所以，&#8220;选择所用最终怎样处理&#8221;还有很多文章可做！</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 5pt; MARGIN-BOTTOM: 5pt; TEXT-INDENT: 21pt; LINE-HEIGHT: 150%"><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: '宋体'; mso-spacerun: 'yes'">&#8220;<font face=宋体>反射反射，程序员的快乐&#8221;，我以前又从来没有听过。。。怎么让我想起了慕容家族的绝技-----斗转星移了呢？我的神呀？</font></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><br></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><br></span><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: 'Times New Roman'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
<p class=p0 style="MARGIN-TOP: 0pt; MARGIN-BOTTOM: 0pt"><span style="FONT-SIZE: 10.5pt; FONT-FAMILY: 'Times New Roman'; mso-spacerun: 'yes'"><o:p></o:p></span></p>
</div>
<!--endfragment--><span style="FONT-SIZE: 9.5pt; FONT-FAMILY: 'Verdana'; mso-spacerun: 'yes'"><font face=宋体>
<p>&nbsp;</p>
</font></span></div>
<p>&nbsp;</p>
<p>&nbsp;</p>
<img src ="http://www.cppblog.com/Tim/aggbug/78322.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-03-29 23:25 <a href="http://www.cppblog.com/Tim/archive/2009/03/29/78322.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>浅读《大话设计模式》----------------1、代码无错就是优？---简单工厂模式</title><link>http://www.cppblog.com/Tim/archive/2009/03/29/78307.html</link><dc:creator>Tim</dc:creator><author>Tim</author><pubDate>Sun, 29 Mar 2009 13:46:00 GMT</pubDate><guid>http://www.cppblog.com/Tim/archive/2009/03/29/78307.html</guid><wfw:comment>http://www.cppblog.com/Tim/comments/78307.html</wfw:comment><comments>http://www.cppblog.com/Tim/archive/2009/03/29/78307.html#Feedback</comments><slash:comments>1</slash:comments><wfw:commentRss>http://www.cppblog.com/Tim/comments/commentRss/78307.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/Tim/services/trackbacks/78307.html</trackback:ping><description><![CDATA[<p>浅读《大话设计模式》----------------1、代码无错就是优？---简单工厂模式<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;如果说面向对象没有用，如果争辩自己当前处理的问题是一个很简单的问题所以自己不用面向对象的方法来处理。那么，曹操的&#8220;喝酒唱歌，人生真爽&#8221;到&#8220;对酒当歌，人生几何&#8221;就是一个很有针对性很有讽刺意义的例子，这简直是作者的神来之笔！面向对象的巨大意义：第一、可维护；第二、可复用；第三、可扩展；第四、灵活性好。写程序的发展：学习了面向对象的分析设计编程思想，开始考虑通过封装、继承、多态把程序的耦合度降低；用设计模式使得程序更加的灵活，容易修改，并且易于复用。<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;其实，从以上这段话，我觉得也说明了设计模式是在面向对象方法基础之上的，所以首先应该熟练的运用面向对象的基本特征：封装、继承和多态！从本章中的计算器程序的例子，我们应该敏感的发现这样一个问题：无论多么小的程序，都可以用到面向对象！都可以用封装、继承、多态！而这个看起来很小很简单的结论，我这个C++程序员竟然之前还是持否认态度！说实话，当时看到这些，我很震惊！<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;这其实反映的是软件设计的需求：一定要降低耦合度，让其更容易维护更好复用更灵活~！记住了，清晰合理的面向对象，怎么都不过分！<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;简单工厂模式：终于由面向对象进入设计模式了！为什么叫简单工厂模式而不叫工厂模式或者负责工厂模式了？因为这个工厂确实就是一个很简单的逻辑判断，一般只需一个switch即可，不过其作用却也是很好很大的！他负责创建别的类的实例！&nbsp;&nbsp;<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 简单工厂的运用：如果将针对从一个父类继承的多个子类进行不同条件下的实例化和运用等，这个选择判断的条件可能比较多，显示为客户端代码显得冗余，或者那些子类本身就是不希望让客户端看到的，此时将这些判断放到一个统一的工厂里面生产将是一种很好的封装模式。记住：工厂只要一个，也就是说经常要选择处理许多同父类对象。一个工厂是只有自己的一个产品线的，要生产本质差别不大但是种类繁多的产品的工厂才有意义！内部并非要进行很多很多复杂的加工处理才能形成产品，相反，应该是简单处理就能得到产品，这才是简单工厂模式。也就是说：是很简单的处理最终得到某种产品，甚至都不负责产品出厂后的维护工作。毕竟，他的定位只是一个小作坊：用面向对象的思想，一个类实现一个函数的功能！</p>
<img src ="http://www.cppblog.com/Tim/aggbug/78307.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/Tim/" target="_blank">Tim</a> 2009-03-29 21:46 <a href="http://www.cppblog.com/Tim/archive/2009/03/29/78307.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>