面向对象设计原则和23个设计模式的笔记
Gof的23种设计模式
Gof的23种设计模式从2005年初听说设计模式，到现在虽然已经8年多了，但GoF的23种模式依然盛行，当然GoF提出这些模式的年代更加久远（1995年）。
在工作的过程中，陆陆续续接触了GoF的大部分模式，我记得在2008年的时候就想总结一下设计模式（最近想做的两件事情），最后因为各种原因也没有完成。
最近这段时间正好是职业空档期，没什么事儿做，就把之前看过的设计模式翻出来整理了一下，于是就有了上面几篇文章。
整理设计模式的过程，也是一个深刻理解面向对象设计的过程。
通过对各个模式的回顾，让我更能够明白前辈们关于面向对象设计提出的各种“最佳实践”，特别是S.O.L.I.D，我觉得在这里再说一次，也不算矫情。
S：单一职责原则（Single Responsibility Principle, SRP），一个类只能有一个原因使其发生改变，即一个类只承担一个职责。
O：开放-封闭原则（Open-Close Principle, OCP），这里指我们的设计应该针对扩展开放，针对修改关闭，即尽量以扩展的方式来维护系统。
L：里氏替换原则（Liskov Subsititution Principle, LSP），它表示我们可以在代码中使用任意子类来替代父类并且程序不受影响，这样可以保证我们使用“继承”并没有破坏父类。
I：接口隔离原则（Interface Segregation Principle, ISP），客户端不应该依赖于它不需要的接口，两个类之间的依赖应该建立在最小接口的基础上。
这条原则的目的是为了让那些使用相同接口的类只需要实现特定必要的一组方法，而不是大量没用的方法。
D：依赖倒置原则（Dependence Inversion Principle, DIP），高层模块不应该依赖于低层模块，两者应该都依赖于抽象；抽象不依赖于细节，而细节应该依赖于抽象。
这里主要是提倡“面向接口”编程，而非“面向实现”编程。
设计模式，从本质上讲，是针对过去某种经验的总结。
面向对象程序设计课堂笔记
面向对象程序设计课堂笔记1.面向对象编程(OOP)的概念：OOP是一种编程范式，其核心思想是将现实世界的事物抽象成类、对象等概念，通过封装、继承、多态等特性来实现代码的复用、可维护性和可扩展性。
2. 类和对象的概念：类是一种抽象的概念，用来描述一类具有相同特征与行为的事物；对象是类的一个具体实例，它具有该类定义的属性和行为。
3. 封装的概念：封装是OOP的一种基本特性，它将数据和行为封装在一个类中，外部无法直接访问类内部的数据，只能通过类提供的公共接口(方法)访问和修改数据。
4. 继承的概念：继承是OOP的一种基本特性，它允许子类继承父类的属性和行为，并可以在此基础上扩展和重写父类的方法。
5. 多态的概念：多态是OOP的一种基本特性，它允许不同的对象对同一消息做出不同的响应，即同一方法在不同对象上的表现形式不同。
6. 接口的概念：接口是一种抽象的概念，用来描述一个类所提供的方法和属性，而不涉及具体的实现细节。
它可以让多个类实现相同的接口，从而提高代码的灵活性和可扩展性。
7. 设计模式的概念：设计模式是一种被广泛应用的编程思想，它提供了一套经验丰富的解决方案来解决常见的软件设计问题，如单例模式、工厂模式、观察者模式等。
8. SOLID原则的概念：SOLID原则是面向对象设计的基本原则，它由5个原则组成，分别是单一职责原则、开闭原则、里式替换原则、接口隔离原则和依赖倒置原则。
这些原则旨在提高代码的可读性、可维护性和可扩展性。
9. UML图的概念：UML图是一种用来描述软件系统结构和行为的标准化图形语言，它包括用例图、类图、时序图、活动图等多种类型，可以帮助开发人员更好地理解和设计软件系统。
10. 实践中的应用：在实际的编程中，需要根据具体的业务需求和设计要求来运用面向对象的思想和技术进行程序设计。
同时，也需要不断学习和掌握新的技术和工具，以提高自己的编程能力和水平。
23种设计模式知识要点
多个工厂类： 每个人种（具体的产品类）都对应了一个创建者，每个创建者独立负责创建对应的 产品对象，非常符合单一职责原则
代替单例模式： 单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内 存中生产一个对象
延迟初始化： ProductFactory 负责产品类对象的创建工作，并且通过 prMap 变量产生一个缓 存，对需要再次被重用的对象保留
使用场景：jdbc 连接数据库，硬件访问，降低对象的产生和销毁
3.抽象工厂模式（Abstract Factory Pattern）
定义：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供 一个接口，而且无须指定它们的具体类。） 抽象工厂模式通用类图：
private static final Singleton singleton = new Singleton(); //限制产生多个对象
private Singleton(){ } //通过该方法获得实例对象 public static Singleton getSingleton(){
return singleton; } //类中其他方法，尽量是 static publห้องสมุดไป่ตู้c static void doSomething(){ } }
1.单例模式（Singleton Pattern）
定义：Ensure a class has only one instance, and provide a global point of access to it.（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实 例。）
面向对象设计模式与设计原则(全)
设计模式Design Pattern面向对象研究的新领域起源Gof (Gang Of Four，“四人帮”)设计模式什么叫模式？设计模式：研究现状设计模式的研究现状模式的分类(gof提出的23个)类Factory Method Adapter (类)InterpreterTemplate Method对象Abstract FactoryBuilderPrototypeSingletonAdapter (对象)BridgeCompositeDecoratorFacadeFlyweightProxyChain of ResponsibilityCommandIteratorMediatorMementoObserverStateStrategyVisitor模式Bridge(桥梁)案例最初的设计需求变化：鸟类要会飞如果增加一种鸟类“企鹅”呢？改进方法：对“飞”使用多态改进方法：再次使用继承如果增加“游泳”行为呢？继承只会使得问题越来越复杂继承是面向对象的基本法宝啊？？设计原则1：组合优先继承复用的优点继承复用的缺点优点组合复用的点组合复用的缺组合优先例1：如果使用继承来描述：使用“组合”思路考虑问题响区分“Is-A”与“Has-A”问题换一个角度看问题是什么导致设计的不完美？设计者的理想设计原则2：封装可变性“发现变化点”“封装变化点”“封装变化点”“封装变化点”“使变化点和不变点独立开来”“鸟类”和“行为”什么关系？拥有鸟儿拥有飞、游泳的行为使用桥梁模式的效果增加增加增加原有代码不需要改动！使用桥梁模式的效果设计原则3：开-闭原则结构意图适用性应用举例1：“小朋友画画”蜡笔和毛笔的差别体现了Bridge模式应用举例2传统的设计Draw()Draw()Draw()应用Bridge 模式DrawLine()DrawCircle()DrawLine()DrawCircle()Draw()Draw()Draw()DrawLine()DrawCircle()分析设计原则：开-闭原则、封装可变性“开-闭”原则解释设计原则：开-闭原则、封装可变性Bertrand Meyer设计原则：开-闭原则、封装可变性玉帝遵照“开-闭”原则维护天庭秩序设计原则：开-闭原则、封装可变性分析设计原则：开-闭原则、封装可变性分析设计原则：开-闭原则、封装可变性“封装可变性原则”。
软件设计师的面向对象设计和设计模式
软件设计师的面向对象设计和设计模式在软件开发领域，面向对象设计和设计模式是软件设计师必备的核心知识。
面向对象设计是一种以对象为核心的设计思想，强调将系统的功能模块划分为独立的对象，并通过对象之间的交互实现系统的整体功能。
而设计模式则是针对常见问题的解决方案，通过提供经过实践验证的设计方法来解决软件开发中的复杂性。
一、面向对象设计的基本原则面向对象设计的基本原则有四个：单一职责原则、开放封闭原则、里氏替换原则和依赖倒置原则。
1. 单一职责原则：一个类只应该有一个单一的功能或职责。
这样可以确保类的职责清晰明确，降低代码复杂度，提高代码的可维护性。
2. 开放封闭原则：软件实体应该是可扩展的，但是不可修改的。
通过对扩展进行开放，对修改进行封闭，可以实现代码的复用性和可维护性。
3. 里氏替换原则：子类对象应该能够替换父类对象，并且保持程序的逻辑行为不发生变化。
这样可以保证系统的稳定性和灵活性。
4. 依赖倒置原则：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。
通过依赖倒置可以减少模块间的耦合性，提高代码的可拓展性。
二、常用的设计模式1. 创建型设计模式创建型设计模式包括：Singleton（单例模式）、Factory Method（工厂方法模式）、Abstract Factory（抽象工厂模式）、Builder（建造者模式）、Prototype（原型模式）等。
这些模式主要用于对象的创建，根据实际需求选择合适的创建型模式，可以提高系统的灵活性和可维护性。
2. 结构型设计模式结构型设计模式包括：Adapter（适配器模式）、Bridge（桥接模式）、Composite（组合模式）、Decorator（装饰者模式）、Facade （外观模式）、Proxy（代理模式）等。
这些模式主要用于对象的组合和组织，通过结构型模式可以实现系统的灵活性和可扩展性。
3. 行为型设计模式行为型设计模式包括：Observer（观察者模式）、Strategy（策略模式）、Template Method（模板方法模式）、Command（命令模式）、State（状态模式）等。
面向对象程序设计听课笔记
面向对象程序设计听课笔记一、面向对象程序设计基本概念1.1 什么是面向对象程序设计面向对象程序设计是一种程序设计方法，它以对象为中心，将系统看作一组对象的集合，对象之间通过消息传递进行通信和合作。
面向对象程序设计强调抽象、封装、继承和多态等概念，从而使得程序更易于维护、扩展和重用。
1.2 面向对象程序设计的特征面向对象程序设计具有以下特征：- 封装：将数据和相关的操作封装到对象中，隐藏内部实现细节，提供统一的接口。
- 继承：通过继承机制，可以将已有的类的属性和方法继承到新的类中，并在此基础上进行扩展。
- 多态：同一个方法在不同对象中有不同的行为，使得代码更灵活、可复用。
1.3 面向对象程序设计的优点面向对象程序设计具有以下优点：- 代码重用：通过继承和多态等特性，可以提高代码的重用率，降低开发成本。
- 可维护性：封装性使得内部实现对外部不可见，可以减少代码耦合，使系统更易于维护。
- 扩展性：通过继承和多态，系统可以更容易地进行功能扩展，适应需求变化。
- 抽象性：面向对象程序设计可以更好地进行问题领域的建模，提高系统的抽象能力。
二、面向对象程序设计的基本原则和模式2.1 单一职责原则单一职责原则要求一个类应该只有一个引起变化的原因，即一个类应该只负责一个职责。
这样可以降低类的复杂度，提高代码的易读性和可维护性。
2.2 开放-封闭原则开放-封闭原则要求软件实体应该对扩展开放，对修改封闭。
即当需求变化时，不应该修改原有的代码，而是通过扩展来实现功能的变化。
2.3 里氏替换原则里氏替换原则要求在一个系统中，子类型必须能够替换掉它们的基类型而不改变系统的任何属性。
这意味着继承关系应该是合理的、可靠的。
2.4 接口隔离原则接口隔离原则要求一个类对另一个类的依赖应该建立在最小的接口上。
这样可以降低依赖关系的耦合度，提高系统的灵活性和可维护性。
2.5 依赖倒置原则依赖倒置原则要求高层模块不应该依赖于低层模块，二者都应该依赖于抽象。
23种设计模式 详解
23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。
这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。
目前，常用的设计模式有23种。
下面，我们来详细介绍一下这23种设计模式。
1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。
在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。
2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。
它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。
3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。
它可以生成一系列相关或相互依赖的对象实例。
具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。
4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。
它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。
5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。
一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。
6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。
具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。
7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。
具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。
8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。
面向对象23种设计模式系列（一）-创建型设计模式
面向对象23种设计模式系列（一）-创建型设计模式本章是面向对象23种设计模式系列开篇，首先我们来看下什么是设计模式？面向对象23种设计模式：1、面向对象语言开发过程中，遇到的种种场景和问题，提出了解决方案和思路，沉淀下来就变成了设计模式。
2、解决具体问题的具体招数---套路---站在前辈的肩膀上。
3、没有什么设计模式是完美无缺的，一种设计模式就是解决一类问题，通常设计模式在解决一类问题的同时，还会带来别的问题，我们设计者要做的事儿，就是要扬长避短，充分发挥长处！设计模式可以大概分为三大类：1、创建型设计模式：关注对象的创建。
2、结构型设计模式：关注类与类之间的关系。
3、行为型设计模式：关注对象和行为的分离。
我们要做的就是学习核心套路，这里就不做过多的描述，如果有机会会通过具体例子再和大家分享。
下面我们正式进入本章主题。
创建型设计模式：关注对象的创建。
（5个）1、单例模式（Singleton Pattern）单例模式：就是限制了对象的创建，重用了对象。
保证进程中，某个类只有一个实例。
即使是单例，变量也不是线程安全的，单例不是为了保证线程安全。
单例的好处就是单例，就是全局唯一的一个实例。
应对一些特殊情况，比如数据库连接池(内置了资源) ，全局唯一号码生成器。
单例可以避免重复创建，但是也会常驻内存，除非是真的有必要，否则就不要使用单例。
1.1、单例模式经典写法（懒汉式）using System;using System.Threading;namespace Singleton Pattern{/// <summary>/// 懒汉式单例模式（经典写法）/// 单例类：一个构造对象很耗时耗资源类型。
/// </summary>public class Singleton{/// <summary>/// 构造函数耗时耗资源/// </summary>private Singleton(){long lResult = 0;for (int i = 0; i < 10000000; i++){lResult += i;}Thread.Sleep(2000);Console.WriteLine("{0}被构造一次", this.GetType().Name);}/// <summary>/// 全局唯一静态重用这个变量/// volatile 促进线程安全让线程按顺序操作/// </summary>private static volatile Singleton _singleton = nul l;/// <summary>/// 引用类型对象/// </summary>private static readonly object lockSingleton = n ew object();/// <summary>/// 公开的静态方法提供对象实例/// </summary>/// <returns>/// </returns>public static Singlet on CreateInstance(){if (_singleton == null) //_singleton已经被初始化之后，就不要进入锁等待了 {//保证任意时刻只有一个线程进入lock范围//也限制了并发，尤其是_singleton已经被初始化之后，故使用了双if 来解决并发限制问题lock (lockSingleton){//Thread.Sleep(1000);//Console.WriteLine("等待锁1s之后才继续。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1 面向对象设计原则和23个 设计模式的笔记 面向对象三大特点： ---------------------------------- 封装： ------------------ 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
不关注处理过程了，只有对象和其职能。 只允许设定的对象访问自身信息，其余私人信息隐藏。 作用：封装可以隐藏实现细节，使得代码模块化，局域化，简单；
继承： ------------------ 继承的父类最好是接口，最好连属性都没有。 少用实现继承（库内使用较多），多用组合。 忘了多重继承，除非实现多接口。 作用：扩展已有代码模块；代码重用（库内使用较多），多态的基础
多态： ------------------ 静态--编程时采用父类型-针对接口编程 2
动态--执行时才实际映射成具体的子类 作用：静态时针对接口编程，执行时才体现实际的效果
面向对象设计原则： ------------------------------------ 单一职责原则（SRP）： ------------------ 就一个类而言，应该仅有一个引起它变化的原因；当职责越多，耦合越多，易遭破坏 软件设计真正要做的就是发现职责并将这些职责相互分离 把职责分离到单独的类中,因为每一个类都是变化的轴线，当需求变化时,该变化会反映为类的职责的变化，如果一个类承担了多余一个的职责,那么引起他变化的原因就会有多个。职责定义为“变化的原因”。
如果一个类承担的职责过多,就等于把这些职责耦合在了一起,一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力，这种耦合会导致脆弱的设计，当变化发生时，设计会受到意想不到的破坏。
另一方面，如果应用程序的变化方式总是导致这两个职责同时变化，那么就不必分离它们，实际分离它们就会导致不必要的复杂性的臭味。
SRP是所有原则中最简单的也是最难以正确应用的原则之一。
开放封闭原则： ------------------ 软件实体应该可以扩展，但是不可修改。 软件要容易维护又不容易出问题的最好方法是多扩展，少修改。 无论模块多么封闭，都会有无法封闭的变化，事先构造抽象隔离这些变化。 面对新需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码。 3
OCP的关键是抽象，对于代码的改动是通过增加新代码进行的，而不是更改现有代码，因此他就不会引起像不遵循OCP原则那样的连锁改动。
通常，我们更愿意一直等到确实需要那些抽象时再把他放进去，“我们愿意被第一颗子弹射中，但是我们不会再被同一支枪射得其他子弹射中”。
可以按照以下的一些方法完成这项工作: 我们首先编写测试.测试描绘了系统的一种使用方法,通过首先编写测试,我们迫使系统成为可测试的,在一个具有可测试的.在一个具有可测试性的系统中发生变化时,我们可以坦然对之,因为我们已经构建了使用系统可测试的抽象,并且通常这些抽象中的许多都会隔离以后发生的其他种类的变化.
在许多方面,OCP都是面向对象设计的核心所在,遵循这个原则可以带来面向对象技术所声称的巨大好处(灵活,可重用,可维护性),然而,并不是说只要使用一种面向对象的语言就是遵循了这个原则,对于程序中的每个部分都肆意进行抽象同样不是一个好主意,正确的做法是,开发人员应该仅仅对程序中呈现出频繁变化的那部分作出抽象.拒绝不成熟的抽象和抽象本身一样重要.
依赖倒转原则 ------------------ 高层模块不应该依赖低层模块，两个都应该依赖于抽象 抽象不应该依赖于细节，细节应该依赖于抽象 即要针对接口编程，不要对实现编程 本应该是高层的策略设置模块去影响低层细节实现的模块的，包含高层业务规则的模块应该优先并独立于包含实现细节的模块，无论如何高层模块都不应该依赖于低层模块。
我们更希望能够重用的是高层策略模块，如果高层模块独立于底层模块，那么高层模块就能更容易的被重用，该原则是框架的设计核心原则。
所有结构良好的面向对象的架构都具有清晰的层次定义，每个层次通过一个定义良好的、受控制的接口向外提供一组内聚的服务。
每个较高的层次都为它所需要服务声明一个抽象接口，较低层次实现了这些抽象接口，每个高层类都通过接口使用下一层，这样高层就不依赖于低层。低层反而依赖于在高层中声明的抽象服务接口。
这种倒置不仅仅是依赖关系的倒置。它也是接口所有权的倒置。 依赖倒置可以应用于任何一个类向另一个类发送消息的地方。 4
违反DIP，高层策略没有和底层实现分离，抽象没有和具体细节分离，没有这种分离，高层策略就自动的依赖于低层模块，抽象就自动的依赖于具体细节。
里氏代换原则（LSP） ------------------ 子类型必须替换掉它们的父类型。 适用于父类的一定适用于子类 LSP让我们得到一个非常重要的结论:一个模型，如果孤立的看，并不具有真正意义上的有效性，模型的有效性必须通过他的客户程序来表现。
如果一组类都支持一个公共的职责，那么它们就应该从一个公共的超类继承该职责。如果公共的超类还不存在，那么就创建一个，并把公共的职责放入其中，毕竟这样一个类的有用性是确定无疑的。
有一些简单的启发规则可以提供一些有关违反LSP的提示，这些规则都和以某种方式从其基类中去除某功能的派生类有关，完成的功能少于其基类的派生类通常是不能替换其基类的，因此就违反了LSP。
另外一种违反LSP的规则形式是在派生类的方法中添加了其基类不会抛出的异常，如果基类的使用者不期望这些异常，那么把它们添加到派生类的方法中就会导致不可替代性，此时要遵循LSP，要么就必须改变使用者的期望，要么派生类就不应该抛出这些异常。
OCP是OOD中很多说法的核心。如果这个原则应用的有效，应用程序就会具有更多的可维护性，可重用性以及健壮性，LSP是使用OCP成为可能的主要原则之一。
迪米特法则（LoD） ------------------ 如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。
法则强调类之间的松耦合。
接口隔离原则ISP ------------------ 5
这个原则用来处理“胖”接口所具有的缺点。如果类的接口不是内聚的，就表示该类具有胖的接口。换句话说，类的胖接口可以分解成多组方法，每一组方法服务于一组不同的客户端程序。
不应该强迫客户依赖于它们不用的方法。 如果一个客户端程序依赖于一个含有它不使用的方法的类，但其他客户端缺要使用该方法，那当其他客户端对这个类改变时，就会影响到这个类。
创建模式 ---------------------------------- 抽象工厂模式（Abstract Factory） 提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。 ################################ 一个抽象工厂多个方法，每个方法创建一个（抽象）对象； 不同工厂实例可得到不同风格对象集； -----优缺点----- 创建操作和实际的产品对象集都独立出来 更换产品对象集很方便 接口已定义好能创建的集中对象个数，难扩展--通过参数传入创建不同类（返回对象类型很难定，需要向下类型转换不安全）
-----关联----- 具体的工厂通常是单件 通常用工厂方法或原型来实现抽象工厂中的各方法
建造者模式（Builder） 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 ################################ 6
定义一个有创建各子部件方法（不返回）和返回组合好的父部件的接口，从而封装内部子对象创建的细节
实现子类，以不同的创建方式实现这些方法，每个子类就是一种创建子部分方法 外部通过创建导向器Director配置创建子部件的方式（顺序和约束），并得到组合好的父部件。 最终产品不需要是抽象类，直接具体的复合类即可 -----关联----- Builder着重于一步步创建复杂对象，最后返回 Abstract Factory创建一系列多个对象，创建一个返回一个 Composite通常是用Builder生成的
工厂方法模式（Factory Method） 定义一个用于创建对象的接口，让子类决定实例化哪一个类。 ################################ 一个接口一个方法创建一个抽象对象，子类确定实现那个具体类。 通过传入参数生成不同对象避免为已确定的类型生成不同子类（写在父类中） -----关联----- 通常在Template Method中被调用
原型模式（Prototype） 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 ################################ 用来Clone一个自身的对象，包含一个Clone的操作。 从一个对象再创建另外一个可定制的对象，而不需要知道任何创建的细节。 注意Clone过程中的浅拷贝和深拷贝的问题 -----优缺点-----