大话设计模式

最新推荐文章于 2021-04-03 22:09:05 发布

jjjsss2

最新推荐文章于 2021-04-03 22:09:05 发布

阅读量684

点赞数

分类专栏：数据库文章标签：设计模式 java 人工智能

本文链接：https://blog.csdn.net/jjjsss2/article/details/84854202

版权

数据库专栏收录该内容

5 篇文章 0 订阅

订阅专栏

<div class="iteye-blog-content-contain" style="font-size: 14px;">
 
 
SET FOREIGN_KEY_CHECKS=0;
 
-- ----------------------------
-- Table structure for t_xxx_study_books
-- ----------------------------
DROP TABLE IF EXISTS `t_xxx_study_books`;
CREATE TABLE `t_xxx_study_books` (
 `id` bigint(20) NOT NULL AUTO_INCREMENT,
 `book` varchar(20) NOT NULL DEFAULT '设计模式读书笔记',
 `chapter` varchar(20) DEFAULT '博客：原型模式',
 `name` varchar(25) NOT NULL DEFAULT '',
 `content` varchar(200) NOT NULL DEFAULT '',
 `type` varchar(20) NOT NULL DEFAULT '枝叶',
 `source` varchar(50) NOT NULL DEFAULT '',
 `pid` varchar(20) CHARACTER SET utf16 NOT NULL DEFAULT '537',
 `my_think` varchar(20) NOT NULL DEFAULT '',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=561 DEFAULT CHARSET=utf8;
 
-- ----------------------------
-- Records of t_xxx_study_books
-- ----------------------------
INSERT INTO `t_xxx_study_books` VALUES ('1', '博客园', '博客', '设计模式总结', '内容很详细，值得详读', '总体', '网址：http://www.cnblogs.com/chenssy/p/3357683.html', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('2', '设计模式总结', ' 设计模式总概况', '面向对象设计原则(七)', '开闭、里氏替换、单一职责、迪米特法则、接口隔离、依赖倒转、合成复用（不算吗？就是六原则）', '总部', '', '1', '合成复用不算一个原则么？');
INSERT INTO `t_xxx_study_books` VALUES ('3', '面向对象设计原则', '1.开闭原则', 'Open Close Principle', '对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。', '分部', '', '1-2', '扩展性好，易于维护和升级。');
INSERT INTO `t_xxx_study_books` VALUES ('4', '面向对象设计原则', '1.开闭原则', '如何做到对扩展开放，对修改关闭？', '想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。', '枝叶', '', '1-2-3', '接口和抽象类，其他设计模式都是为了达成这');
INSERT INTO `t_xxx_study_books` VALUES ('5', '面向对象设计原则', '2.依赖倒转原则', 'Dependence Inversion', '要依赖于抽象，不要依赖于具体。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。', '分部', '实现编程，就是new对象', '1-2', '依赖于抽象，不要依赖于具体：解耦');
INSERT INTO `t_xxx_study_books` VALUES ('6', '面向对象设计原则', '2.依赖倒转原则', '如何实现呢？', '实现开闭原则的关键是抽象化，并且从抽象化导出具体化实现，如果说开闭原则是面向对象设计的目标的话，那么依赖倒转原则就是面向对象设计的主要手段。 from：百度百科', '枝叶', '领悟：A、B类直接依赖，要实现解耦，必须引入第三方：抽象层', '1-2-5', '抽象化，导出具体化实现');
INSERT INTO `t_xxx_study_books` VALUES ('7', '面向对象设计原则', '2.依赖倒转原则', '如何理解倒转？', '原来是A类直接依赖具体实现类B，这时引入第三方接口C，这时A直接从C获取服务，通过里氏替换原则，实际服务者还是C，但A就不知道B了，只与C交互了。所谓倒转，不是真的倒转，而是打破原来的依赖，依赖更上层的抽象了，依赖从具体的底部到抽象的顶部的转变，就是所谓的倒转。', '枝叶', '触类旁通，这就是举一反三吧', '1-2-5', '这里的倒转理解，来自于IoC的反转。');
INSERT INTO `t_xxx_study_books` VALUES ('8', '面向对象设计原则', '3.里氏替换原则', 'Liskov Substitution', '任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。', '分部', '', '1-2', 'Java语言特性-复用');
INSERT INTO `t_xxx_study_books` VALUES ('9', '面向对象设计原则', '3.里氏替换原则', '如何理解里氏替换原则？', '里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。from：百度百科', '枝叶', '', '1-2-8', '开闭原则的补充。');
INSERT INTO `t_xxx_study_books` VALUES ('10', '面向对象设计原则', '4.单一职责原则', '一个类，只有一个引起它变化的原因', '一个类，应该只有一个职责。每一个职责都是变化的一个轴线，如果一个类有一个以上的职责，这些职责就耦合在了一起。这会导致脆弱的设计。', '分部', '', '1-2', '一个职责就可能引起类的一个变化');
INSERT INTO `t_xxx_study_books` VALUES ('11', '面向对象设计原则', '4.单一职责原则', '为什么要按照单一职责设计类？', '当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起，会影响复用性。例如：要实现逻辑和界面的分离。from：百度百科', '枝叶', '', '1-2-10', '职责多=状态变化=混乱，复用差');
INSERT INTO `t_xxx_study_books` VALUES ('12', '面向对象设计原则', '5.接口隔离原则', 'Interface Segregation', '使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。', '分部', '', '1-2', '降低依赖，降低耦合。');
INSERT INTO `t_xxx_study_books` VALUES ('13', '面向对象设计原则', '6.迪米特法则（最少知道原则）', 'Demeter Principle', '为什么叫最少知道(或知识)原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。也就是说一个软件实体应当尽可能少的与其他实体发生相互作用。', '分部', '', '1-2', '类、模块独立，降低耦合');
INSERT INTO `t_xxx_study_books` VALUES ('14', '面向对象设计原则', '6.迪米特法则（最少知道原则）', '为什么要遵守迪米特法则？', '当一个模块修改时，就会尽量少的影响其他的模块，扩展会相对容易，这是对软件实体之间通信的限制，它要求限制软件实体之间通信的宽度和深度。', '枝叶', '', '1-2-13', '扩展更容易');
INSERT INTO `t_xxx_study_books` VALUES ('15', '面向对象设计原则', '7.合成复用原则', 'Composite Reuse', '合成复用原则就是指在一个新的对象里通过关联关系（包括组合关系和聚合关系）来使用一些已有的对象，使之成为新对象的一部分；新对象通过委派调用已有对象的方法达到复用其已有功能的目的。简言之：要尽量使用组合/聚合关系，少用继承。', '分部', '尽量使用组合/聚合关系，少用继承。', '1-2', '复用：通过已有对象达到新功能的目的');
INSERT INTO `t_xxx_study_books` VALUES ('16', '23种设计模式', '分为三类设计模式', '创建型模式(5)、结构(7)、行为(11)', '创建型模式(主要用于创建对象)：抽象工厂、工厂方法、单例、原型、构建者；结构型模式(用于处理类或对象的组合)：适配器、组合、代理、外观、享元、装饰、桥接；行为模式(用于描述类或对象怎样交互和职责怎样分配)：观察者、模板方法、责任链、中介者、命令、解释器、迭代器、备忘录、策略、访问者、状态。', '总部', '', '1', '创建、结构、行为；行为模式11个，较多');
INSERT INTO `t_xxx_study_books` VALUES ('17', '23种设计模式', '1.创建型模式(5)', '主要用于创建对象，有哪些模式呢', '抽象工厂、工厂方法、单例、原型、构建者。都是依赖-关联关系的，即方法的返回值或参数，不是属性(聚合、组合/合成)', '分部', '', '1-16', '依赖-关联-聚合-组合，前两个');
INSERT INTO `t_xxx_study_books` VALUES ('18', '23种设计模式', '1.创建型模式(5)', '解决了什么问题？', '基本的对象创建方式可能会导致设计上的问题，或增加设计的复杂度。创建型模式通过以某种方式控制对象的创建来解决问题。在软件工程中，创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。', '枝叶', '', '1-16-17', '控制对象的创建，不能随便new');
INSERT INTO `t_xxx_study_books` VALUES ('19', '23种设计模式', '1.创建型模式(5)', '两个主导思想构成？', '创建型模式由两个主导思想构成：一是将系统使用的具体类封装起来，二是隐藏这些具体类的实例创建和结合的方式。', '枝叶', '', '1-16-17', '1.封装具体类，2.隐藏创建和结合');
INSERT INTO `t_xxx_study_books` VALUES ('20', '23种设计模式', '1.创建型模式(5)', '创建型模式分类：2种', '创建型模式又分为对象创建型模式和类创建型模式。对象创建型模式处理对象的创建，类创建型模式处理类的创建。详细地说，对象创建型模式把对象创建的一部分推迟到另一个对象中，而类创建型模式将它对象的创建推迟到子类中。', '枝叶', '', '1-16-17', '1对象创建：另一个对象；2.类创建：子类');
INSERT INTO `t_xxx_study_books` VALUES ('21', '23种设计模式', '1-1 抽象工厂模式', 'Abstract Factory', '所谓抽象工厂模式就是她提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。', '分部', '', '1-16-17', '');
INSERT INTO `t_xxx_study_books` VALUES ('22', '23种设计模式', '1-1 抽象工厂模式', '达到的效果(目标)', '他允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。', '枝叶', '', '1-16-17-21', '');
INSERT INTO `t_xxx_study_books` VALUES ('23', '23种设计模式', '1-1 抽象工厂模式', '优缺点', '它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了；而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更改接口及其下所有子类。', '枝叶', '', '1-16-17-21', '隔离具体类，新增接口产品');
INSERT INTO `t_xxx_study_books` VALUES ('24', '23种设计模式', '1-1 抽象工厂模式', 'UML图', 'Client只知道Factory、AbstractProductA、AbstractProductB；而不用知道ConcreteFactory1、ConcreteFactory2、ConcreteProductA1、ConcreteProductA2、ConcreteProductB1、ConcreteProductB2。', '枝叶', '', '1-16-17-21', '');
INSERT INTO `t_xxx_study_books` VALUES ('25', '23种设计模式', '1-1 抽象工厂模式', '角色参与者(4个)', '抽象工厂、具体工厂、抽象产品(这是一个产品家族，每一个具体工厂都能够生产一整组产品。)、具体产品。', '枝叶', '', '1-16-17-21', '');
INSERT INTO `t_xxx_study_books` VALUES ('26', '23种设计模式', '1-2 建造者模式(Builder)', '将一个复杂对象的构建与表示分离', '对于建造者模式而已，它主要是将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。适用于那些产品对象的内部结构比较复杂。', '枝叶', '', '1-16-17', '');
INSERT INTO `t_xxx_study_books` VALUES ('27', '23种设计模式', '1-2 建造者模式(Builder)', '达到的效果(目标)', '建造者模式将复杂产品的构建过程封装分解在不同的方法中，使得创建过程非常清晰，能够让我们更加精确的控制复杂产品对象的创建过程，同时它隔离了复杂产品对象的创建和使用，使得相同的创建过程能够创建不同的产品。', '枝叶', '', '1-16-17-26', '');
INSERT INTO `t_xxx_study_books` VALUES ('28', '23种设计模式', '1-2 建造者模式(Builder)', '缺点-不适用的场景', '如果某个产品的内部结构过于复杂，将会导致整个系统变得非常庞大，不利于控制，同时若几个产品之间存在较大的差异，则不适用建造者模式，毕竟这个世界上存在相同点大的两个产品并不是很多，所以它的使用范围有限。', '枝叶', '', '1-16-17-26', '');
INSERT INTO `t_xxx_study_books` VALUES ('29', '23种设计模式', '1-2 建造者模式(Builder)', 'UML图、参与者', '抽象建造者，具体建造者, 指挥者 , 产品角色', '枝叶', '', '1-16-17-26', '');
INSERT INTO `t_xxx_study_books` VALUES ('30', '23种设计模式', '1-2 建造者模式(Builder)', 'Director：指挥者', '构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象，它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。 ', '枝叶', '简单工厂时，构造的对象复杂时用。', '1-16-17-26', '核心角色，不单独使用');
INSERT INTO `t_xxx_study_books` VALUES ('31', '23种设计模式', '1-3 工厂方法模式', 'Factory Method', '作为抽象工厂模式的孪生兄弟，工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，也就是说工厂方法模式让实例化推迟到子类。', '枝叶', '', '1-16-17', '');
INSERT INTO `t_xxx_study_books` VALUES ('32', '23种设计模式', '1-3 工厂方法模式', '模式解决的问题？', '工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关心产品的创建过程，甚至连具体的产品类名称都不需要知道。', '枝叶', '', '1-16-17-31', '');
INSERT INTO `t_xxx_study_books` VALUES ('33', '23种设计模式', '1-3 工厂方法模式', '缺点', '虽然他很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。', '枝叶', '解决：通过反射，工厂就只有一个了', '1-16-17-31', '增加一个具体产品，还需要增加对应的工厂类');
INSERT INTO `t_xxx_study_books` VALUES ('34', '23种设计模式', '1-3 工厂方法模式', 'UML图、参与者(角色)', ' Product：抽象产品。 ConcreteProduct：具体产品。Creator：抽象工厂。 ConcreteCreator：具体工厂。', '枝叶', '', '1-16-17-31', '');
INSERT INTO `t_xxx_study_books` VALUES ('35', '23种设计模式', '1-4 原型模式(Prototype)', '克隆或复制对象', '在我们应用程序可能有某些对象的结构比较复杂，但是我们又需要频繁的使用它们，如果这个时候我们来不断的新建这个对象势必会大大损耗系统内存的，这个时候我们需要使用原型模式来对这个结构复杂又要频繁使用的对象进行克隆。', '枝叶', '', '1-16-17', '');
INSERT INTO `t_xxx_study_books` VALUES ('36', '23种设计模式', '1-4 原型模式(Prototype)', '达到的目的', '所以原型模式就是用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。', '枝叶', '', '1-16-17-35', '');
INSERT INTO `t_xxx_study_books` VALUES ('37', '23种设计模式', '1-4 原型模式(Prototype)', '优点', '它主要应用与那些创建新对象的成本过大时。它的主要优点就是简化了新对象的创建过程，提高了效率，同时原型模式提供了简化的创建结构。', '枝叶', '', '1-16-17-35', '');
INSERT INTO `t_xxx_study_books` VALUES ('38', '23种设计模式', '1-4 原型模式(Prototype)', 'UML结构图、参与者', 'Prototype：抽象原型类。ConcretePrototype：具体原型类。 Client：客户类。', '枝叶', 'Java已经在语言中支持原型了-克隆，所以不需要抽象原型类，而且我也很难相信不底层复制，or new', '1-16-17-35', 'Java中是通过native()的');
INSERT INTO `t_xxx_study_books` VALUES ('39', '23种设计模式', '1-4 原型模式(Prototype)', '定义', '单例模式，从字面上看就是一个实例的意思。所以它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。', '枝叶', '', '1-16-17', '');
INSERT INTO `t_xxx_study_books` VALUES ('40', '23种设计模式', '1-5 单例模式(Singleton)', '三个特点', '单例模式具备如下几个特点：1、只有一个实例。2、能够自我实例化。3、提供全局访问点。', '枝叶', '', '1-16-17-39', '');
INSERT INTO `t_xxx_study_books` VALUES ('41', '23种设计模式', '1-5 单例模式(Singleton)', '使用范围', '所以说当系统中只需要一个实例对象或者系统中只允许一个公共访问点，除了这个公共访问点外，不能通过其他访问点访问该实例时，可以使用单例模式。', '枝叶', '', '1-16-17-39', '');
INSERT INTO `t_xxx_study_books` VALUES ('42', '23种设计模式', '1-5 单例模式(Singleton)', '主要优点', '单例模式的主要优点就是：节约系统资源、提高了系统效率，同时也能够严格控制客户对它的访问。', '枝叶', '', '1-16-17-39', '');
INSERT INTO `t_xxx_study_books` VALUES ('43', '23种设计模式', '1-5 单例模式(Singleton)', '缺点', '也许就是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，所以扩展起来有一定的困难。', '枝叶', '', '1-16-17-39', '违背单一职责，无法扩展');
INSERT INTO `t_xxx_study_books` VALUES ('44', '23种设计模式', '1-5 单例模式(Singleton)', 'UML图、参与者', '其UML结构图非常简单，就只有一个类： Singleton：单例。', '枝叶', '', '1-16-17-39', '');
INSERT INTO `t_xxx_study_books` VALUES ('45', '23种设计模式', '2 结构型模式', '用于处理类或者对象的组合', '结构型模式主要是用于处理类或者对象的组合，它描述了如何来类或者对象更好的组合起来，是从程序的结构上来解决模块之间的耦合问题。', '枝叶', '聚合、组合关系，即属性', '1-16', '方式：组合，解决耦合问题');
INSERT INTO `t_xxx_study_books` VALUES ('46', '23种设计模式', '2 结构型模式', '包括哪些模式？7个', '它主要包括适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式这个七个模式。', '枝叶', '', '1-16-45', '6（2）、1（3）');
INSERT INTO `t_xxx_study_books` VALUES ('47', '23种设计模式', '2-1 适配器模式(Adapter)', '什么是适配器？', '所谓适配器模式就是将一个类的接口，转换成客户期望的另一个接口。它可以让原本两个不兼容的接口能够无缝完成对接。在我们的应用程序中我们可能需要将两个不同接口的类来进行通信，在不修改这两个的前提下我们可能会需要某个中间件来完成这个衔接的过程。这个中间件就是适配器。', '枝叶', '', '1-16-45', '');
INSERT INTO `t_xxx_study_books` VALUES ('48', '23种设计模式', '2-1 适配器模式(Adapter)', '作用', '作为中间件的适配器将目标类和适配者解耦，增加了类的透明性和可复用性。', '枝叶', '', '1-16-45-47', '');
INSERT INTO `t_xxx_study_books` VALUES ('49', '23种设计模式', '2-1 适配器模式(Adapter)', 'UML结构图、参与者', ' Target：目标抽象类。Adapter：适配器类。Adaptee：适配者类。Client：客户类。', '枝叶', 'Adapter：适配器类。通过在内部包装一个Adaptee，将源接口转成目标接口。', '1-16-45-47', '');
INSERT INTO `t_xxx_study_books` VALUES ('50', '23种设计模式', '2-2 桥接模式(Bridge)', '分离过程就使用了桥接模式', '如果说某个系统能够从多个角度来进行分类，且每一种分类都可能会变化，那么我们需要做的就是讲这多个角度分离出来，使得他们能独立变化，减少他们之间的耦合，这个分离过程就使用了桥接模式。所谓桥接模式就是讲抽象部分和实现部分隔离开来，使得他们能够独立变化。', '枝叶', '所谓桥接模式就是讲抽象部分和实现部分隔离开来，使得他们能够独立变化。', '1-16-45', '');
INSERT INTO `t_xxx_study_books` VALUES ('51', '23种设计模式', '2-2 桥接模式(Bridge)', '怎样做到的呢？', '桥接模式将继承关系转化成关联关系，封装了变化，完成了解耦，减少了系统中类的数量，也减少了代码量。', '枝叶', '', '1-16-45-50', '继承变关联(组合)关系。');
INSERT INTO `t_xxx_study_books` VALUES ('52', '23种设计模式', '2-2 桥接模式(Bridge)', 'UML结构图、参与者', '抽象类，扩充抽象类, 实现类接口, 具体实现类', '枝叶', '', '1-16-45-50', '');
INSERT INTO `t_xxx_study_books` VALUES ('53', '23种设计模式', '2-3 组合模式(Composite)', '表示“整体-部分”的结构层次', '组合模式组合多个对象形成树形结构以表示“整体-部分”的结构层次。它定义了如何将容器对象和叶子对象进行递归组合，使得客户在使用的过程中无须进行区分，可以对他们进行一致的处理。', '枝叶', '', '1-16-45', '');
INSERT INTO `t_xxx_study_books` VALUES ('54', '23种设计模式', '2-3 组合模式(Composite)', '注意点、关键点', '在使用组合模式中需要注意一点也是组合模式最关键的地方：叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。', '枝叶', '', '1-16-45-50', '整体和部分实现相同的接口');
INSERT INTO `t_xxx_study_books` VALUES ('55', '23种设计模式', '2-3 组合模式(Composite)', '不适合的场景', '虽然组合模式能够清晰地定义分层次的复杂对象，也使得增加新构件也更容易，但是这样就导致了系统的设计变得更加抽象，如果系统的业务规则比较复杂的话，使用组合模式就有一定的挑战了。', '枝叶', '', '1-16-45-53', '');
INSERT INTO `t_xxx_study_books` VALUES ('56', '23种设计模式', '2-3 组合模式(Composite)', 'UML图、参与者', 'Component ：组合中的对象声明接口, Leaf：叶子对象。Composite：容器对象', '枝叶', 'Composite：容器对象，定义有枝节点行为，用来存储子部件', '1-16-45-53', '');
INSERT INTO `t_xxx_study_books` VALUES ('57', '23种设计模式', '2-4 装饰者模式(Decorator)', '组合的方式来给一个对象添加行为', '我们可以通过继承和组合的方式来给一个对象添加行为，虽然使用继承能够很好拥有父类的行为，但是它存在几个缺陷：一、对象之间的关系复杂的话，系统变得复杂不利于维护。二、容易产生“类爆炸”现象。三、是静态的。在这里我们可以通过使用装饰者模式来解决这个问题。', '枝叶', '', '1-16-45', '继承复用缺陷：复杂、类爆炸、静态的');
INSERT INTO `t_xxx_study_books` VALUES ('58', '23种设计模式', '2-4 装饰者模式(Decorator)', '作用', '装饰者模式，动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更加有弹性的替代方案。', '枝叶', '', '1-16-45-57', '');
INSERT INTO `t_xxx_study_books` VALUES ('59', '23种设计模式', '2-4 装饰者模式(Decorator)', '缺点', '虽然装饰者模式能够动态将责任附加到对象上，但是他会产生许多的细小对象，增加了系统的复杂度。', '枝叶', '', '1-16-45-57', '');
INSERT INTO `t_xxx_study_books` VALUES ('60', '23种设计模式', '2-4 装饰者模式(Decorator)', 'UML图、参与者', ' Component: 抽象构件。ConcreteComponent:具体构件. Decorator: 抽象装饰类。ConcreteDecorator:具体装饰类', '枝叶', 'Decorator: 抽象装饰类。是装饰抽象类，继承了Component', '1-16-45-57', '');
INSERT INTO `t_xxx_study_books` VALUES ('61', '23种设计模式', '2-5 外观模式(Facade)', '第三者来转发调用', '我们都知道类与类之间的耦合越低，那么可复用性就越好，如果两个类不必彼此通信，那么就不要让这两个类发生直接的相互关系，如果需要调用里面的方法，可以通过第三者来转发调用。外观模式非常好的诠释了这段话。', '枝叶', '', '1-16-45', '');
INSERT INTO `t_xxx_study_books` VALUES ('62', '23种设计模式', '2-5 外观模式(Facade)', '统一的接口', '外观模式提供了一个统一的接口，用来访问子系统中的一群接口。它让一个应用程序中子系统间的相互依赖关系减少到了最少，它给子系统提供了一个简单、单一的屏障，客户通过这个屏障来与子系统进行通信。', '枝叶', '', '1-16-45-61', '');
INSERT INTO `t_xxx_study_books` VALUES ('63', '23种设计模式', '2-5 外观模式(Facade)', '优缺点', ' 通过使用外观模式，使得客户对子系统的引用变得简单了，实现了客户与子系统之间的松耦合。但是它违背了“开闭原则”，因为增加新的子系统可能需要修改外观类或客户端的源代码。', '枝叶', '', '1-16-45-61', '');
INSERT INTO `t_xxx_study_books` VALUES ('64', '23种设计模式', '2-5 外观模式(Facade)', 'UML图、参与者', 'Facade: 外观角色。SubSystem:子系统角色。', '枝叶', '', '1-16-45-61', '');
INSERT INTO `t_xxx_study_books` VALUES ('65', '23种设计模式', '2-6 享元模式(Flyweight)', '共享技术对相同或者相似对象实现重用', '在一个系统中对象会使得内存占用过多，特别是那些大量重复的对象，这就是对系统资源的极大浪费。享元模式对对象的重用提供了一种解决方案，它使用共享技术对相同或者相似对象实现重用。', '枝叶', '', '1-16-45', '缓存对象，这个经常用啊');
INSERT INTO `t_xxx_study_books` VALUES ('66', '23种设计模式', '2-6 享元模式(Flyweight)', '如何重用对象呢？', '享元模式就是运行共享技术有效地支持大量细粒度对象的复用。系统使用少量对象,而且这些都比较相似，状态变化小，可以实现对象的多次复用。这里有一点要注意：享元模式要求能够共享的对象必须是细粒度对象。', '枝叶', '', '1-16-45-65', '通过HashMap获取，没有就创建并加入');
INSERT INTO `t_xxx_study_books` VALUES ('67', '23种设计模式', '2-6 享元模式(Flyweight)', '共享原理', '享元模式通过共享技术使得系统中的对象个数大大减少了，同时享元模式使用了内部状态和外部状态，同时外部状态相对独立，不会影响到内部状态，所以享元模式能够使得享元对象在不同的环境下被共享。', '枝叶', '', '1-16-45-65', '');
INSERT INTO `t_xxx_study_books` VALUES ('68', '23种设计模式', '2-6 享元模式(Flyweight)', '缺点', '同时正是分为了内部状态和外部状态，享元模式会使得系统变得更加复杂，同时也会导致读取外部状态所消耗的时间过长。', '枝叶', '', '1-16-45-65', '');
INSERT INTO `t_xxx_study_books` VALUES ('69', '23种设计模式', '2-6 享元模式(Flyweight)', 'UML图、参与者', 'Flyweight: 抽象享元类。 ConcreteFlyweight: 具体享元类。 UnsharedConcreteFlyweight: 非共享具体享元类。 FlyweightFactory: 享元工厂类。', '枝叶', '', '1-16-45-65', '跟缓存有点不同，还有一个非共享类');
INSERT INTO `t_xxx_study_books` VALUES ('70', '23种设计模式', '2-7 代理模式(Proxy)', '给一个对象提供一个代理', '代理模式就是给一个对象提供一个代理，并由代理对象控制对原对象的引用。它使得客户不能直接与真正的目标对象通信。代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。', '枝叶', '', '1-16-45', '类似AOP么？');
INSERT INTO `t_xxx_study_books` VALUES ('71', '23种设计模式', '2-7 代理模式(Proxy)', '代理对象的作用是什么？', '代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的，同时也在一定程度上面减少了系统的耦合度。', '枝叶', '', '1-16-45-70', '中介：保护；降低了耦合');
INSERT INTO `t_xxx_study_books` VALUES ('72', '23种设计模式', '2-7 代理模式(Proxy)', 'UML图、参与者', 'Subject: 抽象角色。 Proxy: 代理角色。 RealSubject: 真实角色。', '枝叶', '', '1-16-45-70', '');
INSERT INTO `t_xxx_study_books` VALUES ('73', '23种设计模式', '2-7 代理模式(Proxy)', '代理角色的作用', ' Proxy: 代理角色。代理对象与真实对象实现相同的接口，所以它能够在任何时刻都能够代理真实对象。代理角色内部包含有对真实对象的引用，所以她可以操作真实对象，同时也可以附加其他的操作，相当于对真实对象进行封装。', '枝叶', '', '1-16-45-70', '相同接口：可代理，真实引用：调用真实操作');
INSERT INTO `t_xxx_study_books` VALUES ('74', '23种设计模式', '3.行为型模式', '行为型模式', '行为型模式主要是用于描述类或者对象是怎样交互和怎样分配职责的。它涉及到算法和对象间的职责分配，不仅描述对象或者类的模式，还描述了他们之间的通信方式，它将你的注意力从控制流转移到了对象间的关系上来。', '分部', '', '1-16', '交互、分配职责');
INSERT INTO `t_xxx_study_books` VALUES ('75', '23种设计模式', '3.行为型模式', '分类：类模式、对象模式', '行为型类模式采用继承机制在类间分派行为，而行为型对象模式使用对象复合而不是继承。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('76', '23种设计模式', '3.行为型模式', '它包括哪些模式？11种模式', '职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式。', '枝叶', '', '1-16-74', '7（3）、3（2）、1（4）');
INSERT INTO `t_xxx_study_books` VALUES ('77', '23种设计模式', '3-1 职责链模式', 'Chain of Responsibility', '职责链模式描述的请求如何沿着对象所组成的链来传递的。它将对象组成一条链，发送者将请求发给链的第一个接收者，并且沿着这条链传递，直到有一个对象来处理它或者直到最后也没有对象处理而留在链末尾端。', '枝叶', '', '1-16-74', '请求沿着对象组成的链条传递');
INSERT INTO `t_xxx_study_books` VALUES ('78', '23种设计模式', '3-1 职责链模式', '职责链模式：避免发送者与接收者耦合', '避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止，这就是职责链模式。', '枝叶', '', '1-16-74-77', '');
INSERT INTO `t_xxx_study_books` VALUES ('79', '23种设计模式', '3-1 职责链模式', '带来的好处(两点)：1.解耦', '在职责链模式中，使得每一个对象都有可能来处理请求，从而实现了请求的发送者和接收者之间的解耦。', '枝叶', '', '1-16-74-77', '解耦');
INSERT INTO `t_xxx_study_books` VALUES ('80', '23种设计模式', '3-1 职责链模式', '带来的好处(两点)：2.灵活、方便', '同时职责链模式简化了对象的结构，它使得每个对象都只需要引用它的后继者即可，而不必了解整条链，这样既提高了系统的灵活性也使得增加新的请求处理类也比较方便。', '枝叶', '', '1-16-74-77', '简化结构(后继者)：带来灵活、方便');
INSERT INTO `t_xxx_study_books` VALUES ('81', '23种设计模式', '3-1 职责链模式', '缺点：不保证、不利于', '但是在职责链中我们不能保证所有的请求都能够被处理，而且不利于观察运行时特征。', '枝叶', '', '1-16-74-77', '');
INSERT INTO `t_xxx_study_books` VALUES ('82', '23种设计模式', '3-1 职责链模式', 'UML图、参与者', 'Handler: 抽象处理者。 ConcreteHandler: 具体处理者。 Client: 客户类。', '枝叶', '', '1-16-74-77', '具体处理者');
INSERT INTO `t_xxx_study_books` VALUES ('83', '23种设计模式', '3-1 职责链模式', 'ConcreteHandler: 具体处理者', '处理它所负责的请求，同时也可以访问它的后继者。如果它能够处理该请求则处理，否则将请求传递到它的后继者。 ', '枝叶', '', '1-16-74-77', '');
INSERT INTO `t_xxx_study_books` VALUES ('84', '23种设计模式', '3-2 命令模式(Command)', '命令模式将请求封装成对象', '命令模式将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。同时命令模式支持可撤销的操作。', '枝叶', '', '1-16-74', '可撤销的操作');
INSERT INTO `t_xxx_study_books` VALUES ('85', '23种设计模式', '3-2 命令模式(Command)', '什么是命令模式？', '有些时候我们想向某个对象发送一个请求，但是我们并不知道该请求的具体接收者是谁，具体的处理过程是如何的，们只知道在程序运行中指定具体的请求接收者即可，对于这样将请求封装成对象的我们称之为命令模式。', '枝叶', '', '1-16-74-84', '不知道，只知道');
INSERT INTO `t_xxx_study_books` VALUES ('86', '23种设计模式', '3-2 命令模式(Command)', '命令模式的好处？好处1', ' 1.命令模式可以将请求的发送者和接收者之间实现完全的解耦，发送者和接收者之间没有直接的联系，发送者只需要知道如何发送请求命令即可，其余的可以一概不管，甚至命令是否成功都无需关心。', '枝叶', '', '1-16-74-84', '解耦');
INSERT INTO `t_xxx_study_books` VALUES ('87', '23种设计模式', '3-2 命令模式(Command)', '命令模式的好处？好处2', '2.同时我们可以非常方便的增加新的命令', '枝叶', '', '1-16-74-84', '新增方便');
INSERT INTO `t_xxx_study_books` VALUES ('88', '23种设计模式', '3-2 命令模式(Command)', '命令模式的缺点', '但是可能就是因为方便和对请求的封装就会导致系统中会存在过多的具体命令类。', '枝叶', '', '1-16-74-84', '过多');
INSERT INTO `t_xxx_study_books` VALUES ('89', '23种设计模式', '3-2 命令模式(Command)', 'UML图、参与者：5个', 'Command: 抽象命令类。 ConcreteCommand: 具体命令类。 Invoker: 调用者。 Receiver: 接收者。 Client:客户类。', '枝叶', '', '1-16-74-84', '没有理解整个结构图');
INSERT INTO `t_xxx_study_books` VALUES ('90', '23种设计模式', '3-2 命令模式(Command)', '具体命令类', 'ConcreteCommand: 具体命令类：将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现Excute。', '枝叶', '', '1-16-74-84', '');
INSERT INTO `t_xxx_study_books` VALUES ('91', '23种设计模式', '3-3 解释器模式', 'Interpreter', '所谓解释器模式就是定义语言的文法，并且建立一个解释器来解释该语言中的句子。解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。', '枝叶', '', '1-16-74', '应用：编译器');
INSERT INTO `t_xxx_study_books` VALUES ('92', '23种设计模式', '3-3 解释器模式', '达到的目标', '它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。', '枝叶', '', '1-16-74-91', '用得很少吧');
INSERT INTO `t_xxx_study_books` VALUES ('93', '23种设计模式', '3-3 解释器模式', 'UML图、参与者', '抽象表达式。终结符表达式。非终结符表达式。环境类。客户类。', '枝叶', '', '1-16-74-91', '');
INSERT INTO `t_xxx_study_books` VALUES ('94', '23种设计模式', '3-4 迭代器模式(Iterator)', '何为迭代器模式？', '所谓迭代器模式就是提供一种方法顺序访问一个聚合对象中的各个元素，而不是暴露其内部的表示。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('95', '23种设计模式', '3-4 迭代器模式(Iterator)', '工作方式：是怎么工作的？', '迭代器模式是将迭代元素的责任交给迭代器，而不是聚合对象，我们甚至在不需要知道该聚合对象的内部结构就可以实现该聚合对象的迭代。', '枝叶', '', '1-16-74-94', '');
INSERT INTO `t_xxx_study_books` VALUES ('96', '23种设计模式', '3-4 迭代器模式(Iterator)', '好处', '通过迭代器模式，使得聚合对象的结构更加简单，它不需要关注它元素的遍历，只需要专注它应该专注的事情，这样就更加符合单一职责原则了。', '枝叶', '', '1-16-74-94', '简单、专注');
INSERT INTO `t_xxx_study_books` VALUES ('97', '23种设计模式', '3-4 迭代器模式(Iterator)', 'UML图、参与者：4个', '抽象迭代器、具体迭代器、抽象聚合类、具体聚合类。', '枝叶', '', '1-16-74-94', '');
INSERT INTO `t_xxx_study_books` VALUES ('98', '23种设计模式', '3-5 中介者模式(Mediator)', '诞生的原因？', '在我们的系统中有时候会存在着对象与对象之间存在着很强、复杂的关联关系，如果让他们之间有直接的联系的话，必定会导致整个系统变得非常复杂，而且可扩展性很差！', '枝叶', '', '1-16-74', '复杂，可扩展性差');
INSERT INTO `t_xxx_study_books` VALUES ('99', '23种设计模式', '3-5 中介者模式(Mediator)', '解决方案', '在前面我们就知道如果两个类之间没有不必彼此通信，我们就不应该让他们有直接的关联关系，如果实在是需要通信的话，我们可以通过第三者来转发他们的请求。同样，这里我们利用中介者来解决这个问题。', '枝叶', '', '1-16-74-98', '引入第三方解耦');
INSERT INTO `t_xxx_study_books` VALUES ('100', '23种设计模式', '3-5 中介者模式(Mediator)', '什么是中介者模式？', '所谓中介者模式就是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。', '枝叶', '', '1-16-74-98', '');
INSERT INTO `t_xxx_study_books` VALUES ('101', '23种设计模式', '3-5 中介者模式(Mediator)', '工作原理', '在中介者模式中，中介对象用来封装对象之间的关系，各个对象可以不需要知道具体的信息通过中介者对象就可以实现相互通信。', '枝叶', '', '1-16-74-98', '');
INSERT INTO `t_xxx_study_books` VALUES ('102', '23种设计模式', '3-5 中介者模式(Mediator)', '好处：可复用性、简化结构', '它减少了对象之间的互相关系，提供了系统可复用性，简化了系统的结构。', '枝叶', '', '1-16-74-98', '');
INSERT INTO `t_xxx_study_books` VALUES ('103', '23种设计模式', '3-5 中介者模式(Mediator)', '缺点：中介者过于庞大', '在中介者模式中，各个对象不需要互相知道了解，他们只需要知道中介者对象即可，但是中介者对象就必须要知道所有的对象和他们之间的关联关系，正是因为这样就导致了中介者对象的结构过于复杂，承担了过多的职责，同时它也是整个系统的核心所在，它有问题将会导致整个系统的问题。', '枝叶', '', '1-16-74-98', '');
INSERT INTO `t_xxx_study_books` VALUES ('104', '23种设计模式', '3-5 中介者模式(Mediator)', '使用建议：充分考虑', '所以如果在系统的设计过程中如果出现“多对多”的复杂关系群时，千万别急着使用中介者模式，而是要仔细思考是不是您设计的系统存在问题。', '枝叶', '', '1-16-74-98', '');
INSERT INTO `t_xxx_study_books` VALUES ('105', '23种设计模式', '3-5 中介者模式(Mediator)', 'UML图、参与者：4个', '抽象中介者、具体中介者、抽象同事类、具体同事类', '枝叶', '', '1-16-74-98', '');
INSERT INTO `t_xxx_study_books` VALUES ('106', '23种设计模式', '3-6 备忘录模式(Memento)', '什么是备忘录模式？', '所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('107', '23种设计模式', '3-6 备忘录模式(Memento)', '好处', '它实现了对信息的封装，使得客户不需要关心状态保存的细节。', '枝叶', '', '1-16-74-106', '封装的好处');
INSERT INTO `t_xxx_study_books` VALUES ('108', '23种设计模式', '3-6 备忘录模式(Memento)', '缺点', '保存就要消耗资源，所以备忘录模式的缺点就在于消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。', '枝叶', '', '1-16-74-106', '');
INSERT INTO `t_xxx_study_books` VALUES ('109', '23种设计模式', '3-6 备忘录模式(Memento)', 'UML图、参与者：3个', 'Originator: 原发器、Memento: 备忘录、Caretaker: 负责人', '枝叶', '', '1-16-74-106', '');
INSERT INTO `t_xxx_study_books` VALUES ('110', '23种设计模式', '3-6 备忘录模式(Memento)', 'Originator: 原发器', '负责创建一个备忘录，用以记录当前对象的内部状态，通过也可以使用它来利用备忘录恢复内部状态。同时原发器还可以根据需要决定Memento存储Originator的那些内部状态。', '枝叶', '', '1-16-74-106', '能创建、恢复备忘录');
INSERT INTO `t_xxx_study_books` VALUES ('111', '23种设计模式', '3-7 观察者模式(Observer)', '何谓观察者模式？', '观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('112', '23种设计模式', '3-7 观察者模式(Observer)', '工作原理？', '在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以可以根据需要增加和删除观察者，使得系统更易于扩展。', '枝叶', '', '1-16-74-111', '');
INSERT INTO `t_xxx_study_books` VALUES ('113', '23种设计模式', '3-7 观察者模式(Observer)', '好处', '观察者提供了一种对象设计，让主题和观察者之间以松耦合的方式结合。根据需要增加和删除观察者，使得系统更易于扩展。', '枝叶', '', '1-16-74-111', '');
INSERT INTO `t_xxx_study_books` VALUES ('114', '23种设计模式', '3-7 观察者模式(Observer)', 'UML图、参与者：4个', '目标。观察者。具体主题。具体观察者。', '枝叶', '', '1-16-74-111', '');
INSERT INTO `t_xxx_study_books` VALUES ('115', '23种设计模式', '3-7 观察者模式(Observer)', '具体观察者', 'ConcreteObserver：具体观察者。实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态相协调。', '枝叶', '', '1-16-74-111', '');
INSERT INTO `t_xxx_study_books` VALUES ('116', '23种设计模式', '3-8 状态模式(State)', '什么是状态模式？', '状态模式就是允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('117', '23种设计模式', '3-8 状态模式(State)', '诞生原因？', '对象的行为依赖于它的一个或者多个变化的属性，这些可变的属性我们称之为状态，也就是说行为依赖状态，对于这种情况，我们是不能用行为来控制状态的变化，而应该站在状态的角度来思考行为，即是什么状态就要做出什么样的行为。这个就是状态模式。', '枝叶', '', '1-16-74-116', '');
INSERT INTO `t_xxx_study_books` VALUES ('118', '23种设计模式', '3-8 状态模式(State)', '带来的好处、缺点', '1.在状态模式中我们可以减少大块的if…else语句，它是允许态转换逻辑与状态对象合成一体，2.但是减少if…else语句的代价就是会换来大量的类，所以状态模式势必会增加系统中类或者对象的个数。', '枝叶', '', '1-16-74-116', '减少if-else语句');
INSERT INTO `t_xxx_study_books` VALUES ('119', '23种设计模式', '3-8 状态模式(State)', '模式好处2', '状态模式是将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。同时', '枝叶', '', '1-16-74-116', '');
INSERT INTO `t_xxx_study_books` VALUES ('120', '23种设计模式', '3-8 状态模式(State)', '模式缺点2或注意点', '但是这样就会导致系统的结构和实现都会比较复杂，如果使用不当就会导致程序的结构和代码混乱，不利于维护。', '枝叶', '', '1-16-74-116', '');
INSERT INTO `t_xxx_study_books` VALUES ('121', '23种设计模式', '3-8 状态模式(State)', 'UML图、参与者：3个', 'Context：环境类。 State：抽象状态类。ConcreteState：具体状态类。', '枝叶', '', '1-16-74-116', '');
INSERT INTO `t_xxx_study_books` VALUES ('122', '23种设计模式', '3-8 状态模式(State)', ' ConcreteState：具体状态类', '于处理来自Context的请求，每一个ConcreteState都提供了它对自己请求的实现，所以，当Context改变状态时行为也会跟着改变。', '枝叶', '', '1-16-74-116', '');
INSERT INTO `t_xxx_study_books` VALUES ('123', '23种设计模式', '3-9 策略模式(Strategy)', '什么是策略模式？', '策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式让该算法的变化独立于使用算法的客户。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('124', '23种设计模式', '3-9 策略模式(Strategy)', '工作原理', '策略模式中它将这些解决问题的方法定义成一个算法群，每一个方法都对应着一个具体的算法，这里的一个算法我就称之为一个策略。虽然策略模式定义了算法，但是它并不提供算法的选择。', '枝叶', '', '1-16-74-123', '');
INSERT INTO `t_xxx_study_books` VALUES ('125', '23种设计模式', '3-9 策略模式(Strategy)', '客户承担的责任', '客户必须要清楚的知道每个算法之间的区别和在什么时候什么地方使用什么策略是最合适的，这样就增加客户端的负担。', '枝叶', '', '1-16-74-123', '');
INSERT INTO `t_xxx_study_books` VALUES ('126', '23种设计模式', '3-9 策略模式(Strategy)', '优缺点', '同时策略模式也非常完美的符合了“开闭原则”，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。但是一个策略对应一个类将会是系统产生很多的策略类。', '枝叶', '', '1-16-74-123', '灵活；新增类很多');
INSERT INTO `t_xxx_study_books` VALUES ('127', '23种设计模式', '3-9 策略模式(Strategy)', 'UML图、参与者：3个', 'Context: 环境类。Strategy: 抽象策略类。ConcreteStrategy: 具体策略类。', '枝叶', '', '1-16-74-123', '');
INSERT INTO `t_xxx_study_books` VALUES ('128', '23种设计模式', '3-9 策略模式(Strategy)', 'Context: 环境类', '维护一个Strategy对象的引用，用一个ConcreteStrategy来配置，可定义一个接口来让Strategy访问它的数据。', '枝叶', '', '1-16-74-123', '');
INSERT INTO `t_xxx_study_books` VALUES ('129', '23种设计模式', '3-10 模板方法模式', 'Template Method', '所谓模板方法模式就是在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('130', '23种设计模式', '3-10 模板方法模式', '工作原理', ' 模板方法模式就是基于继承的代码复用技术的。在模板方法模式中，我们可以将相同部分的代码放在父类中，而将不同的代码放入不同的子类中', '枝叶', '', '1-16-74-129', '');
INSERT INTO `t_xxx_study_books` VALUES ('131', '23种设计模式', '3-10 模板方法模式', '具体做法', '我们需要声明一个抽象的父类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法让子类来实现剩余的逻辑，不同的子类可以以不同的方式来实现这些逻辑。', '枝叶', '', '1-16-74-129', '');
INSERT INTO `t_xxx_study_books` VALUES ('132', '23种设计模式', '3-10 模板方法模式', '总结', '模板方法的模板其实就是一个普通的方法，只不过这个方法是将算法实现的步骤封装起来的。', '枝叶', '', '1-16-74-129', '');
INSERT INTO `t_xxx_study_books` VALUES ('133', '23种设计模式', '3-10 模板方法模式', 'UML图、参与者：2个', 'AbstractClass: 抽象类。ConcreteClass: 具体子类。', '枝叶', '', '1-16-74-129', '');
INSERT INTO `t_xxx_study_books` VALUES ('134', '23种设计模式', '3-11 访问者模式(Visitor)', '什么是访问者模式？', '访问者模式即表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。', '枝叶', '', '1-16-74', '');
INSERT INTO `t_xxx_study_books` VALUES ('135', '23种设计模式', '3-11 访问者模式(Visitor)', '最难的一个？', '访问者模式俗称23大设计模式中最难的一个。除了结构复杂外，理解也比较难。', '枝叶', '', '1-16-74-134', '');
INSERT INTO `t_xxx_study_books` VALUES ('136', '23种设计模式', '3-11 访问者模式(Visitor)', '原理1', '访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式。', '枝叶', '', '1-16-74-134', '');
INSERT INTO `t_xxx_study_books` VALUES ('137', '23种设计模式', '3-11 访问者模式(Visitor)', '原理2', '同时我们还需要明确一点那就是访问者模式是适用于那些数据结构比较稳定的，因为他是将数据的操作与数据结构进行分离了，如果某个系统的数据结构相对稳定，但是操作算法易于变化的话，就比较适用适用访问者模式，因为访问者模式使得算法操作的增加变得比较简单了。', '枝叶', '', '1-16-74-134', '');
INSERT INTO `t_xxx_study_books` VALUES ('138', '23种设计模式', '3-11 访问者模式(Visitor)', 'UML图、参与者：5个', '抽象访问者具体访问者抽象元素具体元素对象结构', '枝叶', '', '1-16-74-134', '');
INSERT INTO `t_xxx_study_books` VALUES ('139', '23种设计模式', '4.单个设计模式详解', '请查看24个链接', '', '分部', '', '1-16', '');
INSERT INTO `t_xxx_study_books` VALUES ('140', '23种设计模式', '5.资料来源、感谢', '书、PPT', '《Head First design patterns》、刘伟老师的PPT。java基础了：think in java', '枝叶', '', '1-16', '');
INSERT INTO `t_xxx_study_books` VALUES ('141', '设计模式总结', '评论1', '画图工具', '思维导图，下面的图都是Visio画', '枝叶', '', '1', '');
INSERT INTO `t_xxx_study_books` VALUES ('142', '设计模式总结', '评论2', '过度使用', '设计模式看多了容易走火入魔，本末倒置---要找到一个平衡点，是需要经验的，不能过度设计。', '枝叶', '', '1', '');
INSERT INTO `t_xxx_study_books` VALUES ('143', '设计模式总结', '评论3', '学习难度、总结精神', '设计模式本身不难，难的是如何灵活的将现实场景用合适的模式加以抽象，这里更多涉及对业务的深度理解能力。楼主的精神还是很值得点赞的', '枝叶', '', '1', '');
INSERT INTO `t_xxx_study_books` VALUES ('144', '设计模式总结', '评论4', 'DRY原则的运用', '一言以蔽之，这么多设计模式就是为了更好的组织代码。尽可能的像 DRY 靠拢。当你到达一定的程度，你可以忘记所有这些模式的名字。', '枝叶', '', '1', '');
INSERT INTO `t_xxx_study_books` VALUES ('145', '设计模式总结', '结束', '', '', '枝叶', '', '1', '');
INSERT INTO `t_xxx_study_books` VALUES ('146', '大话设计模式', '0.开头、导言、开篇语', '1.封面语-设计演变', '感受设计演变过程中所蕴含的大智慧，体会乐与怒的程序人生中值得回味的一幕幕。', '枝叶', '', '1', '大智慧、回味');
INSERT INTO `t_xxx_study_books` VALUES ('147', '大话设计模式', '0.开头、导言、开篇语', '2.封面语-诙谐、趣味', '设计模式的趣味解读，面向对象的深入剖析。在诙谐与温馨中做一次面向对象编程思维的体操。', '枝叶', '', '146', '解读、剖析；思维体操');
INSERT INTO `t_xxx_study_books` VALUES ('148', '大话设计模式', '0.开头、导言、开篇语', '3.序言-书的起源', '作者程杰连载博客（博客园）---小菜编程成长记。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('149', '大话设计模式', '0.开头、导言、开篇语', '4.序言-UML图', '简介地表达设计模式的结构。其他的还有中文编码改英文、新增UML类图。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('150', '大话设计模式', '0.开头、导言、开篇语', '5.序言-温馨故事', '好学、天真、而又执着的小菜，善于启发、经验老道的大鸟。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('151', '大话设计模式', '0.开头、导言、开篇语', '6.序言-作者', '编辑陈冰，2007年10月18日', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('152', '大话设计模式', '0.开头、导言、开篇语', '7.网友评论1-好书的标准', '好书的意义在于让人学到知识，而不在于用什么方式。只要让人比较容易地学到书里的知识就是一本好书。--->枯燥、不好理解、教条（重理论或专业）。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('153', '大话设计模式', '0.开头、导言、开篇语', '8.网友评论2-好程序的标准', '程序四性：灵活性、可扩展、复用性、可维护性。没有安全性、健壮性、性能、可读性等。这四性是面向对象的特性吧，其他语言在这方面不占优。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('154', '大话设计模式', '0.开头、导言、开篇语', '9.网友评论3-本书风格', '寓教于乐、步步深入。阳春白雪VS下里巴人？简单明了，也不乏趣味。幽默风趣又不失睿智深刻。《深入浅出设计模式》是Head First系列么？', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('155', '大话设计模式', '0.开头、导言、开篇语', '10.前言-本书读者', '程序集、故事集？No，通过故事讲解程序如何设计的方法集。新手、高手？No，面向对象编程的实践者，带你进入OO世界的大门。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('156', '大话设计模式', '0.开头、导言、开篇语', '11.前言-本书起因1-培训经历', '学生知道类、接口、方法、构造方法、抽象类等概念，却不知道为什么要用面向对象，面向对象的好处在哪里？概念知道，表达不清楚么？', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('157', '大话设计模式', '0.开头、导言、开篇语', '12.前言-小说与技术书的区别', '小说之所以坚持读完是因为对它感兴趣，作者的文字吸引你。而技术书的枯燥乏味使得阅读产生了困难，通常读个几个章节就留待以后再说了。我产生了思考：技术书或学一门技术是否需要趣味性，通俗性的引导？', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('158', '大话设计模式', '0.开头、导言、开篇语', '13.前言-好书比喻', 'GoF设计模式-集锦，重构、敏捷软件开发、设计模式解析：足球比赛。参与足球，而不只是欣赏比赛---精彩的代码是如何想出来的，要比看到精彩的代码更令人期待。', '枝叶', '', '146-147', '重在参与的另类解释');
INSERT INTO `t_xxx_study_books` VALUES ('159', '大话设计模式', '0.开头、导言、开篇语', '14.前言-本书定位', '引路人、提携者。非站在巨人身上创造了什么。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('160', '大话设计模式', '0.开头、导言、开篇语', '15.前言-本书特色1-重视过程', '大多数书籍重视解决方案或程序样例。对演变过程却重视不够。<重构与模式>：了解优秀软件的演变过程比学习优秀软件设计本身更有价值，因为设计的演变过程中蕴藏着大智慧。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('161', '大话设计模式', '0.开头、导言、开篇语', '16.前言-本书特色2-贴近生活', '将生活原貌的场景引入书中，用一个个小故事引入模式，会让读者相对轻松地进入学习设计模式的状态。', '枝叶', '', '146-147', '学习的人很熟悉，就不会感到吃力');
INSERT INTO `t_xxx_study_books` VALUES ('162', '大话设计模式', '0.开头、导言、开篇语', '17.前言-本书内容-四个部分', '1.第一部分：面向对象的意义和好处及几个重要的设计原则；2.第二部分：23个设计模式；3.第三部分：总结；4.附录：面向对象概念。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('163', '大话设计模式', '0.开头、导言、开篇语', '18.前言-本书人物及背景', '小菜-22岁，大鸟-29岁。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('164', '大话设计模式', '0.开头、导言、开篇语', '19.前言-本书研读方法', '附录？例子代码-手动输入在查看源码。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('165', '大话设计模式', '0.开头、导言、开篇语', '20.前言-学习的疑问解答', '通过这些模式的学习，要掌握到\"封装变化\"、“对象间松散耦合”、“面向接口编程”的感觉，从而设计出可扩展、可维护、可复用、灵活性好的程序。', '枝叶', '', '146-147', '封装变化、松耦合、面向接口---四个特性');
INSERT INTO `t_xxx_study_books` VALUES ('166', '大话设计模式', '0.开头、导言、开篇语', '21.前言-设计模式的四个境界', '1.不懂。2.套用。3.犹豫。4.灵活。只有通过不断的努力和钻研，你才能突破“不识庐山真面目，只缘生在此山中”的瓶颈。达到“会当绝凌顶，一览众山小”的境界', '枝叶', '', '146-147', '突破...瓶颈，达到...境界');
INSERT INTO `t_xxx_study_books` VALUES ('167', '大话设计模式', '0.开头、导言、开篇语', '22.前言-编程语言差异', '本书是用C#，而与Java差距较小。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('168', '大话设计模式', '0.开头、导言、开篇语', '23.前言-博客地址', 'http://cj723.cnblogs.com，小菜编程成长记。', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('169', '大话设计模式', '0.开头、导言、开篇语', '24.前言-引用著作', '......，《设计模式解析》、《敏捷软件开发：原则、模式、实践》、《Java与模式》严宏', '枝叶', '', '146-147', '《重构与模式》一书很重要');
INSERT INTO `t_xxx_study_books` VALUES ('170', '大话设计模式', '0.开头、导言、开篇语', '25.前言-作者', '程杰，2007年7月', '枝叶', '', '146-147', '');
INSERT INTO `t_xxx_study_books` VALUES ('171', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '0.总体介绍', '面向对象基础知识的简单介绍，比如接口、类、多态、集合等。技术细节未提及或深入。', '枝叶', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('172', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '1.什么是对象？', '对象是一个自包含的实体，用一组可识别的特性和行为来标识。一切事物皆为对象。', '枝叶', '', '146-171', '属性、行为。万物皆对象。');
INSERT INTO `t_xxx_study_books` VALUES ('173', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '2.什么是类？', '类就是具有相同属性和功能的对象的抽象的集合。', '枝叶', '', '146-171', '抽象的集合');
INSERT INTO `t_xxx_study_books` VALUES ('174', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '3.类的实例和实例化？', '实例，就是一个真实的对象。而实例化，就是创建对象的过程，使用new关键字来创建。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('175', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '4.什么是构造方法？', '构造方法：又叫构造函数，其作用就是对类的对象进行初始化。构造方法与类同名，无返回值，也不需要void，在new的时候调用。', '枝叶', '', '146-171', '初始化，在new时调用。');
INSERT INTO `t_xxx_study_books` VALUES ('176', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '5.方法重载', '就是提供相同的方法名的多个方法的能力，但这些方法需要提供不同的参数类型。普通方法、构造方法都可以重载。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('177', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '6.方法重载的好处是什么？', '方法重载可以在不改变原方法的基础上，增加新的功能。即可扩展性。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('178', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '7.什么是字段？', '字段是存储类要满足其设计所需要的数据，字段是与类相关的变量。', '枝叶', '', '146-171', '存储数据、变量。');
INSERT INTO `t_xxx_study_books` VALUES ('179', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '8.什么是封装？', '每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装。因此，对象不必依赖其他对象来完成自己的操作。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('180', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '9.封装有什么好处？三点', '1.良好的封装能减少耦合。2.类内部的实现可以自由地修改。3.类具有清晰的对外接口。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('181', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '10.理解继承1', '对象的继承代表了一种“is-a”的关系。如果两个对象A和B，可以描述为B是A，则表明B可以继承A。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('182', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '11.理解继承2', '继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备自己独有的个性。', '枝叶', '', '146-171', '共性、个性');
INSERT INTO `t_xxx_study_books` VALUES ('183', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '12.理解继承3', '继承定义了类如何相互关联，共享特性。子类不但继承了父类的所有特性(不对外提供服务的属性和方法不算)，还可以定义新的特性。', '枝叶', '', '146-171', '继承也是两个类之间的一种关系类型。');
INSERT INTO `t_xxx_study_books` VALUES ('184', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '13.理解继承4-记住三句话', '1.子类拥有父类非private的属性和功能。2.子类具有自己的属性和功能。扩展性。3.子类还可以自己的方式实现父类的功能。方法重写。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('185', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '14.理解继承5-构造方法', '构造方法不能被继承，只能被调用。java中super，C#中base。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('186', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '15.继承的优点：两点', '继承使得所有子类的公共部分都放在父类，使得代码得到了共享，这就避免了重复。2.继承还可以使得修改或扩展继承而来的实现变得较为容易。', '枝叶', '', '146-171', '重用的两种方式：继承和组合');
INSERT INTO `t_xxx_study_books` VALUES ('187', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '16.继承的缺点：两点', '1.父类变，子类也跟着变(不得不变)。2.继承破坏了封装，父类的实现细节暴露给了子类。即子类与父类的耦合性太强了。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('188', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '17.使用继承的注意点', '尽量少用继承。继承是一种类与类之间强耦合的关系。继承一般用在重构上或在设计前就能明确的“is-a”关系之间的类。', '枝叶', '', '146-171', '抽象的话就必须用到继承(类、接口)');
INSERT INTO `t_xxx_study_books` VALUES ('189', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '18.什么是多态？', '多态表示不同的对象可以执行相同的动作，但要通过它们自己实现的代码来执行。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('190', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '19.多态的注意点：三点', '1.子类以父类的身份出现。2.子类在工作时以自己的方式来实现。3.子类特有的属性和方法不可使用。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('191', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '20.多态的原理-动态绑定', '当方法调用时，无论对象是否转换成其父类，都只有位于对象继承链最末端的方法实现被调用。即动态绑定。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('192', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '21.多态的运用', '要深刻理解和合理利用多态，不去研究设计模式是很难做到的。反过来说，没学过设计模式，那么对多态，乃至面向对象的理解多半都是片面的、肤浅的。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('193', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '22.对抽象类的理解：三点', '1.抽象类不能被实例化。2.抽象方法是必选被子类重写的方法。3.如果类中包含有抽象方法，那么类一定是抽象类。而抽象类可以没有抽象方法。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('194', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '23.抽象类的设计原则', '让抽象类拥有尽量多的共同代码，拥有尽可能少的数据。抽象类是被设计来用于继承的。', '枝叶', '', '146-171', '目的：继承');
INSERT INTO `t_xxx_study_books` VALUES ('195', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '24.我们应该什么时候用抽象类呢？', '抽象类通常代表一个抽象的概念，它提供了一个继承的出发点。所以，在一个继承关系的等级结构里面，叶子节点应该是具体类，而树枝节点应当是抽象类。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('196', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '25.什么是接口？', '接口是把隐式公共方法和属性组合起来，以封装特定功能的一个集合。一旦类实现了接口，类就可以支持接口所指定的所有属性和成员。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('197', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '26.接口与抽象类的异同', '声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行实现。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('198', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '27.实现类与接口的关系', '一个类可以支持多个接口，多个类也可以支持相同的接口。实现接口的类就必须要实现接口中的所有方法和属性，除非是抽象类。', '枝叶', '', '146-171', '抽象类最好不要实现接口，C#就是如此。');
INSERT INTO `t_xxx_study_books` VALUES ('199', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '28.形态上区分接口和抽象类1', '抽象类可以给出一些方法的实现，接口却不包含成员的实现。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('200', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '29.形态上区分接口和抽象类2', '抽象类的抽象方法可被子类部分实现，接口的成员需要实现类完全实现。C#', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('201', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '30.形态上区分接口和抽象类3', '一个类只能继承一个抽象类，但可实现多个接口。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('202', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '31.本质上区分1-抽象', '1.类是对象的抽象，抽象类是对类的抽象，接口时对行为的抽象。它们都是在不同层次、不同角度进行抽象的结果。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('203', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '32.本质上区分2-类型', '2.如果行为跨越不同类的对象，可使用接口；对于一些相似的类对象，用继承抽象类。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('204', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '33.本质上区分3-设计', '3.从设计的角度讲，抽象类是从子类中发现了公共的东西，泛华出父类，然后子类继承父类，而接口是根本不知子类的存在，方法如何实现还不确认，预先定义。', '枝叶', '', '146-171', '不知道实现类是什么样的');
INSERT INTO `t_xxx_study_books` VALUES ('205', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '34.继承与重构', '通过重构改善既有代码的设计时，为了减少重复代码，可使用继承。抽象类是自底向上抽象出来的，而接口则是自顶向下设计出来的。', '枝叶', '', '146-171', '设计方向上的不同');
INSERT INTO `t_xxx_study_books` VALUES ('206', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '35.抽象类与设计模式', '要想真正把抽象类和接口用好，还是需要好好用心地去学习设计模式。只有真正把设计模式理解好了，那么你才能算是真正合理应用抽象类和接口了。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('207', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '36.数组的优点：两点', '1.数组在内存中是连续存储的，因此可以快速而容易地从头到尾遍历元素，可以快速修改元素等。2.类型一致', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('208', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '37.数组的缺点：两点', '1.创建时必须指定数组变量的大小。2.在两个元素之间添加元素也比较困难。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('209', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '38.集合的优点：两点', '1.容量可动态增加。2.增删元素比较方便', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('210', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '39.集合的缺点：两点', '1.里面的类型都是Object类型的。2.装箱和拆箱需要进行大量计算，需要消耗性能。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('211', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '40.泛型的应用-集合', '泛型集合可以获得类型安全的直接优点，不必对元素进行装箱、拆箱。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('212', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '41.委托与事件', 'C#中的内容。Java中用方法里包含对象来解决，在方法体里调用参数的方法。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('213', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '42.附录B-参考文献', '都是经常听说过名字的书籍，以后有机会要看看。还有一些其他网站和博客。特别是《重构与模式》：是继《设计模式》、《重构》后的第三本学习重构的经典书籍。', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('214', '大话设计模式', '-1.附录A：培训实习生-面向对象基础', '43.附录结束', '', '枝叶', '', '146-171', '');
INSERT INTO `t_xxx_study_books` VALUES ('215', '大话设计模式', '1.第一章简单工厂模式', '代码无错就是优么？', '面试受挫、初学者代码毛病', '枝叶', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('216', '大话设计模式', '1.第一章简单工厂模式', '1.代码规范', '命名无意义、分支-只有if、没有处理异常', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('217', '大话设计模式', '1.第一章简单工厂模式', '2.面向对象编程', '初学者碰到问题就直觉地用计算机能够理解的逻辑来描述和表达待解决问题及具体的求解过程。这其实是用计算机的方式去思考，这样的思维却使得我们的程序只为满足实现当前的需求，程序不容易维护，不容易扩展，更不容易复用。从而达不到高质量代码的要求。', '枝叶', '使用问句也很好', '146-215', '长句子不容易记住，应该使用短句、简洁表述');
INSERT INTO `t_xxx_study_books` VALUES ('218', '大话设计模式', '1.第一章简单工厂模式', '3.活字印刷，面向对象', '1.可维护性-要改，很容易改，只改部分，不用全改；2.可复用-代码可重复使用，为以后做准备；3.可扩展-要加功能，很容易加进来，对原来没多大影响；4.灵活性-横排、竖排都能满足排练需求。支持需求的变化', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('219', '大话设计模式', '1.第一章简单工厂模式', '4.活字印刷，四大发明之一', '从刻板印刷到活字印刷是一次技术上的进步。以前，上述四种特性都不满足：要修改，必须重刻，要加字，必须重刻，要重新排列，必须重刻；印完这版，此版再无利用价值。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('220', '大话设计模式', '1.第一章简单工厂模式', '4.不是从无到有', '火药、指南针、造纸术都是从无到有，从未知到发现的伟大方面。而活字印刷被评为四大发明之一，是因为解决了上面的四个特性问题。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('221', '大话设计模式', '1.第一章简单工厂模式', '5.面向对象的好处', '面对需求变化，可以通过封装、继承、多态把程序的耦合度降低，用设计模式使得程序更加灵活、容易修改，并且易于复用。那么需求变更也就不会变成一次灾难了。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('222', '大话设计模式', '1.第一章简单工厂模式', '6.初级程序员的工作', '就是Ctrl+C和Ctrl+V，这其实是非常不好的编码习惯，因为当你的代码中重复的代码多到一定程度，维护的时候，可能就是一场灾难。越大的系统，这种方式带来的问题越严重。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('223', '大话设计模式', '1.第一章简单工厂模式', '7.编程的一个原则', '就是用尽可能的办法去避免重复。即DRY，不要重复你自己。计算机例子：分离控制台和计算相关的代码。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('224', '大话设计模式', '1.第一章简单工厂模式', '8.业务的封装', '计算器例子改造：就是让业务逻辑与界面逻辑分开，让它们之间的耦合度下降。只有分离开，才可达到容易维护或扩展。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('225', '大话设计模式', '1.第一章简单工厂模式', '9.封装的好处', '计算器例子：业务逻辑不仅仅可以用于控制台的计算，还可以用于PDA、Web的计算器例子，达到了重用的目的。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('226', '大话设计模式', '1.第一章简单工厂模式', '10.继承的使用', '计算器例子：将算法抽象成一个父类，加减乘除定义成子类。这样就一个算法类就变成5个类了。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('227', '大话设计模式', '1.第一章简单工厂模式', '11.继承带来的好处', '计算器例子：新增一个开根号的算法，不必知道加减乘除原来是怎么实现的，只需要告诉你父类，你去继承并实现即可。避免了人工修改原来的业务逻辑。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('228', '大话设计模式', '1.第一章简单工厂模式', '12.紧耦合VS松耦合', '计算器例子：在修改前后进行对比发现，以前的代码要修改，就要知道原来的逻辑，而现在只需要知道父类即可，达到了封装，隐藏实现细节的目的。而具体执行谁，通过继承和多态来实现的。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('229', '大话设计模式', '1.第一章简单工厂模式', '13.简单工厂模式', '计算器例子：到底要实例化谁，将来会不会增加实例化的对象，比如增加开根运算，这时很容易变化的地方，应该考虑用一个单独的类来做这个创建实例的过程，这就是工厂。将对象的创建和使用分离。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('230', '大话设计模式', '1.第一章简单工厂模式', '14.UML类图-接口、抽象类', '接口与抽象类斜体，接口分2部分，最上边有《interface》字样，抽象分三部分。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('231', '大话设计模式', '1.第一章简单工厂模式', '15.UML类图-接口棒棒糖表示法', '圆圈旁为接口名称，接口方法在实现类中实现。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('232', '大话设计模式', '1.第一章简单工厂模式', '16.UML类图-继承、实现', '继承是三角形指向父类，实心直线。而接口时虚线。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('233', '大话设计模式', '1.第一章简单工厂模式', '17.UML类图-关系1-依赖', '最弱的关系，如动物生存需要依赖空气和水。动物与空气、水之间的关系比较弱，只是一个方法的参数。虚线，>指向依赖对象。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('234', '大话设计模式', '1.第一章简单工厂模式', '18.UML类图-关系2-关联', '一个类知道另一个类，如企鹅需要根据气候进行迁徙。企鹅与气候的关系，气候可以是一个参数或熟悉。实心直线。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('235', '大话设计模式', '1.第一章简单工厂模式', '19.UML类图-关系3-聚合关系', '比较弱的包含关系，即个体可以脱离单独存在。如雁群与雁的关系，雁群是有雁组成的，但雁可以脱队独立存在。用空心菱形加箭头组成，>指向聚合对象。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('236', '大话设计模式', '1.第一章简单工厂模式', '20.UML类图-关系4-组合/合成', '比较强的包含关系，比如鸟与翅膀。翅膀是构成鸟的一部分，不能脱离鸟而独立存在。实心菱形，还可以在菱形和箭头下面标上数字，表示它们之间的数量关系。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('237', '大话设计模式', '1.第一章简单工厂模式', '21..UML类图-关系总结', '组合、聚合都表示一种“拥有”关系。体现了部分与整体之间的关系，但强弱不同。组合的部分与整体的生命周期一样，不可分割。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('238', '大话设计模式', '1.第一章简单工厂模式', '22.编程的认识', '编程是一门技术，更是一门艺术。不能只满足于写完代码运行结果正确就完事，时常考虑如何让代码更加简练，更加容易维护，容易扩展和复用，只有这样才可以真正得到提高。', '枝叶', '', '146-215', '');
INSERT INTO `t_xxx_study_books` VALUES ('239', '大话设计模式', '2.第二章商场促销-策略模式', '1.商场收银软件', '商场收银不仅要考虑计算商品清单的总价，还要考虑打折、会员积分等事情。而打折又有很多不同的方案需要考虑，这样看起来就很复杂了，但如果用设计模式就能一步一步地化繁为简。', '枝叶', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('240', '大话设计模式', '2.第二章商场促销-策略模式', '2.商场收银系统1.0版', '只有计算商品清单总价的功能。没有考虑打折，计算错误增减总价的问题。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('241', '大话设计模式', '2.第二章商场促销-策略模式', '3.商场收银系统1.1版', '通过下拉选择打折信息，支持对商品进行打折，而不是总价打折。问题是里面的重复代码过多。需要重构。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('242', '大话设计模式', '2.第二章商场促销-策略模式', '4.重复代码的重构', '可以先写一个父类，在继承它实现多个打折和返利的子类，利用多态，完成这个功能。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('243', '大话设计模式', '2.第二章商场促销-策略模式', '5.类爆炸问题', '面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和行为的对象的抽象集合才是类。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('244', '大话设计模式', '2.第二章商场促销-策略模式', '6.类爆炸的具体问题', '打一折和打九折只是形式不同，抽象分析出来，所有的打折算法都是一样的，所以打折算法应该是一个类，而不是多个类。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('245', '大话设计模式', '2.第二章商场促销-策略模式', '7.简单工厂实现-1', '抽取一个父类CashSuper，里面有一个抽象方法，收取现金：参数为原价，返回为当前价。有说那个实现子类：正常收费子类、打折收费子类、返利收费子类', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('246', '大话设计模式', '2.第二章商场促销-策略模式', '8.简单工厂实现-2', '再创建一个现金收费的工厂类，里面有一个返回CashSuper的方法，实现为：根据传入的参数，决定创建那一个具体的子类。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('247', '大话设计模式', '2.第二章商场促销-策略模式', '9.简单工厂实现-3', '客户端程序，将下列列表的参数传给现金收费工厂里的方法，返回一个CashSuper，再调用里面的抽象方法，获取打折或返现后的价格。这样就达到了灵活处理的目的。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('248', '大话设计模式', '2.第二章商场促销-策略模式', '10.简单工厂的问题', '简单工厂模式虽然也能解决这个问题，但这个模式只是解决对象的创建问题，而且由于工厂本身包括了所有收费方式，商场是可能经常性地更改打折额度和返利额度，每次维护或扩展收费方式都要改动这个工厂，以致代码需要重新编译部署，这真的是很糟糕的处理方式，所以用它不是最好的办法。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('249', '大话设计模式', '2.第二章商场促销-策略模式', '11.策略模式的引入', '面对算法的时常变动，应该有更好的办法，这就是策略模式。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('250', '大话设计模式', '2.第二章商场促销-策略模式', '12.什么是策略模式？', '它定义了算法家族，分别封装起来，让它们之间可以相互替换。好处是：此模式让算法的变化，不会影响到使用算法的客户。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('251', '大话设计模式', '2.第二章商场促销-策略模式', '13.工厂模式VS策略模式-1', '商场收银时如何促销，用打折还是返利，其实都是一些算法，用工厂来生成算法对象，这没有错。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('252', '大话设计模式', '2.第二章商场促销-策略模式', '14.工厂模式VS策略模式-2', '但算法本身只是一种策略，最重要的是这些算法是随时都可能相互替换的，这就是变化点。而封装变化点时我们面向对象的一种很重要的思维方式。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('253', '大话设计模式', '2.第二章商场促销-策略模式', '15.策略模式的实现-1', 'CashSuper就是抽象策略，三个子类就是具体策略。这些都不用改，执行要将工厂类改成CashContext就行了。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('254', '大话设计模式', '2.第二章商场促销-策略模式', '16.策略模式的实现-2', '并且把具体创建那一个具体策略的判断放在CashContext中，这样客户端就只与CashContext交互了，就不知道CashSuper及其子类的存在而来。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('255', '大话设计模式', '2.第二章商场促销-策略模式', '17.策略模式比工厂模式的好处-1', '简单工厂需要让客户端认识两个类：CashSuper和CashFactory，而策略模式与简单工厂结合的用法，客户端就只需要认识一个类CashContext就可以了。耦合更加降低。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('256', '大话设计模式', '2.第二章商场促销-策略模式', '18.策略模式比工厂模式的好处-2', '具体的收费算法彻底与客户端分离，连算法的父类都不让客户端认识了。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('257', '大话设计模式', '2.第二章商场促销-策略模式', '19.反思策略模式', '策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。', '枝叶', '', '146-239', '因此在多个选择条件下，只能选其一');
INSERT INTO `t_xxx_study_books` VALUES ('258', '大话设计模式', '2.第二章商场促销-策略模式', '20.策略模式的优点1', '策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。', '枝叶', '', '146-239', '策略模式可解决多个if-else的情况');
INSERT INTO `t_xxx_study_books` VALUES ('259', '大话设计模式', '2.第二章商场促销-策略模式', '21.策略模式的优点2', '简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。原理：修改其中任意一个不会影响其他算法，这真的是非常好。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('260', '大话设计模式', '2.第二章商场促销-策略模式', '22.策略模式解决的问题', '当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。', '枝叶', '', '146-239', '封装判断变化，消除客户端条件语句。');
INSERT INTO `t_xxx_study_books` VALUES ('261', '大话设计模式', '2.第二章商场促销-策略模式', '23.策略模式适用场景', '策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑适用策略模式处理这种变化的可能性。', '枝叶', '', '146-239', '很重要。把策略模式什么时候用讲清楚了。');
INSERT INTO `t_xxx_study_books` VALUES ('262', '大话设计模式', '2.第二章商场促销-策略模式', '24.策略模式的缺点', '在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式Context对象。这本身并没有解除客户端选择判断的压力。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('263', '大话设计模式', '2.第二章商场促销-策略模式', '25.策略模式缺点解决方案', '策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化地减轻了客户端的职责。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('264', '大话设计模式', '2.第二章商场促销-策略模式', '25.Context内判断的消除', '任何需求的变更都是需要成本的。解决的办法就是用到了反射技术。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('265', '大话设计模式', '2.第二章商场促销-策略模式', '26.独立的策略模式', '因为大话设计模式用到了多模式，而不是纯净的模式，所有下面转到博客里的简单工厂、策略模式。', '枝叶', '', '146-239', '');
INSERT INTO `t_xxx_study_books` VALUES ('266', '设计模式读书笔记', '博客：简单工厂模式', '博客地址(网址)', 'http://www.cnblogs.com/chenssy/archive/2013/05/24/3096161.html', '总体', '/chenssy/archive/2013/05/24/3096161.html', '', 'cnblogs');
INSERT INTO `t_xxx_study_books` VALUES ('267', '设计模式读书笔记', '博客：简单工厂模式', '1.设计模式的违背', '常见的设计原则：我们应该针对接口编程，而不是针对实现编程。但我们一直用new关键字来创建一个对象，这不就是针对实现编程么？应该用反射', '枝叶', 'new、反射都是无中生有，而clone、序列化是一生二', '266', '除了new还有那些方式呢？还有五种');
INSERT INTO `t_xxx_study_books` VALUES ('268', '设计模式读书笔记', '博客：简单工厂模式', '2.针对接口编程的好处', '可以隔离掉以后系统可能发生的一大堆改变。代码是针对接口而写，那么可以通过多态，达到灵活扩展的目的。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('269', '设计模式读书笔记', '博客：简单工厂模式', '3.简单工厂模式解决的问题', '当代码使用一大堆的具体类时，等于自找麻烦。因为一旦加入新的具体类，就必须要改变代码。我们希望通过传递一个参数过去就给我返回相应的具体对象，这就是简单工厂模式。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('270', '设计模式读书笔记', '博客：简单工厂模式', '4.简单工厂模式的基本定义', '简单工厂模式又称为静态工厂方法，属于创建型模式。在简单工厂模式中，可以根据传递的参数不同，返回不同类的实例。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('271', '设计模式读书笔记', '博客：简单工厂模式', '5.基本特点', '简单工厂模式定义一个类（工厂类），这个类专门用于创建其他类的实例，这些被创建的类都有一个共同的父类。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('272', '设计模式读书笔记', '博客：简单工厂模式', '6.模式结构图（UML类图）', ' Factory：工厂角色。 Product：抽象产品角色。 ConcreteProduct：具体的产品角色。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('273', '设计模式读书笔记', '博客：简单工厂模式', '7.模式分析：工厂角色', '专门用于创建实例类的工厂，提供一个方法，该方法根据传递的参数不同返回不同类的具体实例。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('274', '设计模式读书笔记', '博客：简单工厂模式', '8.带来的好处', '将对象的创建和对象本身业务处理分离了，可以降低系统的耦合度，使得两者修改起来都相对容易些。当以后实现改变时，只需要修改工厂类即可。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('275', '设计模式读书笔记', '博客：简单工厂模式', '9.优点：3-1', '1.简单工厂模式实现了对责任的分割，提供了专门的工厂类用于创建对象。', '枝叶', '', '266', '创建和使用分离，降低耦合。');
INSERT INTO `t_xxx_study_books` VALUES ('276', '设计模式读书笔记', '博客：简单工厂模式', '10.优点：3-2', '2.客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。', '枝叶', '', '266', '通过参数来获得具体类。');
INSERT INTO `t_xxx_study_books` VALUES ('277', '设计模式读书笔记', '博客：简单工厂模式', '11.优点：3-3', '3.通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。', '枝叶', '', '266', '引入配置，减少修改。');
INSERT INTO `t_xxx_study_books` VALUES ('278', '设计模式读书笔记', '博客：简单工厂模式', '12.缺点：4-1', '1.由于工厂类集中了所有产品的创建逻辑，一旦不能正常工作，整个系统都要受到影响。', '枝叶', '', '266', '工厂类的重要性：核心地位，不能出错');
INSERT INTO `t_xxx_study_books` VALUES ('279', '设计模式读书笔记', '博客：简单工厂模式', '13.缺点：4-2', '2.使用简单工厂模式将会增加系统中类的个数，在一定程度上增加了系统的复杂度和理解难度。', '枝叶', '', '266', '增加了类的个数，必要的代价');
INSERT INTO `t_xxx_study_books` VALUES ('280', '设计模式读书笔记', '博客：简单工厂模式', '14.缺点：4-3', '3.系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。', '枝叶', '', '266', '用配置文件解决。');
INSERT INTO `t_xxx_study_books` VALUES ('281', '设计模式读书笔记', '博客：简单工厂模式', '15.缺点：4-4', '4.简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。', '枝叶', '', '266', '换成工厂方法模式就行了');
INSERT INTO `t_xxx_study_books` VALUES ('282', '设计模式读书笔记', '博客：简单工厂模式', '16.简单工厂模式的使用场景', '1.工厂类负责创建的对象比较少。2.客户端只知道传入工厂类的参数，对于如何创建对象不关心。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('283', '设计模式读书笔记', '博客：简单工厂模式', '17.总结：2-1', '1.简单工厂模式的要点在于当你需要什么，只需要传入一个正确的参数，就可以获取你所需的对象，而无须知道其创建细节。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('284', '设计模式读书笔记', '博客：简单工厂模式', '18.总结：2-2', '2.最大的优点在于实现对象的创建和对象的使用分离，但是如果产品过多时，会导致工厂代码非常复杂。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('285', '设计模式读书笔记', '博客：简单工厂模式', '19.完结', '内容结束，评论很少，没有价值，不写(参考)了。', '枝叶', '', '266', '');
INSERT INTO `t_xxx_study_books` VALUES ('286', '设计模式读书笔记', '博客：策略模式', '博客网址', 'http://www.cnblogs.com/chenssy/p/3295643.html', '总体', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('287', '设计模式读书笔记', '博客：策略模式', '1.与状态模式的相同点', '非常相似，犹如一对双胞胎一样。相同点是：两者都可用于解决同一个问题，带有大量if-else等条件判断语句。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('288', '设计模式读书笔记', '博客：策略模式', '2.与状态模式的不同点', '状态模式是通过改变对象内部的状态来帮助对象控制自己的行为，而策略模式则是围绕可以相互互换的算法来控制行为的。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('289', '设计模式读书笔记', '博客：策略模式', '3.什么是策略模式呢？', '在软件开发过程中，我们可能有很多种方法实现某一功能。而这些方法我们称之为策略。当需要根据不同的条件选择某一策略时，策略间可以互换的解决方案就是策略模式的动机。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('290', '设计模式读书笔记', '博客：策略模式', '4.策略模式的定义', '所谓策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式然该算法的变化独立于使用算法的客户。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('291', '设计模式读书笔记', '博客：策略模式', '5.策略模式前的代码', '将算法全部写在一个类里，每一种算法的具体实现对应着一个方法，然后写一个总方法通过if-else来判断选择具体的算法。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('292', '设计模式读书笔记', '博客：策略模式', '6.策略模式前的问题-1', '1.如果需要增加新的算法，则需要修改源代码。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('293', '设计模式读书笔记', '博客：策略模式', '7.策略模式前的问题-2', '2.如果更新了排序算法，那么需要在客户端也需要修改代码，麻烦。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('294', '设计模式读书笔记', '博客：策略模式', '8.策略模式前的问题-3', '充斥着大量的if…else…语句，代码维护比较困难。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('295', '设计模式读书笔记', '博客：策略模式', '9.策略模式的代码', '定义一个抽象的父类，把不同的算法当成一个独立的子类，每个子类称为一个具体的策略。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('296', '设计模式读书笔记', '博客：策略模式', '10.策略模式的UML图-1', '与状态模式的UML几乎一模一样。状态模式是对状态进行封装，将动作的实现和责任进行分割，把动作委托到代表当前状态的对象。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('297', '设计模式读书笔记', '博客：策略模式', '11.策略模式的UML图-2', '而策略模式是对算法的封装，把算法的责任和算法本身进行分割开来，同时委派给不同的对象进行管理。策略模式是将一个系列的算法封装到一系列的策略里面。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('298', '设计模式读书笔记', '博客：策略模式', '12.策略模式不关心什么？', '对于算法的选择，策略模式并不关心，它只是对算法进行封装。算法什么时候用，用在什么地方，都是由客户决定的。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('299', '设计模式读书笔记', '博客：策略模式', '13.带来的好处与缺点', '提高了系统的灵活性，但增加了客户的负担。因为客户需要清除知道选择什么样的算法对自己最有利，这就需要客户对每一个算法都清除知道他们的区别。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('300', '设计模式读书笔记', '博客：策略模式', '14.优点：3-1', '1.策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('301', '设计模式读书笔记', '博客：策略模式', '15.优点：3-2', '2.策略模式提供了可以替换继承关系的办法。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('302', '设计模式读书笔记', '博客：策略模式', '16.优点：3-3', '3.使用策略模式可以避免使用多重条件转移语句。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('303', '设计模式读书笔记', '博客：策略模式', '17.缺点：2-1', '1.客户端必须知道所有的策略类，并自行决定使用哪一个策略类。', '枝叶', '', '286', '可与简单工厂结合解决');
INSERT INTO `t_xxx_study_books` VALUES ('304', '设计模式读书笔记', '博客：策略模式', '18.缺点：2-2', '2.策略模式将造成很多策略类。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('305', '设计模式读书笔记', '博客：策略模式', '19.使用场景：3-1', '1.如果在一个系统里面有很多类，它们之间的区别仅在于它们的行为，', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('306', '设计模式读书笔记', '博客：策略模式', '20.使用场景：3-2', '2.一个系统需要动态地在几种算法中选择一种。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('307', '设计模式读书笔记', '博客：策略模式', '21.使用场景：3-3', '3.如果一个对象有很多的行为，如果不使用策略模式，就只能用多重条件选择语句来实现。', '枝叶', '', '286', '');
INSERT INTO `t_xxx_study_books` VALUES ('308', '设计模式读书笔记', '博客：策略模式', '22.结束-评论', '解决策略模式缺点：使用工厂模式！！！', '枝叶', '', '286', '是行为模式，与结构模式有什么区别呢？');
INSERT INTO `t_xxx_study_books` VALUES ('309', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '', '', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('310', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '1.新手机', '新出的Nokia N86功能很多，能上网、拍照、听歌、gps...功能很多，避免了携带笔记本、相机、MP3等设备，一机在手，天下我有。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('311', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '2.拍摄UFO', '发现一架UFO，花了九牛二虎之力，终于拍下来了，但画面不是很清晰，打算回家在电脑上看。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('312', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '3.没用的东西', '在电脑上的效果只是一个白点，根本看不出是UFO，小菜对手机比较失望，拍摄效果不理想。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('313', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '4.单一职责原则', '如果是摄像机，效果一定不会差，原因是人眼看得很清楚。大多数时候，一件产品简单一些，职责单一一些，或许是更好的选择。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('314', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '5.单一职责的定义', '定义：就一个类而言，应该仅有一个引起它变化的原因。这样类就很容易复用，也比较灵活。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('315', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '6.方块游戏的设计', '如何设计俄罗斯方块有些呢？有界面，有逻辑，如果界面与逻辑混在一起，就有很多种改变它的原因。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('316', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '7.职责过多的问题', '如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会消弱或者抑制这个类完成其他职责的能力。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('317', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '8.职责过多导致的后果', '接上，这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('318', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '9.如何做好软件设计？', '软件设计真正要做的内容很多，就是发现职责并把这些职责相互分离。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('319', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '10.什么时候考虑类的职责分离？', '如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责，就应该考虑类的职责分离。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('320', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '11.手机的职责过多码？', '整合当然是一种很好的思想，但分类、垂直搜索也很实用，因此要考虑的功能复杂性，比如智能手机，如果能整合更好，不能整合就分离，目的是让用户好用。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('321', '大话设计模式', '3.第三章拍摄UFO---单一职责原则', '12.编程要考虑单一职责的原因', '因为编程是一件很复杂的工作，我们要在类的职责分离上多思考，做到单一职责，这样的代码才是真正的易维护、易扩展、易复用、灵活多样。', '枝叶', '', '146-309', '');
INSERT INTO `t_xxx_study_books` VALUES ('322', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '', '', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('323', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '1.考研失败', '考研的时候，未对找工作做准备，失败后，才沮丧。考研时，未对找工作开放。dxp一国两制收回香港：一个国家，两种制度，这在政治上，是伟大的发明。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('324', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '2.开放-封闭原则', '开放-封闭原则，是说软件实体（类、模块、函数等）应该可以扩展，但是不可修改。简述为：对扩展开放，对修改关闭。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('325', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '3.开闭原则带来的好处', '告诉我们怎样的设计才能面对需求的改变却可以保持相对稳定，从而使得系统可以在第一个版本以后不断推出新的版本。即设计需要满足开闭原则。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('326', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '4.开闭原则在生活中的应用', '老板对上班考勤的考核，严格按照上班时间是不必要的，主要问题是保证每天8小时的工作量时老板最需要的，所以弹性上班工作制，就是符合开闭原则的制度。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('327', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '5.弹性上班怎么符合开闭原则呢？', '对工作时间或业绩成效的修改是关闭的，而对时间制度扩展开放。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('328', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '6.开闭原则应做到什么？', '1.设计的时候，时刻要考虑，尽量让这个类是足够好，写好了就不要去修改了，如果新需求来，我们增加一些类就完事了，原来的代码能不动则不动。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('329', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '7.开闭原则遇到的挑战', '绝对的对修改关闭是不可能的。无论模块是多么的“封闭”，都会存在一些无法对之封闭的变化。既然不可能完全封闭，我们该怎么办呢？', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('330', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '8.如何应对不完全封闭的情况？', '设计人员必须对于他设计的模块应该对哪种变化封闭做出选择。他必须先猜测最有可能发生的变化种类，然后构造抽象来隔离哪些变化。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('331', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '9.何时应对变化？', '我们很难预先猜测，但却可以在发生小变化时，就及早想办法应对发生更大变化的可能，也就是说，等到变化发生时，立即采取行动。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('332', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '10.人生经历的哲学', '正所谓，同一地方，摔第一跤不是你的错，再次在此摔跤就是你的不对了。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('333', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '11.面对变化我们应该做什么？', '在我们最初编写代码时，假设变化不会发生。当变化发生时，我们就创建抽象来隔离以后发生的同类变化。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('334', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '12.开闭原则的代码要求', '面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码。这就是开闭原则的精神所在。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('335', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '13.越早发现变化越好', '我们希望的是在开发工作开展不久就知道可能发生的变化。查明可能发生的变化所等待的时间越长，要创建正确的抽象就越困难。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('336', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '14.面向对象的核心', '开闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处，也就是可维护、可扩展、可复用、灵活性好。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('337', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '15.对变化进行抽象', '开发人员应该仅对程序中呈现出频繁变化的那些部分作出抽象，然而对每个部分刻意地进行抽象同样不是一个好主意。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('338', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '16.过度抽象不是一个好主意', '拒绝不成熟的抽象和抽象本身一样重要。过度抽象会导致程序很复杂，可读性低，也无法进行很好地扩展。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('339', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '17.两手准备，并全力以赴', '考研之前，学习计划是不应该更改的，这是对修改关闭，在不影响复习的前提下，来写写建立，了解招聘大学生的公司的资讯，是对扩展开放。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('340', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '18.两手准备的意义', '既不影响你考研，又可以增大找到好工作的可能性，为考研万一失败后找工作做好充分的准备。不要把所有的鸡蛋放在一个篮子里，这是为了防止出现意外。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('341', '大话设计模式', '4.第四章考研求职两不误---开放封闭', '19.对自己的意义', '全力以赴当然是必需的，两手准备也是灵活处事的表现。所以，我现在除了考虑成功的可能性，也要做好失败的准备。', '枝叶', '', '146-322', '');
INSERT INTO `t_xxx_study_books` VALUES ('342', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '0.第五章开始', '', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('343', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '1.MM请求修电脑', '内存坏了，电脑蓝屏，远程协助维修。死了都要爱的铃声，习以为常的东西往往都不是正确的，死了怎么爱？李善友：万众一心...标语。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('344', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '2.电话遥控修电脑', '打开机箱，拔出内存条，开机正常。内存问题的电脑，就修好了，就是这么简单。我在这儿等着你回来---花痴。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('345', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '3.为什么能修电脑？', 'CPU独立成产品，把接口定义好，内部再复杂也不让外界知道，主板只需要预留与CPU针脚的插槽就可以了。内存条也是一样', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('346', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '4.换零件修电脑', '这就是接口的最大好处。内存坏了，不应该成为更换CPU的理由，它们各自的职责是明确的，谁坏了，替换就行了，不会影响其他部件的功能。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('347', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '5.单一职责、组合', '各个部件的职责是分离的，硬盘就是为了存储数据，不参与计算、显示，是职责分离的体现，但将它们组合起来，就体现出强大的功能。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('348', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '6.依赖倒转原则', '原话为：抽象不应该依赖细节，细节应该依赖于抽象。白话为：针对接口编程，不要对实现编程。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('349', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '7.依赖倒转在电脑上的体现', '无论主板、CPU、内存、硬盘都是针对接口设计的，如果针对实现来设计，内存就要对应到具体的某个品牌的主板，出现换内存需要把主板也换了的尴尬。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('350', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '8.高层模块依赖底层模块', '在面向过程的开发中，为了使得常用代码可以复用，一般都会把这些常用代码写成许多函数的程序库，在做项目时，直接调用这些底层函数就可以了。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('351', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '9.面向过程的缺陷', '要做新项目时，发现业务逻辑测高层模块都是一样的，但客户却希望使用不同的数据库或存储信息方式，会导致所有模块不可用。因为高层模块与底层的访问数据库绑定在一起。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('352', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '10.为什么依赖于抽象后就不怕更改了呢？', '因为在面向对象领域中，还有一个重要的原则：里氏替换原则。是有Liskov女士在1988年发表的。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('353', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '11.里氏替换原则', '一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('354', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '12.里氏替换原则的简述', '也就是说，在软件里面，把父类替换成它的子类，程序的行为没有变化，简单地说，子类型必须能够替换掉它们的父类型。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('355', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '13.鸟与企鹅', '在生物学上，企鹅是一种特殊的鸟，虽然不能飞。但在面向对象设计时，企鹅就不能继承鸟，因为他不能完全替换父类型。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('356', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '14. 里氏替换原则的意义-1', '正是有了这个原则，使得继承复用成为了可能。只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('357', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '15.里氏替换原则的意义-2', '使得开闭原则成为了可能。正是由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('358', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '16.里氏替换与依赖倒转', '因为依赖的是高层模块的抽象接口，所以替换时不会影响到高层模块，所以依赖倒转才能真正实现。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('359', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '17.电脑能修，而收音机不能修', '收音机就是典型的耦合过度，只要出故障，都很难修理，不懂的人根本没法修，因为任何问题都可能涉及其他部件，各个部件相互依赖，难以维护。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('360', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '18.电脑能修的原因', '非常复杂的电脑可以修，反而相对简单的收音机不能修，说明依赖倒转带来的巨大好处。但要认识到，电脑的所谓修也就是更换配件，而不是真正的修理。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('361', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '19.面向对象设计的标志', '依赖倒转其实可以说是面向对象的标志。即程序中所有的依赖关系都是终止于抽象类或接口，那就是面向对象的设计，反之就是过程化的设计了。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('362', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '20.学习设计模式的好处', '银行系统出问题了，导致的经济损失很大，所以现在大力鼓励年轻人学设计模式，直接面向对象的设计和编程，从大的方向上讲，就是国家大力发展生产力的很大保障。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('363', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '21.本书的五大原则', '按照板书顺序：单一职责》开闭原则》依赖倒转》里氏替换，还有后面的迪米特法则，而没有讲接口隔离、组合原则。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('364', '大话设计模式', '5.第五章电脑、收音机---依赖倒转', '22.七大原则排列属性', '按我的理解，应该还开闭原则排在最前面，依次是：依赖倒转、里氏替换、单一职责、接口隔离、迪米特法则、组合聚合原则。', '枝叶', '', '146-342', '');
INSERT INTO `t_xxx_study_books` VALUES ('365', '大话设计模式', '6.第六章穿什么---装饰模式', '', '', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('366', '大话设计模式', '6.第六章穿什么---装饰模式', '1.小菜约会不知道穿什么好？', '他想给娇娇留下一个深刻的印象，因此纠结于穿什么，经过大鸟的开导，认识到穿什么不重要，简练干净就行，最重要的是你这个人。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('367', '大话设计模式', '6.第六章穿什么---装饰模式', '2.穿什么有这么重要？', '男生嘛，只要干净一些就可以了，关键不在于你穿什么，而在于你人怎么样。对自己都这么没信心，如何追求女孩子。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('368', '大话设计模式', '6.第六章穿什么---装饰模式', '3.网络avatar系统', '给人搭配不同的服饰系统，如网络上QQ、游戏、论坛都有的avatar系统。即可以换各种各样的衣服裤子的个人形象系统。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('369', '大话设计模式', '6.第六章穿什么---装饰模式', '4.小菜扮靓第一版', '只有一个类，将衣服穿着当成一个方法，要某种穿着，就要调多个方法进行展示。如果要增加超人的装扮，就要修改类，违背了开闭原则。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('370', '大话设计模式', '6.第六章穿什么---装饰模式', '5.小菜扮靓第二版-改版', '提取出一个person，一个装扮的父类，具体装扮的各种子类，如大叉裤等。这样解决了超人的装扮，增加一个子类，不用改原来的代码。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('371', '大话设计模式', '6.第六章穿什么---装饰模式', '5.改版后存在的问题', '用了继承，用了抽象类就算是用好了面向对象了吗？现在虽然做到了服饰类与人类的分离，但仍存在一个问题：组装的过程是公开的，就像在公共场合躶体穿衣。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('372', '大话设计模式', '6.第六章穿什么---装饰模式', '6.内部组装再显示，建造者模式？', '建造者模式要求建造的过程必须是稳定的，而现在我们这个例子，建造过程是不稳定的。即通过服饰组合出一个有个性的人，完全有无数种方案，并非是固定不变的。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('373', '大话设计模式', '6.第六章穿什么---装饰模式', '7.改版的装扮还存在什么问题？', '装扮还存在一个问题：即穿的先后顺序也是有讲究的，如先穿内裤后穿外裤，这叫凡人，内裤外穿，就是超人了。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('374', '大话设计模式', '6.第六章穿什么---装饰模式', '8.解决方案的思路', '我们需要把所需的功能按正确的顺序串联起来进行控制，建造者模式不行，所以我们需要学一种新的设计模式：装饰模式。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('375', '大话设计模式', '6.第六章穿什么---装饰模式', '9.装饰模式的定义', '装饰模式（Decorator），动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('376', '大话设计模式', '6.第六章穿什么---装饰模式', '10.装饰模式的结构图', '1.第一层：组件接口；2.第二层：接口的两个实现类：具体组件，抽象装饰类；3.第三层：抽象装饰类的子类。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('377', '大话设计模式', '6.第六章穿什么---装饰模式', '11.装饰模式的关键：装饰抽象类', 'Decorator(装饰抽象类)继承了Component，它有一个Component属性（从外类来扩展Component类的功能），但对于Component来说，是无需知道Decorator的存在的。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('378', '大话设计模式', '6.第六章穿什么---装饰模式', '12.模式的其他组成部分的作用-1', 'Component是定义一个对象接口，可以给这些对象动态地添加职责。ConcreteComponent是定义了一个具体的对象，也可以给这个对象添加一些职责。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('379', '大话设计模式', '6.第六章穿什么---装饰模式', '13.模式的其他组成部分的作用-2', 'Decorator，继承并聚合了Component接口，从外类来扩展Component的功能。至于ConcreteComponent就是具体的装饰对象，起到给Component添加职责的功能。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('380', '大话设计模式', '6.第六章穿什么---装饰模式', '14.装饰模式的代码调用', '1.先new一个具体构件，2.再new一个具体装饰器，将具体构件传入装饰器（构造器或setter方法），形成一个新的构件。3.重复2；4.调用最后的装饰类的接口方法', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('381', '大话设计模式', '6.第六章穿什么---装饰模式', '15.装饰模式的原理-1', '装饰模式是利用setComponet来对对象进行包装的(也可以构造器注入)。这样每个装饰对象的实现就和如何使用这个对象分离开了。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('382', '大话设计模式', '6.第六章穿什么---装饰模式', '16.装饰模式的原理-2', '每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。即内裤外穿、内穿都可以。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('383', '大话设计模式', '6.第六章穿什么---装饰模式', '17.模式的变通-1', '学习模式要善于变通：如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator累可以是ContreteComponent的一个子类。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('384', '大话设计模式', '6.第六章穿什么---装饰模式', '18.模式的变通-2', '同理，如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('385', '大话设计模式', '6.第六章穿什么---装饰模式', '19.模式变通的应用', '如avatar系统，就没有必要有Component类了，直接让服饰类Decorator继承人类Person就可。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('386', '大话设计模式', '6.第六章穿什么---装饰模式', '20.小菜扮靓第三版', '用了装饰模式，具体类Person，抽象类Decorator继承Person，具体装扮是Decorator的子类。在调用时，把person类传入装饰类，最后调用装饰类的show()。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('387', '大话设计模式', '6.第六章穿什么---装饰模式', '21.新增一种装扮', '如果要新增一种装扮，新增一个装饰类，再将组装装饰类的顺序改变一些接口，而具体组件是不知道自己被装饰了。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('388', '大话设计模式', '6.第六章穿什么---装饰模式', '22.总结1：装饰模式干什么？', '装饰模式是为已有功能，动态地添加更多功能的一种方式。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('389', '大话设计模式', '6.第六章穿什么---装饰模式', '23.总结2：装饰模式前的情况', '在起初的设计中，当系统需要新功能的时候，是向旧的类中添加新的代码。这些新加的代码通常装饰了原有类的核心职责或主要行为。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('390', '大话设计模式', '6.第六章穿什么---装饰模式', '24.总结3：改代码带来的问题', '在主类中加入新的字段，新的方法和新的逻辑，从而增加了主类的复杂度，而这些新加入的东西仅仅是为了满足一些在某种特定情况下才会执行的特殊行为的需要。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('391', '大话设计模式', '6.第六章穿什么---装饰模式', '25.总结4：装饰模式的解决方案', '装饰模式却提供了一个非常好的解决方案，它把每个要装饰的功能放在单独的类中，并让这个类包装它所要装饰的对象，因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('392', '大话设计模式', '6.第六章穿什么---装饰模式', '26.总结5：装饰模式的优点', '把类中的装饰功能从类中搬移出去，这样可以简化原有的类。更大的好处是：有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中重复的装饰逻辑。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('393', '大话设计模式', '6.第六章穿什么---装饰模式', '27.总结6：装饰模式的注意点', '使用装饰模式要当心，装饰的顺序很重要。如加密数据和过滤词汇都是数据持久化前的装饰功能，但先加密再过滤，功能就会出问题。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('394', '大话设计模式', '6.第六章穿什么---装饰模式', '28.总结7：理想情况', '最理想的情况，是保证装饰类之间彼此独立，这样它们就可以以任意的顺序进行组合，但碰到上面的问题就要注意了，需要其他方面的功能来加以解决。', '枝叶', '', '146-365', '');
INSERT INTO `t_xxx_study_books` VALUES ('395', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '', '', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('396', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '1.为别人做嫁衣', '娇娇有男朋友，并给小菜回忆起他们认识的过程......戴励帮卓贾易送娇娇礼物。最后娇娇与戴励在一起了，就是她现在在北京的男朋友。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('397', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '2.学新模式：代理模式', '卓贾易不直接追娇娇，而是找戴励帮忙，结果是为别人做嫁衣，所以自己苦恼也是活该，谁叫他不自己主动，找人代理谈恋爱。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('398', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '3.没有代理的代码', '模拟卓贾易直接追求娇娇。追求者--->被追求者。将被追求者传入追求者对象，调用追求者对象的送花、送巧克力，送回家等行为。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('399', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '4.只有代理的代码', '但娇娇不认识卓贾易，上面的行为就行不通。所以需要戴励这个人来代理送礼物。小菜就把卓贾易直接替换戴励了，戴励就没关系了。变成戴励直接给娇娇送礼物了，而不是代理别人送礼物。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('400', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '5.如何正确设计代理类？', '仔细观察一下，不难发现，追求者和代理都有送礼物的三个方法，代理如果没有，就不能完成对目标的代理了，所以它们应该有一个共同的父类或接口。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('401', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '6.符合实际的代码', '1.抽象出一个接口，封装这三个送礼物的方法；2.代理类和追求者都实现这个接口；3.代理类聚合追求者对象。所以将娇娇传给追求者，将追求者传给代理，调用代理的送礼物方法，这样娇娇得到了礼物，但又不与送礼物的卓贾易认识了。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('402', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '7.代理实现后的效果', '这下好了，娇娇不认识追求她的人，但却可以通过代理人得到礼物，效果其实是达到了。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('403', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '8.代理模式的定义', '代理模式：为其他对象提供一种代理以控制对这个对象的访问。目的是控制，而不是装饰。这是与装饰模式的最大区别。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('404', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '9.代理模式的结构图', '1.Subject，从代理类和被代理类提出的公共接口；2.RealSubjcet，真实对象，即被代理类；3.Proxy，代理类。保存一个真实对象的引用，以调用真实对象的方法（即代理）。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('405', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '10.Subject的作用', 'Subject类，定义了RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy了。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('406', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '11.Proxy类的作用', '保存一个引用使得代理可以访问实体对象，并提供一个与Subject的接口相同的接口，这样就可以来替代实体了。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('407', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '12.代理模式的应用场合', '代理模式分为好几种，如远程代理、虚拟代理、安全代理、智能指引。在这些场景下都很适合代理模式。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('408', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '13.什么是远程代理？', '也就是为一个对象在不同的地址空间提供局部代表，这样可以隐藏一个对象存在于不同地址空间的事实。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('409', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '14.远程代理的例子', '如WebSerivce，需要在本地产生一些WebService客户端，客户端就是远程访问的代理。这样我们在调用WebService时，就像调用本地方法一样。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('410', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '15.什么是虚拟代理？', '虚拟代理就是根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象。以达到性能最优化。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('411', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '16.虚拟代理的例子', '打开一个很大的HTML网页时，里面有很多图片、js和css文件。浏览器会先将文字显示出来，通过虚拟代理来下载文件，优化页面打开速度的。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('412', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '17.什么是安全代理？', '安全代理就是用来控制真实对象访问时的权限。一般用于对象应该有不同的访问权限的时候。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('413', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '18.什么是智能指引？', '是指当调用真实的对象时，代理处理另外一些事。如计算真实对象的自动释放、装入内存、检查锁定等。即通过代理在访问一个对象时附加一些内务处理。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('414', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '19.智能指引的应用', '自动释放：计算真实对象的引用次数，当该对象没有引用时，可以自动释放。装入内存：当第一次引用一个持久对象时。检查锁定：访问一个实际对象前，检查是否已经锁定它，以确保其他对象不能改变它。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('415', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '20.代理模式的本质', '代理模式其实就是在访问对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。说白了，代理就是真实对象的代表。', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('416', '大话设计模式', '7.第七章为别人做嫁衣---代理模式', '21.秀才让小刘代其求婚', '武林外传-22集剧尾，本节完', '枝叶', '', '146-395', '');
INSERT INTO `t_xxx_study_books` VALUES ('417', '设计模式读书笔记', '博客：装饰模式', '标题', '设计模式读书笔记---装饰模式，地址：http://www.cnblogs.com/chenssy/archive/2013/05/23/3094138.html', '总部', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('418', '设计模式读书笔记', '博客：装饰模式', '1.添加行为的两种方式', '我们都知道，可以使用两种方式给一个类或者对象添加行为：继承、关联。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('419', '设计模式读书笔记', '博客：装饰模式', '2.通过继承添加行为', '比较有效的途径：通过使用继承，子类在拥有自身方法的同时，还拥有父类的方法。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('420', '设计模式读书笔记', '博客：装饰模式', '3.继承的缺点', '继承是静态的，在编译的时候就决定了子类的行为，我们不便于控制增加行为的方式和时机。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('421', '设计模式读书笔记', '博客：装饰模式', '4.关联添加行为', '组合或聚合：将一个对象嵌入到另一个对象中，由另一个对象来决定是否引用该对象来扩展自己的行为。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('422', '设计模式读书笔记', '博客：装饰模式', '5.关联的好处', '是一种动态的方式，我们可以在应用程序中动态的控制。动态 VS 静态。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('423', '设计模式读书笔记', '博客：装饰模式', '6.关联对继承的优势', '在于不会破坏类的封装性，且具有较好的松耦合性，可以使系统更加容易维护。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('424', '设计模式读书笔记', '博客：装饰模式', '7.关联对继承的劣势', '关联对继承的缺点就是：要创建比继承更多的对象。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('425', '设计模式读书笔记', '博客：装饰模式', '8.装饰模式的定义', '装饰者模式，动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更加有弹性的替代方案。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('426', '设计模式读书笔记', '博客：装饰模式', '9.模式的UML结构图', '接口组件、具体组件、抽象装饰类(实现接口，组合接口)、具体装饰类（子类）。共有4个角色。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('427', '设计模式读书笔记', '博客：装饰模式', '10.Decorator', '抽象装饰类：继承了Component，从外类来扩展Component的功能，但对Component来说，是无需知道Decorator存在的。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('428', '设计模式读书笔记', '博客：装饰模式', '11.代码实现', '在使用装饰模式前的结构图，和使用后的结构图。再是具体的代码实现。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('429', '设计模式读书笔记', '博客：装饰模式', '12.优点4-1', '1.装饰者模式可以提供比继承更多的灵活性。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('430', '设计模式读书笔记', '博客：装饰模式', '13.优点4-2', '2.可以通过一种动态的方式来扩展一个对象的功能，在运行时选择不同的装饰器，从而实现不同的行为。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('431', '设计模式读书笔记', '博客：装饰模式', '14.优点4-3', '3.可以通过使用不同的具体装饰类以及这些装饰类的排练组合，可以创造出很多不同的行为的组合。可以使用多个具体装饰类拉装饰同一个对象，得到功能更为强大的对象。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('432', '设计模式读书笔记', '博客：装饰模式', '15.优点4-4', '4.具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开-闭原则”。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('433', '设计模式读书笔记', '博客：装饰模式', '16.缺点2-1', '1.会产生很多的小对象，增加了系统的复杂性。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('434', '设计模式读书笔记', '博客：装饰模式', '17.缺点2-2', '2.这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错，排错也很困难。对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为繁琐。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('435', '设计模式读书笔记', '博客：装饰模式', '18.模式的适用场景2-1', '1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('436', '设计模式读书笔记', '博客：装饰模式', '19.模式的适用场景2-2', '2.需要动态地给一个对象增加功能，这些功能也可以动态地被撤销。当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('437', '设计模式读书笔记', '博客：装饰模式', '20.总结7-1', '1.组合和委托可以在运行时动态的添加新的行为，而继承是静态的，在系统编译时就已经决定了对象的行为。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('438', '设计模式读书笔记', '博客：装饰模式', '21.总结7-2', '2.装饰者模式意味着一群装饰类，这些类用来保障具体组件。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('439', '设计模式读书笔记', '博客：装饰模式', '22.总结7-3', '3.装饰者可以在被装饰者的行为前面或后面加上自己的行为，甚至可以将被装饰者的行为整体取代掉，从而达到特定的目的。', '枝叶', '', '417', '？？？这不是代理模式了么');
INSERT INTO `t_xxx_study_books` VALUES ('440', '设计模式读书笔记', '博客：装饰模式', '23.总结7-4', '4.可以用多个装饰者包装一个组件。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('441', '设计模式读书笔记', '博客：装饰模式', '24.总结7-5', '5.装饰者一般对于组件的客户是透明的，除非客户程序依赖于组件的具体类型。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('442', '设计模式读书笔记', '博客：装饰模式', '25.总结7-6', '6.装饰者会导致设计中出现许多的小对象，如果过度使用，会让系统变得更加复杂。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('443', '设计模式读书笔记', '博客：装饰模式', '26.总结7-7', '7.装饰者和被装饰者对象有相同的超类型。', '枝叶', '', '417', '');
INSERT INTO `t_xxx_study_books` VALUES ('444', '设计模式读书笔记', '博客：代理模式', '标题', '设计模式读书笔记---代理模式，地址：http://www.cnblogs.com/chenssy/p/3304390.html', '总部', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('445', '设计模式读书笔记', '博客：代理模式', '1.代理情况很常见', '如购物过程中，支付宝、物流公司、物业都扮演“第三者”的角色帮我完成物品的购买。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('446', '设计模式读书笔记', '博客：代理模式', '2.什么是代理？', '所谓代理就是通过引用一个新的对象来实现对真实对象的操作或者将新的对象当做真实对象的一个替身，这种实现机制就是代理模式。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('447', '设计模式读书笔记', '博客：代理模式', '3.代理模式的设计动机', '通过引用代理对象来访问真实对象。如网络远程代理，在客户端产生一个代理，以隐藏在网络另一端的真实对象，达到隐藏（封装）实现细节的目的。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('448', '设计模式读书笔记', '博客：代理模式', '4.代理模式的定义', '代理模式就是给一个对象提供一个代理，并由代理对象控制对原对象的引用。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('449', '设计模式读书笔记', '博客：代理模式', '5.代理的作用', '在代理模式中，“第三者”代理主要是起到一个中介的作用，它连接客户端和目标对象。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('450', '设计模式读书笔记', '博客：代理模式', '6.UML结构图', '代理与真实对象有一个共同的父类或接口。客户端调用代理的方法，在代理中控制是否访问真实对象。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('451', '设计模式读书笔记', '博客：代理模式', '7.Proxy角色', '代理角色：代理对象与真实对象实现相同的接口，所以它能够在任何时刻都能够代理真实对象。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('452', '设计模式读书笔记', '博客：代理模式', '8.Proxy内部', '代理角色内部包含有对真实对象的引用，所以它可以操作真实对象，同时也可以附加其他操作，相当于对真实对象进行封装。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('453', '设计模式读书笔记', '博客：代理模式', '9.模式的实现（代码）', '通过在大学里追女孩，先搞好她闺蜜的例子来进行编码。通过构造方法传入时，在代理的构造方法里new真实对象，客户就不知道真实对象了。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('454', '设计模式读书笔记', '博客：代理模式', '10.优点2-1', '1.代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('455', '设计模式读书笔记', '博客：代理模式', '11.优点2-2', '2.代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护了目标对象的目的。', '枝叶', '', '444', '降低耦合');
INSERT INTO `t_xxx_study_books` VALUES ('456', '设计模式读书笔记', '博客：代理模式', '12.缺点2-1', '1.由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。', '枝叶', '', '444', '保护目标');
INSERT INTO `t_xxx_study_books` VALUES ('457', '设计模式读书笔记', '博客：代理模式', '13.缺点2-2', '2.实现代理模式需要额外的工作，有些代理模式的实现非常复杂。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('458', '设计模式读书笔记', '博客：代理模式', '14.模式适用场景3-1', '1.远程代理：为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在不同地址空间的事实。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('459', '设计模式读书笔记', '博客：代理模式', '15.模式适用场景3-2', '2.虚拟代理：通过使用一个小的对象代理一个大对象。这样可以减少系统的开销。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('460', '设计模式读书笔记', '博客：代理模式', '16.模式使用场景3-3', '3.保护代理：用来控制对真实对象的访问权限。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('461', '设计模式读书笔记', '博客：代理模式', '17.模式总结2-1', '1.代理模式是通过使用引用对象来访问真实对象，在这里代理对象充当用于连接客户端和真实对象的中介者。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('462', '设计模式读书笔记', '博客：代理模式', '18.模式总结2-2', '2.代理模式主要用于远程代理、虚拟代理和保护代理。其中保护代理可以进行访问权限控制。', '枝叶', '', '444', '');
INSERT INTO `t_xxx_study_books` VALUES ('463', '博客园-博客', '装饰模式与代理模式的区别(转载)', '0.网址', 'http://www.cnblogs.com/jaredlam/archive/2011/11/08/2241089.html', '总部', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('464', '博客园-博客', '装饰模式与代理模式的区别(转载)', '1.两个模式代来的困惑', '两个模式的UML看起来很像。装饰器：装饰者和被装饰者都实现同一个接口。代理：代理类和真实对象都实现同一个接口。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('465', '博客园-博客', '装饰模式与代理模式的区别(转载)', '2.两个模式的共同作用', '无论我们使用哪一个模式，都可以很容易在真实对象的方法前面或后面加上自定义的方法，即新增功能。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('466', '博客园-博客', '装饰模式与代理模式的区别(转载)', '3.两个模式的区别', '装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对象的访问。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('467', '博客园-博客', '装饰模式与代理模式的区别(转载)', '4.代理模式：控制访问', '代理模式：代理类可以对它的客户隐藏一个对象的具体信息，因此，当使用代理模式的时候，在代理类中需要创建一个真实对象的实例。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('468', '博客园-博客', '装饰模式与代理模式的区别(转载)', '5.装饰器：新增功能', '当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数餐给装饰者的构造器，而不是自己创建。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('469', '博客园-博客', '装饰模式与代理模式的区别(转载)', '6.关系确定的时机不同', '代理模式的关系在编译时就已经确定了，而装饰者能够在运行时递归地被构造。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('470', '博客园-博客', '装饰模式与代理模式的区别(转载)', '7.完结', '这篇文字比较短，但说明了几个问题，还是值得一看。', '枝叶', '', '463', '');
INSERT INTO `t_xxx_study_books` VALUES ('471', 'CSDN-博客', '动态代理：1个经纪人N个明显', '0.网址', 'http://blog.csdn.net/u011240877/article/details/52334547，作者：张轼心，是博客专家，值得一看。', '总部', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('472', 'CSDN-博客', '动态代理：1个经纪人N个明显', '1.回顾静态代理', '网址：http://blog.csdn.net/u011240877/article/details/52264283，代理模式：女朋友这么漂亮，你缺经纪人吗？---王宝强的例子', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('473', 'CSDN-博客', '动态代理：1个经纪人N个明显', '2.回顾总结', '静态代理需要我们编码时就确定代理、被代理的关系，如果有大量的或者运行时才确定的代理行为，静态代理就不太合适。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('474', 'CSDN-博客', '动态代理：1个经纪人N个明显', '3.回顾的解决方案', '在实际应用中，动态代理更为常用，它可以使用反射，通过参数和代理方法自动生成代理的代码。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('475', 'CSDN-博客', '动态代理：1个经纪人N个明显', '4.正文：静态代理的弊端', '1.需要手动创建代理类，如果要代理的类很多，会很累。2.代理与真实对象实现同样的接口，接口有变动，两个类都得修改，容易出问题。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('476', 'CSDN-博客', '动态代理：1个经纪人N个明显', '5.与静态代理的最大区别', '不用我们创建那么多类，敲那么多代码，在程序运行时，运用反射机制动态创建而成。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('477', 'CSDN-博客', '动态代理：1个经纪人N个明显', '6.JDK的Proxy动态代理', '它有一个方法：newProxyInstance(3个参数)，用于返回动态代理对象，可以创建任意类的代理对象。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('478', 'CSDN-博客', '动态代理：1个经纪人N个明显', '7.前两个参数', 'ClassLoader：被代理类的类加载器，与代理类要一致。Class[]：被代理实现的接口，创建的代理类会实现这些接口。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('479', 'CSDN-博客', '动态代理：1个经纪人N个明显', '8.第三个参数：最关键接口', 'InvocationHandler接口：它有一个invoke方法，是代理类进行拦截操作的入口，我们需要实现它来对真实对象的方法进行增强。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('480', 'CSDN-博客', '动态代理：1个经纪人N个明显', '9.invoke()的功能', '在invoke()里，有3个参数：代理对象(一般不用)，Method(被调用方法)、Object[]（被调用方法的参数）。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('481', 'CSDN-博客', '动态代理：1个经纪人N个明显', '10.如何书写invoke()-1', '1.我们可以通过method.getName来对要调用的方法进行控制，2.可以对方法参数进行记录，3.不要忘了最重要的调用原有方法：', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('482', 'CSDN-博客', '动态代理：1个经纪人N个明显', '11.如何书写invoke()-2', 'method.invoke(mTarget, args)，4.在调用这个方法时，可以进行控制，5.最后我们可以对结果进行记录或转换。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('483', 'CSDN-博客', '动态代理：1个经纪人N个明显', '12.mTarget对象', '这个是我们要代理的真实对象，需要从外界传入。所以我们需要一个属性Object来接收这个对象。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('484', 'CSDN-博客', '动态代理：1个经纪人N个明显', '13.JDK动态代理的好处', '1.只需要写一个类，就能对所有的类进行代理；2.真实对象改动后，不影响代理类的代码，因为代理对象是在运行时动态生成的。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('485', 'CSDN-博客', '动态代理：1个经纪人N个明显', '14.JDK动态代理的不足', '1.只能代理接口，不能代理类。代理类需要用到CGLIB(asm)。2.不能代理final类。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('486', 'CSDN-博客', '动态代理：1个经纪人N个明显', '15.Retrofit 中的动态代理', 'Retrofit是一个框架，暂时用不到，了解即可。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('487', 'CSDN-博客', '动态代理：1个经纪人N个明显', '16.Cglib的动态代理', '既能代理接口，也能代理类，广泛应用于许多AOP框架，如Spring，它的用法与JDK用法差不多，就不赘述了。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('488', 'CSDN-博客', '动态代理：1个经纪人N个明显', '17.更多应用', '代理模式在AOP中的运用，请继续看Spring的AOP章节。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('489', 'CSDN-博客', '动态代理：1个经纪人N个明显', '18.结束', '还是回到大话设计模式的章节吧。以后有新内容了，再补充。', '枝叶', '', '471', '');
INSERT INTO `t_xxx_study_books` VALUES ('490', '大话设计模式', '8.第八章工厂方法模式', '0.章节标题', '雷锋依然在人间---工厂方法模式', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('491', '大话设计模式', '8.第八章工厂方法模式', '1.再现活雷锋', '小菜的同学出事故后，发现做了三年的无名活雷锋：帮助一位儿子是军人的孤寡老人。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('492', '大话设计模式', '8.第八章工厂方法模式', '2.简单工厂模式实现', '工厂方法模式与简单工作有什么区别呢？简单工厂实现，是一个工厂类，负责对整个产品的创建。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('493', '大话设计模式', '8.第八章工厂方法模式', '3.工厂方法模式的实现', '由一个工厂抽象类，具体产品的创建由不同的子类来实现。即将简单工厂类的不同的产品创建，改为不同的工厂创建。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('494', '大话设计模式', '8.第八章工厂方法模式', '4.简单工厂 VS 工厂方法', '工厂方法应对新增算法类“M的N次方”：加类，加对应的工厂类，改客户端的工厂(处理case)。问题：不但没简化难度，反而增加了很多类和方法，把复杂性增加了。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('495', '大话设计模式', '8.第八章工厂方法模式', '5.简单工厂的最大优点', '在于：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关类，对于客户端来说，去除了与具体产品的依赖。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('496', '大话设计模式', '8.第八章工厂方法模式', '6.简单工厂模式的缺点', '新增类时，在工厂类里需要新增一个case分支条件，修改了原有的工厂类，即不但对扩展开放了，对修改也开放了，违背了开闭原则。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('497', '大话设计模式', '8.第八章工厂方法模式', '7.什么是工厂方法模式呢？', 'Factory Method：定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('498', '大话设计模式', '8.第八章工厂方法模式', '8.工厂模式改造后的状态', '整个工厂和产品体系其实都没有修改变化，而只是扩展的变化，这就完全符合开闭原则的精神了。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('499', '大话设计模式', '8.第八章工厂方法模式', '9.工厂模式没有解决什么？', '在工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('500', '大话设计模式', '8.第八章工厂方法模式', '10.判断逻辑的转移', '也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在是修改客户端！。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('501', '大话设计模式', '8.第八章工厂方法模式', '11.工厂方法模式的代码实现', '以前在简单工厂模式里，如果要创建多个相同对象，需要传3次同样的参数，代码重复了，换了工厂方法后，就只改一处就够了，其他地方没参数，就不涉及修改。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('502', '大话设计模式', '8.第八章工厂方法模式', '12.工厂方法模式的好处', '1.克服了简单工厂违背开闭原则的缺点，2.又保持了封装对象创建过程的优点。工厂方法模式是简单工厂模式的进一步抽象和推广。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('503', '大话设计模式', '8.第八章工厂方法模式', '13.解决if/case的终极解决方案', '将变化封装在配置文件里，通过反射来创建对象。现在还不急讲这个，以后会讲到。', '枝叶', '', '146-490', '');
INSERT INTO `t_xxx_study_books` VALUES ('504', '大话设计模式', '9.第九章简历复印-原型模式', '1.夸张的简历', '小菜的简历：写得很多，将小学得奖都写上去了，写得不切实际，各种精通。打算以量取胜，广投简历。', '分部', '', '146', '');
INSERT INTO `t_xxx_study_books` VALUES ('505', '大话设计模式', '9.第九章简历复印-原型模式', '2.复印简历', '通过复印，就可以得到多份与原来一模一样的简历。就像在电脑上，Ctrl C，Ctrl V一样方便快捷。而在编程中，简单的复杂粘贴有可能造成重复代码的灾难。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('506', '大话设计模式', '9.第九章简历复印-原型模式', '3.简历代码初步实现', '写一个简历类，通过调用多次创建对象并设置值的方法，实际上是生成了多个对象。而可以将一个对象赋给多个变量，但这些变量都引用同一个内存地址。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('507', '大话设计模式', '9.第九章简历复印-原型模式', '4.什么是原型模式？', 'Prototype：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('508', '大话设计模式', '9.第九章简历复印-原型模式', '5.原型模式的本质', '其实就是从一个对象再创建另一个可定制的对象，而且不需要知道任何创建的细节。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('509', '大话设计模式', '9.第九章简历复印-原型模式', '6.Java的原型模式支持', 'clone()是Object的protected方法，要想使用原型模式，类需要实现Cloneable接口(空接口-标示接口)，重新clone()方法，将访问修饰符改为public，且里面调用super.clone()：本地方法。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('510', '大话设计模式', '9.第九章简历复印-原型模式', '7.什么时候使用原型模式？', '一般在初始化信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('511', '大话设计模式', '9.第九章简历复印-原型模式', '8.原型模式的意义', '不用重新初始化对象，而是动态地获得对象运行时的状态。即不用new，而且不用重新设值。对于创建需要花费大量时间的对象，非常有用。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('512', '大话设计模式', '9.第九章简历复印-原型模式', '9.浅复制与深复制', '什么是浅复制？即Java默认的clone模式，只复制基本数据类型和String，而不复制引用类型。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('513', '大话设计模式', '9.第九章简历复印-原型模式', '10.什么是深复制呢？', '即把要复制的对象所引用的对象也复制一遍。深复制把引用对象的变量指向复制过来的新对象，而不是原有的被引用的对象。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('514', '大话设计模式', '9.第九章简历复印-原型模式', '11.Java的深复制实现', '1.需要引用的对象也实现了Cloneable接口，2.在自身的clone()里，先调用super.clone后，调用引用对象的clone()，再将引用对象的复制对象设置到复制对象中。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('515', '大话设计模式', '9.第九章简历复印-原型模式', '12.复制简历 VS 手写求职信', '工具带来的便利，但也带来了懒惰。想要与众不同，就得在值得花时间的地方，下笨功夫，才能脱颖而出。', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('516', '大话设计模式', '9.第九章简历复印-原型模式', '13.受重视or碰运气', '你是愿意你的简历和求职信备受重视呢，还是愿意和所有的毕业生一样千篇一律毫无新意地碰运气？', '枝叶', '', '146-504', '');
INSERT INTO `t_xxx_study_books` VALUES ('517', '设计模式读书笔记', '博客：工厂方法模式', '0.网址', 'http://www.cnblogs.com/chenssy/archive/2013/05/26/3099495.html', '总部', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('518', '设计模式读书笔记', '博客：工厂方法模式', '1.简单工厂模式的问题', '简单工厂模式将披萨的制作流程完全承包了。但我们希望各地有风味不同的披萨，如纽约披萨、芝加哥口味披萨。各地安装自己的制作流程来制作。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('519', '设计模式读书笔记', '博客：工厂方法模式', '2.披萨的解决方案', '将披萨的制作方法教给各个披萨加盟店完成，但是他们只能提供完成的披萨，但订单仍然要交给披萨工厂去做。即将创建披萨的方法，移到具体的店里，而其他部分保持不变。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('520', '设计模式读书笔记', '博客：工厂方法模式', '3.工厂方法模式的定义', '定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让实例化推迟到子类。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('521', '设计模式读书笔记', '博客：工厂方法模式', '4.UML结构图', '1.抽象产品；2.具体产品；3.抽象工厂；4.具体工厂', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('522', '设计模式读书笔记', '博客：工厂方法模式', '5.具体工厂的功能', 'ConcreteCreator：具体工厂。制造产品的实际工厂，它负责创建一个或多个具体产品，只有她才知道如何创建这些产品。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('523', '设计模式读书笔记', '博客：工厂方法模式', '6.工厂方法模式的不同', '1.它是简单工厂模式的延伸。2.在工厂方法模式中，核心工厂类不再负责产品的创建，而是将具体的创建工作交给子类去完成。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('524', '设计模式读书笔记', '博客：工厂方法模式', '7.抽象工厂的作用', '只负责提供创建的接口，具体实现交给继承它的子类去完成。新增具体产品时，只需要新增具体工厂类即可，不用修改抽象工厂，很好地符合了开闭原则。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('525', '设计模式读书笔记', '博客：工厂方法模式', '8.工厂方法模式的代码实现', '纽约风味披萨(牛肉、芝士...)，芝加哥风味披萨(牛肉...)，对应两个具体的工厂。在客户端，需要确定要new哪一个工厂。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('526', '设计模式读书笔记', '博客：工厂方法模式', '9.工厂方法模式的优缺点', '优点1：在工厂方法中，用户只需要知道所需要产品的具体工厂，无须关心具体的创建过程，甚至不需要具体产品类的类名。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('527', '设计模式读书笔记', '博客：工厂方法模式', '优点2', '新增产品时，只需要添加一个具体产品类和对应的实现工厂，无需对原工厂进行任何修改，很好地符合“开闭原则”。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('528', '设计模式读书笔记', '博客：工厂方法模式', '缺点：复杂度增加', '在优点2中，新增的类的个数成倍增加，增加了系统的复杂度，也增加了系统具体类的依赖，这并不是什么好事。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('529', '设计模式读书笔记', '博客：工厂方法模式', '10.工厂方法适用场景：3点', '1.一个类不知道它所需要的对象的类：不知道具体产品的类名，只知道创建它的具体工厂。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('530', '设计模式读书笔记', '博客：工厂方法模式', '', '2.一个类通过其子类来指定创建那个对象：工厂类只提供接口，实现类(子类)负责创建具体的对象。子类覆盖父类对象，系统更容易扩展。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('531', '设计模式读书笔记', '博客：工厂方法模式', '', '3.将创建对象的任务委托给多个工厂子类中的一个，客户端在使用时无须关系是哪个具体工厂创建产品，需要时(运行时)再动态指定。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('532', '设计模式读书笔记', '博客：工厂方法模式', '11.工厂方法模式的总结：5点', '1.工厂方法模式完全符合“开闭原则”。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('533', '设计模式读书笔记', '博客：工厂方法模式', '', '2.通过使用继承，将对象的创建委托给子类。通过子类实现工厂方法来创建对象。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('534', '设计模式读书笔记', '博客：工厂方法模式', '', '3.工厂方法运行类将实例化延伸到子类进行。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('535', '设计模式读书笔记', '博客：工厂方法模式', '', '4.在编程时，客户端不用知道创建的是哪一个具体产品，哪一个具体工厂，在运行时动态指定后，才确认。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('536', '设计模式读书笔记', '博客：工厂方法模式', '', '5.编程时，依赖于抽象，而不依赖于具体。在运行时，才确定要创建的具体产品，和对应的工厂。', '枝叶', '', '517', '');
INSERT INTO `t_xxx_study_books` VALUES ('537', '设计模式读书笔记', '博客：原型模式', '0.网址', 'http://www.cnblogs.com/chenssy/p/3313339.html', '总部', '', '', '');
INSERT INTO `t_xxx_study_books` VALUES ('538', '设计模式读书笔记', '博客：原型模式', '1.克隆技术是什么？', '就是用一个物体复制若干个一模一样的物体。在面向对象系统中，我们同样可以利用克隆技术克隆出若干一模一样的对象。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('539', '设计模式读书笔记', '博客：原型模式', '2.什么时候用克隆技术呢？', '1.有些对象比较复杂，其创建过程过于复杂，而且我们又需要频繁的利用该对象。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('540', '设计模式读书笔记', '博客：原型模式', '3.克隆技术-原型模式的设计目的', '我们可以利用一个原型对象来指明我们所要创建对象的类型，然后通过复制这个对象的方法来获得该对象一模一样的对象实例。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('541', '设计模式读书笔记', '博客：原型模式', '4.什么是原型模式呢？', '就是用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('542', '设计模式读书笔记', '博客：原型模式', '5.什么是浅拷贝？', '就是使用一个已知实例对新创建实例的成员变量逐个赋值。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('543', '设计模式读书笔记', '博客：原型模式', '6.什么是深拷贝？', '当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型成员变量创建新的实例，并且初始化。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('544', '设计模式读书笔记', '博客：原型模式', '7.UML结构图', '三个角色：抽象原型类，具体原型类，客户类。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('545', '设计模式读书笔记', '博客：原型模式', '8.Java中的原型模式', 'Object提供了一个clone()，但类要实现了Cloneable接口才能使用这个方法，否则会抛出ConeNotSupportedException.', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('546', '设计模式读书笔记', '博客：原型模式', '9.clone()的实现', 'Java中的clone()是protected的，所以需要更改为public，而且默认时浅复制，要深复制需要引用对象也实现了Cloneable接口，而且需要手动注入。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('547', '设计模式读书笔记', '博客：原型模式', '10.clone()满足3点', '1.都有obj.clone() != obj，即克隆对象与原对象不是同一个对象。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('548', '设计模式读书笔记', '博客：原型模式', '', '2.都有x.clone().getClass() == x.getClass()，即克隆对象与元对象的类型一样。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('549', '设计模式读书笔记', '博客：原型模式', '', '3.都有x.clone().equals(x) == true，需要确保x的equals重写恰当。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('550', '设计模式读书笔记', '博客：原型模式', '11.java原型模式的代码实现', '1.实现Cloneable接口；2.重写clone()；3.通过对象.clone()调用，产生出克隆对象。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('551', '设计模式读书笔记', '博客：原型模式', '12.原型模式的优点：3点', '1.如果创建新的对象比较复杂时，可以可用原型模式简化对象的创建过程，同时也能够提高效率。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('552', '设计模式读书笔记', '博客：原型模式', '', '2.可以使用深克隆，保持对象的状态(代码事务)； 3.原型模式提供了简化的创建结构。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('553', '设计模式读书笔记', '博客：原型模式', '13.原型模式的缺点：2点', '1.在实现深克隆的时候可能需要比较复杂的代码。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('554', '设计模式读书笔记', '博客：原型模式', '', '2.需要为相关的类都实现克隆方法，需要对类的功能进行通盘考虑。这对全新的系统不难，但对改造旧有系统不是一件容易的事，必须修改其源代码，违背了“开闭原则”。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('555', '设计模式读书笔记', '博客：原型模式', '14.原型模式的使用场景：3点', '1.如果创建新对象的成本较大，我们可以利用已有的对象进行复制来获得。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('556', '设计模式读书笔记', '博客：原型模式', '', '2.如果系统要保持对象的状态，而状态的变化很小，或者本身所占内存不大，可以使用原型+备忘录模式来解决。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('557', '设计模式读书笔记', '博客：原型模式', '', '相反，如果对象状态变化很大，或者占内存很大，那么采用状态模式会比原型模式要好。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('558', '设计模式读书笔记', '博客：原型模式', '', '3.需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态时。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('559', '设计模式读书笔记', '博客：原型模式', '15.原型模式总结：3点', '1.原型模式向客户隐藏了创建对象的复杂性。客户只需要知道要创建对象的类型，然后通过请求就可以获得和该对象一模一样的新对象，无须知道具体的创建过程。', '枝叶', '', '537', '');
INSERT INTO `t_xxx_study_books` VALUES ('560', '设计模式读书笔记', '博客：原型模式', '', '2.克隆分为浅克隆和深克隆两种。 3.深克隆时，可能会相当复杂。', '枝叶', '', '537', '');
 
 
</div>

jjjsss2

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
大话设计模式

SET FOREIGN_KEY_CHECKS=0; -- ------------------------------ Table structure for t_xxx_study_books-- ----------------------------DROP TABLE IF EXISTS `t_xxx_study_books`;CREATE TABL...
复制链接

扫一扫

专栏目录