大话设计模式总结(1-15章)

一、简单工厂设计模式

1. 写代码最基本的几个问题
     1.1 命名是否规范
     1.2 代码是否简洁
     1.3 是否有做边缘处理
     1.4 代码的可维护性与可拓展性
     1.5 代码是否易于复用
2. 面向对象设计思维（自己理解）
     把一个复杂的问题拆分成许多独立的小问题分开解决，在最后用创建对象的方式将他们相互建立连接，解决最初的问题，这样当代码需要添加或修改功能时只需要修改相应的代码块即可，降低了我们的工作量。
3. 简单工厂设计思想
     3.1 设计一个接口类，包含最基本的方法
     3.2 设计接口类的具体实现类，实现接口类中的方法，添加自己的功能或特性，一个功能对应一个实现类
     3.3 设计一个类来整合所有的实现类，可通过判断来将相应的类实例化并返回
     3.4 简单工厂设计思想好处：降低了类与类之间的耦合度，这样需要修改功能时只需要修改对应的实现类即可
4. 简单工厂代码实现
   
   
   
   

二、UML类图解析

  5.1 类表示方法：第一层表示类的名称，第二层表示类有什么属性，第三层表示类中包含的方法（+表示public，-表示private，#表示protected）

  5.2 接口表示方法

  5.3 继承关系：空心三角形+实线

  5.4 实现接口：空心三角形+虚线

  5.5 关联关系（一个类中需要创建引用另一个类的对象）：实线箭头

  5.6 聚合关系（A对象可以包含一个或多个B对象，但B对象不是A对象中的一部分）：空心的
  菱形+实线箭头

  5.7 组合关系

  5.8 依赖关系

三、策略模式

1. 策略模式概要：策略模式是一种定义一系列算法的方法，从概念上看，所有这些算法都完成相同的工作，只是实现不同，它可以以相同的方式调用所有算法，减少了各种算法类和使用算法类之间的耦合。
2. 策略模式优点：
     2.1 每个算法都有自己单独的实现类，可以在自己的接口中进行测试
     2.2 策略模式封装了变化（将需要使用的行为封装到一个个Strategy类中，这样可以在使用这些行为的类中消除条件语句）
3. 可以用到策略模式的地方：
   由于策略模式几乎可以封装任何类型的规则，所以只要在分析过程中听到需要在不同的时间使用不同的算法时，就可以考虑策略模式
4. 案例：商场收银系统（需要根据不同的情况调用不同的收费方式）
   
   
   
   
   

5. 小总结：
     5.1 策略模式和简单工厂模式：结构上很相似，但是简单工厂模式是创建性模式，它的作用是创建对象；策略模式是行为模式，它是将不同的算法封装在一个对象中，以实现动态调用算法。
     5.2 应用问题：若需要管理创建不同对象则用工厂模式，若要实现不同算法的动态调用则使用策略模式
     5.3 任何的需求的变化都是需要成本，我们需要做的就是用最小的成本来实现功能的变更

四、开放-封闭原则

0. 解决的问题：
     怎样的设计才能面对需求的改变却可以保持相对稳定，在系统上线后可以不断更新系统？
1. 原则简介：
     软件实体（类、模块、函数等等）应该可以拓展，但是不可以修改
2. 两个特征：
     2.1 对于拓展是开放的（需求变更时修改代码不会很困难）
     2.2 对于更改是封闭的（在修改功能时尽量不要动原有的代码，而是添加新的代码）
3. 如何运用原则：
     3.1 我们在设计程序时要预测最容易产生变化的模块，然后构造抽象来隔离变化。
     3.2 若一开始并不知道哪里会发生变化，则假设变化不会发生，当变化发生时，立即创建抽象来隔离以后的同种变化
     3.3 面对需求，对程序的改动时通过新增代码实现的，而不是修改原有代码
4. 小结
     开放-封闭原则是面向对象设计思想核心所在，遵循这个原则可以使代码可维护、可拓展、可复用，灵活好。但开发人员应仅对程序中呈现频繁变化的那些部分做出抽象，切记不要对每个部分都做出抽象。拒绝不成熟的抽象和抽象本身一样重要！

五、依赖倒转原则

