下载文档原格式
策略模式简单工厂模式抽象工厂模式策略模式、简单工厂模式和抽象工厂模式是常见的设计模式，用于解决不同的问题和满足不同的设计需求。
下面将分别介绍这三种模式，并进行详细的比较。
策略模式策略模式是一种行为型模式，它将一组特定的算法封装成一个独立的类，使得它们可以相互替换。
应用策略模式的主要目的是让算法的变化独立于使用算法的客户端。
策略模式将算法的定义与算法的使用分离开来，这样可以让算法的定义更加灵活，能够根据需要动态地改变。
简单工厂模式简单工厂模式是一种创建型模式，它由一个工厂类负责创建不同类型的对象。
简单工厂模式的核心思想是将对象的创建过程封装起来，客户端只需要通过一个工厂类的方法来获取所需的对象，而不需要了解创建对象的细节。
简单工厂模式常常使用静态方法来创建对象，这样客户端可以直接通过类名来调用工厂方法。
抽象工厂模式也是一种创建型模式，它提供了一种创建一族相关或相互依赖对象的接口，而不需要指定具体的类。
抽象工厂模式的核心思想是将对象的创建过程封装到一个工厂接口中，具体的工厂类实现这个接口来创建不同的对象。
抽象工厂模式可以用于创建一系列的产品对象，这些产品对象有一定的关联关系。
比较1.目的不同：-策略模式的目的是将一组算法封装起来，使得它们可以相互替换。
-简单工厂模式的目的是封装对象的创建过程，使得客户端只需要通过一个工厂类的方法来获取所需的对象。
-抽象工厂模式的目的是提供一种创建一族相关或相互依赖对象的接口。
2.使用场景不同：-策略模式适用于一组特定的算法需要进行动态切换或扩展的场景。
-简单工厂模式适用于需要根据输入参数来决定创建具体对象的场景。
-抽象工厂模式适用于需要创建一系列相关或相互依赖的对象的场景。
3.灵活性不同：-策略模式的算法可以灵活地添加、删除或替换，客户端可以根据需要动态地选择所需的算法。
-简单工厂模式的创建过程在工厂类中，所以客户端只能通过修改工厂类代码来实现创建对象的变化，不够灵活。
【设计模式-⼯⼚模式】男男⼥⼥的抽象⼯⼚模式背景虽然⼥娲已经成功将⼈类创造出来了，可是都是没有性别的，那么后续该如何繁衍呢。
为此，除了增加⼈种外，我们还需要增加所有⼈类都有的⼀个属性：性别。
由此：⼈种和性别相互组合⽣成6中不同的⼈类男⿊⼈、⼥⿊⼈、男⽩⼈、⼥⽩⼈、男黄⼈、⼥黄⼈原来的⼀个⼋卦炉也需要进⾏修改，变为专门⽣产男性的"男⼋卦炉" 和专门⽣产⼥性的 “⼥⼋卦炉”类图可以看到我们在原有的⼏个⼈种上，⼜重新继承并实现了两个类，分别⽤于表⽰不同⼈种的男⼥特别说明的是HumanFactory接⼝，在这个接⼝中定义了三个⽅法，分别⽤于⽣产不同的肤⾊的⼈种，也就是我们将肤⾊作为Y轴，性别作为X轴，通过X坐标和Y坐标唯⼀确定⼀个⽣产出来的对象。
代码⼈种接⼝public interface Human {//每个⼈种的⽪肤都是不同的颜⾊public void getColor();//每个⼈类都会发声public void talk();public void getSex();}⼈种接⼝即抽象产品，该产品的共同属性定义：肤⾊和语⾔，⽽性别则是不同产品下更深层的细分实现⼈种接⼝的黄种⼈public abstract class AbstractYellowHuman implements Human{@Overridepublic void getColor() {System.out.println("黄种⼈");}@Overridepublic void talk() {System.out.println("国语");}}继承了该接⼝的抽象黄种⼈类，每个抽象类都会实现产品的公共细节，⽽每个抽象类的都会有两个实现类，分别实现各⾃的不同的细节：性别黄种⼈⼥性public class YellowWoman extends AbstractYellowHuman{@Overridepublic void getSex() {System.out.println("YellowWoman");}}⼋卦炉/*** 产品类* 有N个产品组,在抽象⼯⼚类中就应该有N个创建⽅法;* 每个产品有M个产品扩展维度就应该有M个产品实现⼯⼚类,* 在每个实现⼯⼚中,实现不同的产品族的⽣产任务.* @author LiPeng01* @since 2020/8/8 7:31 下午*/public interface HumanFactory {public Human doYellowHuman();public Human doWhiteHuman();public Human doBlackHuman();}在接⼝中我们可以看到 抽象的⼯⼚是可以⽣产出不同肤⾊的⼈种的。
第一种表述简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。
其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。
本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解。
简单工厂简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
不修改代码的话，是无法扩展的。
工厂方法工厂方法是针对每一种产品提供一个工厂类。
通过不同的工厂实例来创建不同的产品实例。
在同一等级结构中，支持增加任意产品。
抽象工厂抽象工厂是应对产品族概念的。
比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
小结★工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式，多层继承或者是单个类都是可以的。
但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
区别简单工厂：用来生产同一等级结构中的任意产品。
（对于增加新的产品，无能为力）工厂模式：用来生产同一等级结构中的固定产品。
（支持增加任意产品）抽象工厂：用来生产不同产品族的全部产品。
（对于增加新的产品，无能为力；支持增加产品族）以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。
所以要根据情况考虑应该使用哪种方法。
第二种表述简单工厂、工厂方法和抽象工厂都是创建型的设计模式。
三者的共同点是：1、都有两种作用不同的类：产品类和工厂类。
其中，工厂类在自己的方法中实例化产品类（即使用new命令生成产品类的对象），并将生成的产品类的对象提供给外部使用。
2、创建的过程，都是类似的：工厂类得到一个标志（可以由程序输入，也可以读取配置文件中的内容），返回一个产品对象。
目录1【装饰模式应用场景举例】 ......................................................................................................... 1 2【策略模式应用场景举例】 ......................................................................................................... 5 3【代理模式应用场景举例】 ......................................................................................................... 8 4【外观模式应用场景举例】 ....................................................................................................... 12 5【抽象工厂模式应用场景举例】 ............................................................................................... 14 6【观察者模式应用场景举例】 ................................................................................................... 22 7【建造者模式应用场景举例】 ................................................................................................... 27 8【原型模式应用场景举例】 ....................................................................................................... 32 9【工厂方法模式应用场景举例】 ............................................................................................... 35 10【模板方法模式应用场景举例】 ............................................................................................. 401【装饰模式应用场景举例】 【 】比如在玩“极品飞车”这款游戏，游戏中有对汽车进行喷涂鸦的功能，而且 这个喷涂鸦是可以覆盖的，并且覆盖的顺序也影响到最后车身的显示效果，假设 现在喷涂鸦具有 2 种样式： （1） 红色火焰 （2） 紫色霞光如果使用“继承父类” 设计这样的功能，那么类图就像如下的这样：从图中可以看到使用继承来实现这种功能，并且是 2 种涂鸦样式，就需要创 建 4 个子类，如果喷涂鸦有 3 种，4 种呢？这种情况就是典型中学课程学习过的 “排列与组合”，那简直就是“Head First 设计模式”书中讲的“类爆炸”。
24种设计模式及案例图标放到了最后⾯思维导图创建型模式⼯⼚模式⼯⼚模式（Factory Pattern）是 Java 中最常⽤的设计模式之⼀。
这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。
在⼯⼚模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。
介绍意图：定义⼀个创建对象的接⼝，让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类，⼯⼚模式使其创建过程延迟到⼦类进⾏。
主要解决：主要解决接⼝选择的问题。
何时使⽤：我们明确地计划不同条件下创建不同实例时。
如何解决：让其⼦类实现⼯⼚接⼝，返回的也是⼀个抽象的产品。
关键代码：创建过程在其⼦类执⾏。
应⽤实例： 1、您需要⼀辆汽车，可以直接从⼯⼚⾥⾯提货，⽽不⽤去管这辆汽车是怎么做出来的，以及这个汽车⾥⾯的具体实现。
2、Hibernate 换数据库只需换⽅⾔和驱动就可以。
优点： 1、⼀个调⽤者想创建⼀个对象，只要知道其名称就可以了。
2、扩展性⾼，如果想增加⼀个产品，只要扩展⼀个⼯⼚类就可以。
3、屏蔽产品的具体实现，调⽤者只关⼼产品的接⼝。
缺点：每次增加⼀个产品时，都需要增加⼀个具体类和对象实现⼯⼚，使得系统中类的个数成倍增加，在⼀定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
这并不是什么好事。
使⽤场景： 1、⽇志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，⽤户可以选择记录⽇志到什么地⽅。
2、数据库访问，当⽤户不知道最后系统采⽤哪⼀类数据库，以及数据库可能有变化时。
3、设计⼀个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现⼀个接⼝。
注意事项：作为⼀种创建类模式，在任何需要⽣成复杂对象的地⽅，都可以使⽤⼯⼚⽅法模式。
有⼀点需要注意的地⽅就是复杂对象适合使⽤⼯⼚模式，⽽简单对象，特别是只需要通过 new 就可以完成创建的对象，⽆需使⽤⼯⼚模式。
⼯⼚模式简介和应⽤场景⼀、简介⼯⼚模式主要是为创建对象提供了接⼝。
⼯⼚模式按照《Java与模式》中的提法分为三类：1. 简单⼯⼚模式(Simple Factory)2. ⼯⼚⽅法模式(Factory Method)3. 抽象⼯⼚模式(Abstract Factory)⼆、简单⼯⼚模式我喜欢吃⾯条，抽象⼀个⾯条基类，(接⼝也可以)，这是产品的抽象类。
public abstract class INoodles {/*** 描述每种⾯条啥样的*/public abstract void desc();}先来⼀份兰州拉⾯（具体的产品类）：public class LzNoodles extends INoodles {@Overridepublic void desc() {System.out.println("兰州拉⾯上海的好贵家⾥才5 6块钱⼀碗");}}程序员加班必备也要吃泡⾯（具体的产品类）：public class PaoNoodles extends INoodles {@Overridepublic void desc() {System.out.println("泡⾯好吃可不要贪杯");}}还有我最爱吃的家乡的⼲扣⾯（具体的产品类）：public class GankouNoodles extends INoodles {@Overridepublic void desc() {System.out.println("还是家⾥的⼲扣⾯好吃 6块⼀碗");}}准备⼯作做完了，我们来到⼀家“简单⾯馆”（简单⼯⼚类），菜单如下：public class SimpleNoodlesFactory {public static final int TYPE_LZ = 1;//兰州拉⾯public static final int TYPE_PM = 2;//泡⾯public static final int TYPE_GK = 3;//⼲扣⾯public static INoodles createNoodles(int type) {switch (type) {case TYPE_LZ:return new LzNoodles();case TYPE_PM:return new PaoNoodles();case TYPE_GK:default:return new GankouNoodles();}}}简单⾯馆就提供三种⾯条（产品），你说你要啥，他就给你啥。
工厂模式的常见应用场景一、什么是工厂模式工厂模式是一种常见的设计模式，它可以将对象的创建和使用分离，使得我们可以在不了解具体实现细节的情况下创建对象。
它将对象的创建交给一个专门的工厂类来完成，这个工厂类负责根据不同的需求创建出不同类型的对象。
二、工厂模式的优点1. 可以降低代码耦合度：将对象创建和使用分离，使得客户端只需要知道产品接口就可以了，而无需知道具体实现细节。
2. 可以提高代码复用性：如果需要创建相似类型的对象，只需要修改工厂类即可。
3. 可以方便地进行单元测试：由于客户端只依赖产品接口而不依赖具体实现类，因此可以方便地进行单元测试。
三、工厂模式的常见应用场景1. JDBC中Connection对象的获取：JDBC中提供了一个DriverManager类来获取数据库连接。
这个类就是一个典型的工厂类，它根据不同类型的数据库驱动程序返回不同类型的Connection对象。
2. 日志框架中Logger对象的获取：日志框架中通常都会提供一个LoggerFactory类来获取Logger对象。
这个类也是一个典型的工厂类，它根据不同的日志实现返回不同类型的Logger对象。
3. Spring框架中Bean对象的获取：Spring框架中采用了IoC（控制反转）和DI（依赖注入）的方式来管理Bean对象。
在Spring中，我们可以通过配置文件或者注解来定义Bean对象，然后由Spring容器来负责创建和管理这些Bean对象。
4. 图形界面编程中控件对象的获取：图形界面编程中通常都会提供一个工厂类来创建控件对象，例如Swing框架中提供了一个JFrame类来创建窗口对象，JPanel类来创建面板对象等。
5. 游戏开发中角色对象的获取：游戏开发中通常都会提供一个工厂类来创建角色对象，例如《魔兽世界》游戏中就有一个CharacterFactory类来创建各种角色。
四、工厂模式的实现方式1. 简单工厂模式：简单工厂模式是一种最简单、最常用的工厂模式。
精益生产案例精益生产（Lean Production）是一种以精益思维为基础的生产管理方法，旨在通过减少浪费、提高效率和质量，实现生产过程的优化。
下面列举10个精益生产案例，以展示其在不同领域的应用和效果。
1. 丰田生产系统（T oyota Production System，简称TPS）是精益生产的典型案例。
TPS通过标准化流程、零库存、及时生产等手段，实现了生产效率和质量的大幅提升。
丰田汽车以其高效、灵活和质量稳定的生产模式成为全球汽车行业的典范。
2. 亚马逊的仓储和物流管理也是一个成功的精益生产案例。
亚马逊通过使用先进的仓储机器人、优化的物流网络和实时数据分析，实现了高效的订单处理和快速的配送服务，提高了客户满意度。
3. 丹麦乐高公司采用精益生产方法，实现了高效的生产和供应链管理。
乐高通过精细的计划、准确的库存控制和灵活的生产调度，保证了产品的高质量和及时交付，同时降低了库存成本。
4. 耐克公司在生产和供应链管理中采用了精益生产的方法。
耐克通过减少生产过程中的浪费、优化供应链和加强与供应商的合作，提高了生产效率和产品质量，同时缩短了产品上市时间。
5. 日本的富士康科技集团（Foxconn）是全球最大的电子制造服务公司之一，也是精益生产的成功案例。
富士康通过引进先进的生产设备、标准化工作流程和持续的员工培训，实现了高效的生产和质量控制，为客户提供高品质的电子产品。
6. 美国的快餐连锁企业麦当劳通过精益生产的方法，实现了订单处理和服务的高效率。
麦当劳通过优化餐厅布局、标准化工作流程和使用先进的点餐系统，提高了订单处理速度和客户满意度。
7. 日本的丸红公司是一家全球知名的物流和供应链管理公司，也是精益生产的典范。
丸红公司通过优化仓储和运输流程、精细的库存管理和实时数据分析，实现了高效的物流运作和准时交货。
8. 德国汽车制造商奔驰公司采用精益生产方法，实现了高质量和高效率的生产。
奔驰通过持续改进生产流程、优化零部件供应和自动化生产线，提高了生产效率和产品质量。
23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。
本文将介绍23种经典的设计模式，并给出它们在实际开发中的应用示例。
通过学习这些设计模式，您将增加对软件设计的理解，并能够更好地解决问题。
创建型设计模式1.工厂方法模式（F a c t o r y M e t h o d）工厂方法模式通过定义一个创建对象的接口，但由子类决定实例化具体类。
这种方法可以延迟实例化过程，具有更高的灵活性和可扩展性。
应用场景：-在一个系统中，希望客户端与具体类的实例化解耦。
-希望通过增加具体类的扩展来增加系统的灵活性。
2.抽象工厂模式（A b s t r a c t F a c t o r y）抽象工厂模式提供一个接口，用于创建相关或依赖对象组。
这种模式将对象的实例化推迟到子类中，从而实现了解耦。
应用场景：-当一个系统独立于其产品的创建、组合和表示时。
-当需要一个系列的相互依赖的对象而无需指定其具体类时。
3.单例模式（S i n gl e t o n）单例模式确保一个类只有一个实例，并提供一个全局访问点。
这种模式常用于控制对资源的访问，例如数据库连接或日志文件。
应用场景：-当需要一个类的唯一实例，并且该实例需要被多个客户端共享时。
-当需要限制系统中特定类的实例数量时。
4.原型模式（P r o to t y p e）原型模式通过复制现有对象来创建新对象。
这种模式对于创建需要消耗大量资源的对象非常有用，可以通过克隆现有对象来提高性能。
应用场景：-当一个系统的某些对象的创建比较昂贵时。
-当需要避免构造函数调用，而直接通过复制现有对象来创建新对象时。
5.建造者模式（B ui l d e r）建造者模式将一个复杂对象的构建过程与其表现分离，使得相同的构建过程可以创建不同的表现。
应用场景：-当想要构建一些复杂对象时，如生成器。
-当需要创建对象的过程具有多个步骤，并且每个步骤都可以按需选择或省略时。
结构型设计模式6.适配器模式（A da p t e r）适配器模式将一个类的接口转换为客户端所期望的另一个接口。
下面就来看一个Demo ，从这个Demo 中看出抽象工厂的优点
先来展现一下具体的类图
上面的类图呢，说明的是有两个具体工厂，一个是Linux 控件的制造，还有一个是Windows 控件的制造，
然后，有两个产品族，一个是WindowsTextBox 和LinuxTextBox 组成的TextBox 产品族，还有一个就是WindowsButton 和LinuxButton 组成的Button 产品族。
下面就来写类了
先来看工厂类吧
namespace AbstractFactory
{
public abstract class AbstractFactory
{
//在抽象工厂中，应该包含所有产品创建的抽象方法
public abstract Button CreateButton(); public abstract TextBox CreateTextBox(); }
}
namespace AbstractFactory
{
public class WindowsFactory:AbstractFactory {
public override Button CreateButton() {
return new WindowsButton();
}
public override TextBox CreateTextBox() {
return new WindowsTextBox();
}
}
}
namespace AbstractFactory
{
public class LinuxFactory:AbstractFactory
{
public override Button CreateButton() {
return new LinuxButton();
}
public override TextBox CreateTextBox() {
return new LinuxTextBox();
}
}
}
下面就给出所有的产品类
namespace AbstractFactory
{
public abstract class Button
{
public abstract void DisplayButton();
}
}
using System;
namespace AbstractFactory
{
class LinuxButton:Button
{
public override void DisplayButton()
{
Console.WriteLine("我的类型是：{0}",
this.GetType().ToString());
}
}
}
using System;
namespace AbstractFactory
{
class WindowsButton : Button
{
public override void DisplayButton()
{
Console.WriteLine("我的类型是：{0}",
this.GetType().ToString());
}
}
}
namespace AbstractFactory
{
public abstract class TextBox
{
public abstract void DisplayTextBox(); }
}
using System;
namespace AbstractFactory
{
class LinuxTextBox : TextBox
{
public override void DisplayTextBox()
{
Console.WriteLine("我的类型是：{0}",
this.GetType().ToString());
}
}
}
using System;
namespace AbstractFactory
{
class WindowsTextBox:TextBox
{
public override void DisplayTextBox()
{
Console.WriteLine("我的类型是：{0}",
this.GetType().ToString());
}
}
}
上面就是整个Demo 的类了，下面就是看一下Main 函数和效果了using System;
using AbstractFactory;
namespace AbstractFactoryTest
{
class Program
{
static void Main(string[] args)
{
AbstractFactory.AbstractFactory factory;
Button button;
TextBox textBox;
//Windows 下操作
factory = new WindowsFactory();
button = factory.CreateButton();
textBox = factory.CreateTextBox();
button.DisplayButton();
textBox.DisplayTextBox();
Console.WriteLine();
//Linux 下操作
factory = new LinuxFactory();
button = factory.CreateButton();
textBox = factory.CreateTextBox();
button.DisplayButton();
textBox.DisplayTextBox();
Console.ReadLine();
}
}
}
从上面Main 函数来看的话，如果你的系统本来是基于Linux 的话，你只需更改一行代码factory = new WindowsFactory();
即可实现将系统更改为Windows ，
抽象工厂在这种情况下是非常有用的，比如，如果要实现后台数据库从Oracle 转换到Sql Server，
则采用抽象工厂的思想实现是最好的。
下面总结一下抽象工厂的优缺点
首先，抽象工厂的话，其可以更加方便的实现交换一个产品系列，
就像上面的Demo 中可以轻易的实现从Linux 上转换为Windows，
同时，客户端代码中依赖的是抽象，而非具体的实现，
但是，抽象工厂也是有缺点的，其实这个缺点也很明显，那就是显得过于臃肿，
上面的Demo 尽管还只有两个产品族，类图就显得有些难看了，
如果产品族一多的话，那么总的类数是成几倍的增加，这样使整个结构变得过于复杂，
类的结构也会变得更为庞大。
尾声
上面呢，接连介绍了简单工厂，工厂方法，抽象工厂，整个工厂模式的介绍就到此告一段落了。