1. 定义：
     1.1 高层模块不应该依赖低层模块，两个都应该依赖抽象（接口）
     1.2 抽象不应该依赖细节，细节应该依赖抽象
2. 里氏代换原则：
     一个软件的实体如果使用的是一个父类的话，那么一定适用于子类，若是把父类替换成子类，程序的行为不会发生改变。即：子类型必须可以替换其父类型
3. 总结：面向接口编程( ╯□╰ )

六、装饰模式

0. 解决的问题：
     当项目需要添加功能时，要向主类添加新的代码和逻辑，这样就会增加主类的复杂度，不符合开放-封闭原则。
1. 定义：
     装饰模式，动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更加灵活
2. 装饰模式优点：
     2.1 能动态的添加新的功能，符合面向对象思维和开放-封闭原则
     2.2 有效的把类的核心职责和装饰功能区分开了，去除了类中重复的逻辑，简化了类
     2.3 客户代码在运行时可以根据需求有选择的、按顺序的使用装饰功能包装对象
3. 装饰模式的应用场景：
     需要为已有功能动态添加新的相似功能时
     注意：装饰模式的装饰顺序很重要！需要自己考虑
4. 装饰模式实现步骤
     4.1 抽象组件：需要装饰的抽象对象(接口或抽象父类)
     4.2 具体组件：需要装饰的对象
     4.3 抽象装饰类：包含了对抽象组件的应用和装饰者共有的方法
     4.4 具体装饰类：被装饰的对象
5. 装饰模式代码实现
   
   
   
   

七、代理模式

1. 定义：
     代理模式，为其它对象提供一种代理以控制对这个对象的访问
2. 代理模式的好处：
     2.1 职责清晰：真实角色就是实现实际的业务逻辑，不必关心其它的事务
     2.2 代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用
     2.3 高拓展性
3. 代理模式实现（静态代理）
     3.1 定义Subject接口类：里面有对应的抽象功能
     3.2 定义ProxySubject类(代理对象)：实现Subject接口，实现相应的代理功能，里面还需要有被代理对象的引用，真实功能由被代理对象实现
     3.3 定义RealSubject类(真实对象)：实现Subject，实现真实功能
4. 代理模式代码实现：

八、工厂方法模式

1. 定义：
     工厂方法模式，定义一个用于创建对象的接口，让子类决定具体事例化哪个类。工厂方法模式使一个类的实例化延迟到它的子类
2. 与简单工厂模式的比较：
     2.1 优点：工厂方法模式中由于延迟了类的实例化，所以无论我们增加多少产品类，都可以通过添加新的工厂来实现，更加符合开放-封闭原则，进一步降低了代码的耦合。
     2.2 缺点：在工厂方法模式中，因为一个产品类对应一个工厂类，所以若是产品很多则会导致需要很多工厂类；在简单工厂模式中，若是想要修改需求，只需要修改工厂类即可，而工厂方法模式则需要修改客户端！
3. 工厂方法模式实现：
     3.1 创建实际类接口
     3.2 创建工厂类接口，里面的方法返回值为实际类对象。
     3.3 创建实际类的实现类
     3.4 创建工厂类的实现类，一个工厂类对应一个实际类
     3.5 客户端根据需求调用相应的工厂类创建对象
4. 工厂方法模式代码实现
   
   
   

九、原型模式

1. 定义：
     原型模式(Prototype)，用原型实例指定创建对象的种类，并且通过拷贝这些对象创建新的对象
2. 原型模式的分类：
     2.1 浅复制：可以正常复制与修改对象中的值类型字段(String,int,Double等普通类型)，但若是存有Object类型的话，则无法正常修改(例子：原型模式复制了一个包含Date属性的对象，若是修改原有对象中Date属性，复制对象中的属性也会被修改)
     2.2 深复制：解决了浅复制的缺点，所有对象都可正常复制修改
3. 原型模式优点：
     当需要创建大量相似对象时，每New一次都需要执行一次构造函数性能不高，而使用原型模式则隐藏了创建细节，而且对性能也有了很大的提高
4. 原型模式应用场景：
     需要创建大量重复对象时
5. 原型模式实现方法（由于浅复制的缺点，这里仅实现深复制）：
     5.1 需要复制的类对象中实现Cloneable接口
     5.2 需要复制的类中的对象属性也要实现Cloneable接口，只有自己创建的类才需要，系统自带的类已经默认实现了Cloneable接口
     5.2 覆写clone方法，直接调用父类(默认为Object类)的super.clone()方法复制对象，对需要复制的属性用this.属性名.clone()调用其clone()方法
6. 原型模式代码实现
   
   

十、模板方法模式

1.定义:
  定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
2. 优点：
  2.1 该模式通过把不变的行为转移到模板方法中，去除了子类中的重复代码
  2.2 当不变与可变的行为在方法的子类实现中混合到一起的时候，不变的行为就会在子类中重复出现。通过模板方法可以把这些行为搬运到单一的地方，帮助子类摆脱了重复的行为
3. 运用场景
  当我们遇到由一系列步骤构成的过程需要执行，而这个过程在大体上是一致的，只有某些特定步骤需要修改，这时就可以考虑模板方法模式（比如做试卷，题目都是一样的，若是每做一次都要抄题则会严重影响效率，这时就可以用模板方法模式，只写答题卡）
4. 模板方法模式实现
  把类定义为抽象类，把类中重复的方法集中到一个模板方法中执行，将需要修改的方法定义为抽象方法（钩子方法），在子类中只需实现钩子方法即可
5. 代码实现

十一、建造者模式

1. 定义：
     将一个复杂对象的创建与它的表示分离，使得同样的构建过程可以创建不同的对象
2. 优点：
     2.1 如果用户用了建造者模式，那么用户只需要指定具体的类型就可以得到它们，不需要知道方法，降低了耦合性
     2.2 建造者模式使得建造代码与表示代码分离，这样若需要改变一个产品的内部表示，只需要再定义一个建造者即可。
3. 使用场景：
     一些基本对象不会变，但其组合会变（如电脑）
4. 模式实现：
     4.1 创建Product(实体)类
     4.2 创建builder接口，里面有构造实体类中组件的方法
     4.3 创建Concretebuilder类，实现builder接口，覆写其中的方法
     4.4 创建Director类，里面有对builder的引用，提供一个方法完成构造并返回对象
5. 代码实现：
   
   
   
   
   

十二、观察者模式

1. 定义：
     定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象。这个主题对象在状态发生变化时，会通知所有的观察者对象，是它们能够更新自己
2. 优点：
     2.1 观察者和被观察者是抽象耦合的
     2.2 建立了一套触发机制
3. 缺点：
     3.1 如果一个被观察对象有许多直接或间接观察对象时，通知可能需要花费大量时间
     3.2 如果观察对象与被观察对象存在依赖关系的话，有可能会互相调用，造成死循环
     3.3 被观察者只能知道观察者发生了变化，而不能知道观察者发生了什么变化
4. 应用场景：
     一个对象发生改变，所有依赖该对象的对象都将得到通知
5. 如何实现：
     5.1 创建Subject(被观察者)类，里面定义一个观察者容器，有相关增删函数，以及一个方法用于用于当状态改变时通知所有观察者
     5.2 创建Observer(观察者接口)，里面定义通知到来时的更新方法（update()）
     5.3 创建ConcreteSubject(观察者实例类)，定义一个属性用于更新通知（如状态码），当调用该属性set方法时，调用父类的通知方法更新观察者
     5.4 创建Observer实现类，里面定义一个与ConcreteSubject中属性相同的属性用于接收，覆写update方法
6. 代码实现：

十三、抽象工厂模式

1. 定义：
     抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式
2. 优点：
     2.1 易于交换产品系列，由于具体工厂类在代码中只出现一次，这就使得改变一个应用的具体工厂十分方便，只需要改变具体工厂就可以使用不同的产品配置
     2.2 它让具体的创建过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂实现分离，不会出现在客户端中
3. 缺点：
     产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码
4. 应用场景：
     系统的产品有多于一个的产品族，而系统只消费其中某一族的产品
5. 如何实现：
     5.1 创建实体类
     5.2 创建实体类工厂，每一个实体类对应一个工厂类
     5.3 创建抽象工厂接口，里面放回需要构造的实体类，一个实体类对应一个方法
     5.4 实现抽象工厂接口，在对应方法中选择调用相应实体类工厂创建产品
6. 代码实现：