工厂方法模式(讲)
Python中的工厂模式
Python中的工厂模式工厂模式（Factory Pattern）是一种常用的设计模式，用于创建对象。
它属于创建型模式，通过定义一个工厂类负责创建其他对象的实例，而不必直接使用new关键字来创建对象。
工厂模式使得代码的可拓展性和复用性更好，同时也隐藏了对象的创建和实现细节，简化了客户端的操作。
工厂模式的核心思想是将对象的实例化操作封装起来，让客户端只需调用工厂方法即可创建所需的对象。
从而达到降低系统耦合度的目的。
工厂模式的实现方式有两种：一种是通过一个单独的工厂类来创建所需的对象，另一种是通过将工厂方法定义在需要创建对象的类中。
其中，单独的工厂类又可以分为简单工厂和工厂方法两种模式。
1.简单工厂模式简单工厂模式（Simple Factory Pattern），也叫静态工厂模式，由一个工厂类负责创建所有需要的产品类的实例。
客户端只需向该工厂类传递相应的参数，即可获取所需的对象。
该模式下，工厂类通常是一个静态类或者包含一个静态方法的类。
简单工厂模式的代码结构如下：```class Product:def __init__(self):passclass ProductA(Product):def __init__(self):print("Product A")class ProductB(Product):def __init__(self):print("Product B")class SimpleFactory:def create_product(self, product_type):if product_type == "A":return ProductA()elif product_type == "B":return ProductB()factory = SimpleFactory()productA = factory.create_product("A")productB = factory.create_product("B")```该代码中，类Product、ProductA、ProductB分别为抽象产品类、具体产品类。
面向对象23种设计模式
面向对象23种设计模式面向对象23种设计模式在面向对象的编程中，设计模式是一种解决问题的通用方案。
设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并提高代码的可维护性和可重用性。
本文将介绍23种面向对象的设计模式。
1. 工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。
在工厂方法模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
2. 抽象工厂模式抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
在抽象工厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
3. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局点。
4. 原型模式原型模式是一种创建型设计模式，它允许复制或克隆一个现有的对象，而不必知道其具体实现。
5. 建造者模式建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。
6. 适配器模式适配器模式是一种结构型设计模式，它将一个或多个不兼容的类或接口转换为客户端所需的接口。
7. 桥接模式桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。
8. 组合模式组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。
9. 装饰器模式装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。
10. 外观模式外观模式是一种结构型设计模式，它为一组复杂的子系统提供了一个统一的接口，以便于客户端使用。
11. 享元模式享元模式是一种结构型设计模式，它利用共享技术来最小化内存使用，以及提高应用程序的性能。
12. 代理模式代理模式是一种结构型设计模式，它提供了一个代理对象，使得客户端可以通过代理对象间接地访问实际对象。
工厂方法模式的优点和缺点
工厂方法模式的优点和缺点工厂方法模式是一种常用的设计模式，在软件开发中被广泛应用。
它提供了一种灵活、可扩展的方式来创建对象，使得代码更加可维护、可测试。
本文将讨论工厂方法模式的优点和缺点，以帮助读者了解该模式的应用场景和适用性。
一、优点1. 符合开闭原则工厂方法模式符合开闭原则，即对扩展开放，对修改关闭。
通过该模式，我们可以在需要新增产品时，添加新的工厂类和产品类，而不需要修改现有的代码。
因此，该模式可以有效地降低程序的耦合度，增加代码的灵活性和可维护性。
2. 降低代码复杂度工厂方法模式通过将对象的创建过程封装在一个工厂类中，使得客户端无需关心对象的具体创建过程。
这样可以大大降低客户端的代码复杂度，使得客户端代码更加简洁、易读、易于维护。
3. 可以在运行时动态创建对象工厂方法模式可以在运行时动态创建对象，与静态工厂方法不同。
静态工厂方法在编译时就已经确定了要创建哪些对象，而工厂方法模式则可以根据运行时的条件来动态地创建对象，更加灵活。
4. 可以实现多态工厂方法模式中，工厂类和产品类都是抽象的，可以有多个不同的实现。
这使得工厂方法模式具有良好的可扩展性和可维护性，可以灵活组合不同的对象，实现多态性。
二、缺点1. 增加了系统的复杂性工厂方法模式需要增加额外的类和接口来实现，增加了系统的复杂性。
如果系统中只有一个产品等级结构，使用该模式可能会过于复杂，不易于理解和维护，此时可以直接使用简单工厂模式。
2. 增加了系统的抽象性工厂方法模式通过增加工厂类和抽象产品类的抽象性，降低了客户端与具体产品类之间的耦合度。
但是，它也增加了系统的抽象性，使得代码不易于理解和维护。
此时可以适当地使用简单工厂模式或抽象工厂模式。
3. 可能会导致系统性能下降工厂方法模式的实现需要通过反射等技术来动态创建对象，这可能会导致系统的性能下降。
此时可以使用静态工厂方法或单例模式来提高系统的性能。
4. 对开发人员的要求较高工厂方法模式需要开发人员掌握较高的抽象能力和设计能力，否则容易出现错误或不合理的设计。
工厂管理方法模式结构介绍PPT(共35页)
工厂方法模式
模式分析
✓ 修改后的客户类代码片段：
PayMethodFactory factory; AbstractPay payMethod; factory=(PayMethodFactory)XMLUtil.getBean(); //getBean()的返回类型 为Object，此处需要进行强制类型转换 payMethod =factory.getPayMethod(); payMethod.pay();
DatabaseLogFactory
+ createLog () : Log ...
<<create>>
...... return new DatabaseLog();
FileLog
+ writeLog () : void ...
<<create>>
DatabaseLog
+ writeLog () : void ...
工厂方法模式
模式实例与Байду номын сангаас析
✓ 实例一：电视机工厂
• 将原有的工厂进行分割，为每种品牌的电视机提供一个子工厂， 海尔工厂专门负责生产海尔电视机，海信工厂专门负责生产海 信电视机，如果需要生产TCL电视机或创维电视机，只需要对应 增加一个新的TCL工厂或创维工厂即可，原有的工厂无须做任何 修改，使得整个系统具有更加的灵活性和可扩展性。
工厂方法模式
Client
模式实例与解析
✓ 实例一：电视机工厂
TVFactory
+ produceTV () : TV ...
TV
+ play () : void ...
HaierTVFactory + produceTV () : TV
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别简单工厂、工厂方法、抽象工厂以及策略模式在软件开发中都是常用的设计模式，它们都是为了解决不同对象的创建和使用问题。
下面将对它们进行详细的介绍，并比较它们之间的区别。
1. 简单工厂模式（Simple Factory Pattern）：简单工厂模式是由一个工厂类根据传入的参数决定创建哪种产品的设计模式。
它包含三个角色：工厂类负责创建产品，产品类定义产品的具体实现，客户端通过工厂类获取产品对象。
简单工厂模式将对象的创建与使用进行了分离，增加了灵活性，但是违反了开闭原则，因为每次新增产品都需要修改工厂类。
2. 工厂方法模式（Factory Method Pattern）：工厂方法模式是指定义一个创建产品对象的接口，但是由子类决定实例化哪个类。
这样可以将产品的实例化延迟到子类中进行，满足了开闭原则。
工厂方法模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
具体工厂类负责创建具体产品类的实例，抽象产品类定义了产品的接口。
客户端通过抽象工厂类获取产品对象。
工厂方法模式解决了简单工厂模式的缺点，但是增加了类的个数。
3. 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式是指提供一个创建一系列相关或互相依赖对象的接口，而无需指定具体的类。
抽象工厂模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
抽象工厂类定义了创建产品的接口，具体工厂类负责创建具体产品。
抽象产品类定义了产品的接口，具体产品类实现了产品的具体实现。
客户端通过抽象工厂类获取产品对象。
抽象工厂模式提供了一种创建一系列产品对象的方法，但是增加新产品时需要修改所有的工厂类。
4. 策略模式（Strategy Pattern）：策略模式是指定义了一系列的算法，并将每个算法封装起来，使得它们可以互相替换，使得算法的选择和使用可以独立于客户端。
策略模式由抽象策略类、具体策略类和环境类组成。
工厂（工厂方法）模式实现多数据库的连接
⼯⼚（⼯⼚⽅法）模式实现多数据库的连接以前⽼听别⼈说多数据库的连接应当⽤⼯⼚模式处理，当时感觉神秘，没有深究，在学习了⼯⼚模式后，⽼感觉不对，⼯⼚模式（我开始认为是抽象⼯⼚模式）不是创建产品系列的嘛，也就是创建对象的嘛，多数据库哪有需要创建产品系列，也就是对象的系列，后来想想了感觉⽤⼯⼚⽅法还是⽐较合适的，今天从⽹上搜索，果然在这⾥⼤家所说的⼯⼚模式指的是⼯⼚⽅法模式。
在这⾥⼤概讲⼀下。
1. ⾸先定义抽象⼯⼚，创建产品，在这⾥是数据库连接的实例。
在此可以例如public abstract class DatabaseFactory{public AbstractDatabase Create;}}2.然后定义具体⼯⼚，实现创建⽅法，具体⼯⼚创建具体产品。
⽬前只写 oracle的public class OracleFactory:DatabaseFactory{public override AbstractDatabase Create(){//to do}}3.⾸先定义抽象产品，描述都需要什么⽅法或属性，⼀般就是创建连接，打开连接，执⾏sql，查询结果，返回dataset、或dataTable，事务的操作，关闭连接等，可以根据你的需要。
⽬前实例如下Code4.然后定义具体产品，可以有sqlserver、oracle什么的，继承抽象⼯⼚，实现抽象⼯⼚的⽅法或属性。
然后定义确定使⽤哪种具体产品的⽅法，⽬前写了不再例举。
5.定义决定使⽤哪个⼯⼚的控制类，控制⽅式可以使⽤传字符串的⽅式，或者读配置⽂件，或者其他⽅式，推荐配置⽂件，容易修改，灵活。
可以采⽤反射的形式，也可以不⽤。
推荐反射，灵活获得以插件式的灵活性。
在此不写代码了。
思路如此，⼀切根据实际情况灵活运⽤，上⾯写的没有经过实验，都是构思过程，可能有谬误的地⽅，欢迎⼤家拍砖，呵呵。
后记：现在感觉不⽤⼯⼚⽅法也可以，反⽽有些⿇烦，其实⽤简单⼯⼚就⾏，就是由抽象产品和具体产品，然后有⼀个⽣产产品的⽅法（可以使⽤⼯⼚⾥的create）就可以。
工厂方法模式的缺点
工厂方法模式的缺点工厂方法模式是一种创建型设计模式，它通过定义一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法使得一个类的实例化延迟到了子类。
工厂方法模式的优点非常明显，它可以提供一种灵活的方式来创建对象，解除了客户端与具体产品的依赖关系，增加了代码的可扩展性和可维护性。
然而，工厂方法模式并不是没有缺点的，它也存在一些局限性和缺点。
下面将会详细介绍工厂方法模式的缺点。
1. 类的数量增加：工厂方法模式的核心是定义一个创建对象的接口，每个具体的产品都有一个对应的工厂类来创建它。
这就意味着如果要创建多个具体产品，就需要相应数量的工厂类。
随着具体产品数量的增加，工厂类的数量也会增加，导致类的数量增多。
2. 增加系统复杂度：由于工厂方法模式需要定义多个工厂类，所以增加了系统的复杂度。
在实际使用过程中，如果每个具体产品由一个对应的工厂类来创建，那么工厂类将会变得非常多，对于系统的设计和维护都会带来很多困扰。
3. 增加代码量：工厂方法模式需要定义抽象工厂类和抽象产品类，并且每个具体产品都需要一个对应的具体工厂类和具体产品类。
这就导致了代码的数量增加，增加了开发量和维护成本。
4. 不符合开闭原则：工厂方法模式在添加新产品时，需要新增具体产品类和对应的具体工厂类。
这就违背了开闭原则，对于已有代码的修改会对系统稳定性造成一定的影响，需要进行大量的修改和测试。
5. 运行效率低：由于工厂方法模式每次都需要通过具体工厂类来创建具体产品类的实例，这就需要实例化具体工厂类和具体产品类。
在系统运行时，可能需要频繁地创建多个具体工厂类和具体产品类的实例，这就会影响系统的运行效率。
6. 需要预先知道所有的具体产品类：在使用工厂方法模式时，需要预先知道所有的具体产品类。
如果要增加新的产品，就必须要修改客户端代码，违背了开闭原则。
如果希望动态地添加新的产品，就需要使用其他的设计模式，如抽象工厂模式。
7. 与依赖倒置原则的冲突：工厂方法模式依赖于具体工厂类来创建具体产品类的实例，在客户端代码中需要使用具体工厂类来创建具体产品类的对象。
设计模式(简单工厂,工厂方法,抽象工厂)区别
第一种表述简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。
其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。
本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解。
简单工厂简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
不修改代码的话，是无法扩展的。
工厂方法工厂方法是针对每一种产品提供一个工厂类。
通过不同的工厂实例来创建不同的产品实例。
在同一等级结构中，支持增加任意产品。
抽象工厂抽象工厂是应对产品族概念的。
比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
小结★工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式，多层继承或者是单个类都是可以的。
但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
区别简单工厂：用来生产同一等级结构中的任意产品。
（对于增加新的产品，无能为力）工厂模式：用来生产同一等级结构中的固定产品。
（支持增加任意产品）抽象工厂：用来生产不同产品族的全部产品。
（对于增加新的产品，无能为力；支持增加产品族）以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。
所以要根据情况考虑应该使用哪种方法。
第二种表述简单工厂、工厂方法和抽象工厂都是创建型的设计模式。
三者的共同点是：1、都有两种作用不同的类：产品类和工厂类。
其中，工厂类在自己的方法中实例化产品类（即使用new命令生成产品类的对象），并将生成的产品类的对象提供给外部使用。
2、创建的过程，都是类似的：工厂类得到一个标志（可以由程序输入，也可以读取配置文件中的内容），返回一个产品对象。
简单工厂 工厂方法
简单工厂工厂方法
简单工厂模式和工厂方法模式是两种不同的设计模式，它们在实现方式和适用场景上有所区别。
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
简单工厂模式适用于工厂负责的对象比较少，且客户只关心传入工厂的参数，而不关心如何创建对象的情况。
工厂方法模式定义了一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
这种模式的优点是核心类成为抽象工厂角色，不再负责产品的创建，仅负责具体工厂子类必须实现的接口，使得系统在不修改具体工厂角色的情况下引进新的产品。
工厂方法模式适用于具体工厂角色和抽象工厂角色分离的情况，使得系统更加灵活和可扩展。
总的来说，简单工厂和工厂方法都是创建型设计模式，用于处理对象的创建问题。
但简单工厂模式是一种更简单、直接的对象创建方式，而工厂方法模式则更加强调抽象和多态的应用，使系统更加灵活和可扩展。
在实际应用中，可以根据需要选择合适的设计模式。
设计模式之工厂模式（3种）详解及代码示例
设计模式之⼯⼚模式（3种）详解及代码⽰例 ⼯⼚模式划分来说总共有三类：简单⼯⼚模式、⼯⼚⽅法模式和抽象⼯⼚模式。
其中简单⼯⼚模式不输⼊23种设计模式之⼀，但他们⼜都属于创建型模式。
我们依次讲解这三种⼯⼚模式。
⼀、简单⼯⼚ 1、什么是简单⼯⼚模式？ ⾸先来说简单⼯⼚，简单⼯⼚模式，⼜叫做静态⼯⼚模式（Static Factory Method），由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例，简单⼯⼚模式的实质是由⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类。
属于创建型模式，但不属于GOF23设计模式。
2、简单⼯⼚适⽤场景 ⼯⼚类负责创建的对象⽐较少；客户端（应⽤层）只需要知道传⼊⼯⼚类的参数，对于如何创建对象（逻辑）不关⼼。
3、简单⼯⼚优缺点优点：只需要传⼊⼀个正确的参数，就可以获取你所需要的对象，⽽⽆需知道其细节创建。
缺点：⼯⼚类的职责相对过重，增加新的产品，需要修改⼯⼚类的判断逻辑，违背了开闭原则。
4、简单⼯⼚实现 ⾸先来看类图： 代码实现：public class ShapeFactory {public Shape getShape(String shapeType){if(shapeType.equalsIgnoreCase("circle")){return new Circle();}else if(shapeType.equalsIgnoreCase("rectangle")){return new Rectangle();}else if(shapeType.equalsIgnoreCase("squere")){return new Squere();}return null;}public Shape getShape(Class clazz) throws Exception{return (Shape) clazz.newInstance();}}⼆、⼯⼚⽅法模式 1、什么是⼯⼚⽅法 ⼯⼚⽅法模式（Factory Method），⼜称多态性⼯⼚模式，属于设计模式三⼤分类中的创建型模式，作为抽象⼯⼚模式的孪⽣兄弟，⼯⼚⽅法模式定义了⼀个创建对象的接⼝，但由⼦类决定要实例化的类是哪⼀个，也就是说⼯⼚模式让实例化推迟到⼦类。
设计模式Factory_Method_工厂方法
Factory Method（工厂方法）Factory Method（工厂方法）属于创建型模式，利用工厂方法创建对象实例而不是直接用 New 关键字实例化。
理解如何写出工厂方法很简单，但理解为什么要用工厂方法就需要动动脑子了。
工厂方法看似简单的将 New 替换为一个函数，其实是体现了面向接口编程的思路，它创建的对象其实是一个符合通用接口的通用对象，这个对象的具体实现可以随意替换，以达到通用性目的。
意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
Factory Method 使一个类的实例化延迟到其子类。
举例子如果看不懂上面的意图介绍，没有关系，设计模式需要在日常工作里用起来，结合例子可以加深你的理解，下面我准备了三个例子，让你体会什么场景下会用到这种设计模式。
换灯泡我自己在家换过灯泡，以前我家里灯坏掉的时候，我看着这个奇形怪状的灯管，心里想，这种灯泡和这个灯座应该是一体的，市场上估计很难买到适配我这个灯座的灯泡了。
结果等我把灯泡拧下来，跑到门口的五金店去换的时候，店员随便给了我一个灯泡，我回去随便拧了一下居然就能用了。
我买这个灯泡的过程就用到了工厂模式，而正是得益于这种模式，让我可以方便在家门口就买到可以用的灯泡。
卡牌对战游戏卡牌对战中，卡牌有一些基本属性，比如攻防、生命值，也符合一些通用约定，比如一回合出击一起等等，那么对于战斗系统来说，应该怎样实例化卡牌呢？如何批量操作卡牌，而不是通用功能也要拿到每个卡牌的实例才能调用？另外每个卡牌有特殊能力，这些特殊能力又应该如何拓展呢？实现任意图形拖拽系统一个可以被交互操作的图形，它可以用鼠标进行拉伸、旋转或者移动，不同图形实现这些操作可能并不相同，要存储的数据也不一样，这些数据应该独立于图形存储，我们的系统如果要对接任意多的图形，具备强大拓展能力，对象关系应该如何设计呢？意图解释在使用工厂方法之前，我们就要创建一个用于创建对象的接口，这个接口具备通用性，所以我们可以忽略不同的实现来做一些通用的事情。
软件开发中常见的设计模式介绍
软件开发中常见的设计模式介绍在软件开发过程中，设计模式是一种被广泛应用的解决问题的方法。
设计模式可以提供在特定情境中重复使用的可行解决方案，有助于提高代码的可读性、可维护性和重用性。
本文将介绍几种常见的设计模式，包括工厂模式、观察者模式、单例模式和策略模式。
一、工厂模式工厂模式是一种常见的创建型设计模式，用于将对象的实例化过程封装起来。
它通过定义一个共同的接口来创建对象实例，使得客户端调用代码与具体的实现逻辑解耦。
工厂模式可以分为简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式通过一个工厂类来根据传入的参数决定创建哪个具体对象。
它的优点是实现简单，适用于对象类型较少且变化频率低的场景。
但是，当需要添加新的对象类型时，需要修改工厂类的代码，不符合开闭原则。
工厂方法模式通过定义一个抽象的工厂接口，由子类具体实现工厂方法来创建对象。
这种方式实现了对象的创建和使用的解耦，也符合开闭原则。
同时，工厂方法模式也可以在运行时动态地切换具体的子类工厂。
抽象工厂模式通过定义一个抽象的工厂接口，可以创建一组相关的对象。
它可以创建多个产品族的对象，且具有良好的扩展性。
但是，抽象工厂模式也增加了系统的复杂度和理解难度。
二、观察者模式观察者模式是一种常见的行为型设计模式，用于定义对象之间的一对多的依赖关系，使得当一个对象的状态发生变化时，其所依赖的对象都会得到通知并自动更新。
观察者模式分为被观察者和观察者两个角色。
被观察者维护一个观察者列表，并提供注册、移除和通知观察者的方法。
当被观察者的状态发生改变时，会遍历观察者列表，调用每个观察者的更新方法。
观察者接收到通知后，可以进行相应的处理。
观察者模式能够实现对象之间的松耦合，使得被观察者和观察者之间的依赖关系可以动态地建立和解除。
它也符合开闭原则，因为可以在运行时增加新的观察者。
三、单例模式单例模式是一种创建型设计模式，用于限制一个类只能创建一个实例。
它保证在整个应用程序中，只有一个实例存在，并提供了一个全局访问点。
工厂模式的三种形式
⼯⼚模式的三种形式简单⼯⼚模式-Simple Factory Patter在简单⼯⼚模式结构图中包含如下⼏个⾓⾊：● Factory（⼯⼚⾓⾊）：⼯⼚⾓⾊即⼯⼚类，它是简单⼯⼚模式的核⼼，负责实现创建所有产品实例的内部逻辑；⼯⼚类可以被外界直接调⽤，创建所需的产品对象；在⼯⼚类中提供了静态的⼯⼚⽅法factoryMethod()，它的返回类型为抽象产品类型Product。
● Product（抽象产品⾓⾊）：它是⼯⼚类所创建的所有对象的⽗类，封装了各种产品对象的公有⽅法，它的引⼊将提⾼系统的灵活性，使得在⼯⼚类中只需定义⼀个通⽤的⼯⼚⽅法，因为所有创建的具体产品对象都是其⼦类对象。
● ConcreteProduct（具体产品⾓⾊）：它是简单⼯⼚模式的创建⽬标，所有被创建的对象都充当这个⾓⾊的某个具体类的实例。
每⼀个具体产品⾓⾊都继承了抽象产品⾓⾊，需要实现在抽象产品中声明的抽象⽅法。
⼯⼚⽅法模式-Factory Method Pattern● Product（抽象产品）：它是定义产品的接⼝，是⼯⼚⽅法模式所创建对象的超类型，也就是产品对象的公共⽗类。
● ConcreteProduct（具体产品）：它实现了抽象产品接⼝，某种类型的具体产品由专门的具体⼯⼚创建，具体⼯⼚和具体产品之间⼀⼀对应。
● Factory（抽象⼯⼚）：在抽象⼯⼚类中，声明了⼯⼚⽅法(Factory Method)，⽤于返回⼀个产品。
抽象⼯⼚是⼯⼚⽅法模式的核⼼，所有创建对象的⼯⼚类都必须实现该接⼝。
● ConcreteFactory（具体⼯⼚）：它是抽象⼯⼚类的⼦类，实现了抽象⼯⼚中定义的⼯⼚⽅法，并可由客户端调⽤，返回⼀个具体产品类的实例。
与简单⼯⼚模式相⽐，⼯⼚⽅法模式最重要的区别是引⼊了抽象⼯⼚⾓⾊，抽象⼯⼚可以是接⼝，也可以是抽象类或者具体类抽象⼯⼚模式-Abstract Factory Pattern● AbstractFactory（抽象⼯⼚）：它声明了⼀组⽤于创建⼀族产品的⽅法，每⼀个⽅法对应⼀种产品。
显示器进入工厂模式方法
12）7KIr显示器（品牌机配套）
面板按键：“EXIT”，“←”,“→”,“MENU”，电源开关“◎”
工厂模式进入方法：按下“MENU”键，呼出OSD调整菜单，移动“→”到“ZOOM”处，按下 “MENU”不松手，等大约5-6秒钟后，在屏幕上方弹出一个蓝底白字的OSD菜单，就表示已经进 入工厂模式调整状态。
工厂模式中比用户模式多出了二十多项功能，对显示器三基色调整和几何图像调整等有很大的改 进。 其中“FOSD”是改变工厂模式中OSD菜单的上下位置。 “TM”是一个计时器，能够记录显示器开机工作的时间。这对于防止JS把样品或翻新显示器当成 新品来卖。 “User Adjustment”是用来返回用户模式操作界面。 “Exit”是退出工厂模式OSD菜单。 “←→”是用来改变显示器的最高行频，必须由硬件支持，不能人为的强行改变，否则可能损坏 显示器。 “LH”是用来改变显示器的亮度模式，有BL和BM两种。
在工厂模式中比用户模式多出如下功能：
“BI”（SET BURN-IN OFF/ON），用来设置是否打开老化开关，此功能要开时，显示器在无信 号输入时，屏幕上有图像为显示。此功能关闭时，显示器在无信号输入时，延时4秒种显示器进 入节能状态。
“TM”（USED TIME），此功能用来记录显示器的开机使用时间。 “USER ADJUSTMENT”，返回用户调整模式。 “EXIT”退出工厂模式的OSD菜单。 “BC”（BUTTOM CORNER），下边角调整。 ”TC“（TOP CORNER），上边角调整。 ”HS“（HORIZONTAL S），水平S线性调整。 该款显示器也同样俱有TCL显示器的玲珑指功能，当按下“MENU”键时，显示器的图像会在 “Personal(个人设置）”，“Mild（柔和）”，“Standard（标准）”，“Bright（高亮）” 四中模式中转换。
工厂模式简述
public class BMW { public BMW(){ System.out.println("这是-->BMW"); }}public class AUDI { public AUDI(){ System.out.println("这是-->AUDI"); }}public class {public static void main(String[] args) { BMW bmw = new BMW(); AUDI audi = new AUDI();}}public interface Car { public void carBrand();}public class AUDI implements Car { @Override public void carBrand() { System.out.println("这是-->AUDI"); }⼯⼚模式简述代码的优化离不开设计模式的使⽤，今天主要介绍⼀下⼯⼚模式：⼯⼚模式概念 实例化对象，⽤⼯⼚⽅法代替new操作 ⼯⼚模式包括⼯⼚⽅法模式、抽象⼯⼚模式什么情况⽤有⼀组相似的对象要创建编码时不能预见创建哪⼀些实例考虑代码的拓展性低耦合，⼀个对象的改变不影响以来他的对象具体实例模拟需求：需要⽣产宝马、奔驰、奥迪原始的做法：存在BMW、AUDI个类，通过new的⽅式创建多个对象客户需要知道怎么去创建⼀款车,客户和车就紧密耦合在⼀起了.为了降低耦合,就出现了⼯⼚类,把创造车的操作细节都放到了⼯⼚⾥⾯去,客户直接使⽤⼯⼚的创建⼯⼚⽅法,传⼊想要的车型号就⾏了,⽽不必去知道创建的细节.这就是⼯业⾰命了：简单⼯⼚模式即我们建⽴⼀个⼯⼚类⽅法来制造新的对象产品类： }}public class BMW implements Car{ @Override public void carBrand() { System.out.println("这是-->BMW"); }}⼯⼚类public class CarFactory {public Car creatCar(String carType){ switch (carType ) { case "bmw": return new BMW(); case "audi": return new AUDI(); default: break; } return null; }}客户端public class Test {CarFactory factory = new CarFactory(); factory.creatCar("bmw"); factory.creatCar("audi");}简单⼯⼚模式⼜称静态⼯⼚⽅法模式。
简单工厂与工厂方法模式的区别
简单工厂与工厂方法模式的区别软件开发中的设计模式是一种特定的解决方案，它可以用来解决一种在软件开发中普遍存在的问题。
在这些模式中，工厂模式是最为广泛使用的模式之一。
在工厂模式中，有两种基本的类型——简单工厂和工厂方法模式。
虽然这两种方法本质上是相同的，但它们之间也存在着一些关键的区别。
## 简单工厂模式简单工厂模式是一种创建型模式，它允许用户根据需要创建一个对象，而不必知道对象的具体类。
这个模式可以有效地将对象创建的过程抽象出来，并把它们放在一个工厂类中，这个工厂类根据用户的输入信息决定应该创建哪个具体的对象。
简单工厂模式的核心是工厂类，它是一个包含多个静态方法的类，这些静态方法根据用户的需求创建不同类型的对象。
例如，在一个汽车制造工厂中，简单工厂模式可以用来创建不同类型的车辆，例如轿车、跑车或 SUV。
用户只需提供所需类型的参数，简单工厂就可以根据当前需求返回相应的实例对象。
以下是简单工厂的实现示例：```class CarFactory {public static Car getCar(String carType) {if (carType == null) {return null;}if (carType.equalsIgnoreCase("SUV")) {return new SUV();}else if (carType.equalsIgnoreCase("sedan")) {return new Sedan();}else if (carType.equalsIgnoreCase("SportsCar")) { return new SportsCar();}return null;}class SUV implements Car {public void drive() {System.out.println("Driving SUV");}}class Sedan implements Car {public void drive() {System.out.println("Driving Sedan");}}class SportsCar implements Car {public void drive() {System.out.println("Driving Sports Car"); }interface Car {void drive();}```在上面的示例中，接口 Car 定义了一个 drive 方法，这个方法用来描述不同的车辆如何行驶。
工厂方法模式应用场景
工厂方法模式应用场景工厂方法模式是一种常用的设计模式，它将对象的创建过程封装在工厂类中，从而使客户端和具体产品类解耦。
在实际开发中，工厂方法模式有着广泛的应用场景，本文将从以下几个方面进行探讨。
1. 多态性的实现工厂方法模式是一种创建型模式，它通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。
这种方式可以让程序在运行时动态地创建对象，从而实现多态性。
在实际开发中，我们经常需要根据不同的条件来创建不同的对象，这时候工厂方法模式就可以派上用场。
例如，我们需要根据用户的年龄来创建不同类型的会员卡，如果用户的年龄小于18岁，则创建一张青少年会员卡；如果用户的年龄大于等于18岁，则创建一张成年会员卡。
这时候我们可以定义一个工厂类，根据用户的年龄来创建不同类型的会员卡对象，从而实现多态性。
2. 对象的复用工厂方法模式可以帮助我们实现对象的复用。
在实际开发中，我们经常需要创建大量的对象，如果每次都直接new一个新的对象，会浪费大量的资源。
而工厂方法模式可以通过在工厂类中缓存已创建的对象，从而实现对象的复用。
例如，我们需要创建一个线程池，如果每次都直接new一个新的线程对象，会消耗大量的内存和CPU资源。
而通过使用工厂方法模式，我们可以在工厂类中缓存已创建的线程对象，从而实现线程的复用，提高程序的性能。
3. 降低耦合度工厂方法模式可以降低程序的耦合度。
在实际开发中，我们经常需要创建不同类型的对象，如果直接在客户端中new一个新的对象，会导致客户端与具体产品类之间产生耦合。
而通过使用工厂方法模式，客户端只需要依赖于工厂类，不需要关心具体产品类的实现细节，从而降低了程序的耦合度。
例如，我们需要创建不同类型的图形对象，如圆形、矩形、三角形等。
如果直接在客户端中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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
工厂方法模式(Factory Method)—对象创建型模式工厂模式有以下几种形态：简单工厂（Simple Factory)模式；工厂方法(Factory Method)模式，又称多形性工厂(Polymorphic Factory)模式；抽象工厂(Abstract Factory)模式,又称工具箱(Kit或Toolkit)模式概述在软件系统中，经常面临着“某个对象”的创建工作，由于需求的变化，这个对象的具体实现经常面临着剧烈的变化，但是它却拥有比较稳定的接口。
如何应对这种变化？提供一种封装机制来隔离出“这个易变对象”的变化，从而保持系统中“其它依赖该对象的对象”不随着需求的改变而改变？这就是要说的Factory Method模式了。
意图定义一个用户创建对象的接口，让子类决定实例化哪一个类。
Factory Method使一个类的实例化延迟到其子类。
工厂方法模式解说在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。
这个核心类仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节。
这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
在Factory Method模式中，工厂类与产品类往往具有平行的等级结构，它们之间一一对应。
现在我们考虑一个日志记录的例子（这里我们只是为了说明Factory Method模式，实际项目中的日志记录不会这么去做，也要比这复杂一些）。
假定我们要设计日志记录的类，支持记录的方法有FileLog和EventLog两种方式。
在这里我们先不谈设计模式，那么这个日志记录的类就很好实现了：1///<summary>2///日志记录类3///</summary>4public class Log5 {67public void WriteEvent()8 {9 Console.WriteLine("EventLog Success!");10 }1112public void WriteFile()13 {14 Console.WriteLine("FileLog Success!");15 }1617public void Write(string LogType)18 {19switch(LogType.ToLower())20 {21case "event":22 WriteEvent();23break;2425case "file":26 WriteFile();27break;2829default:30break;31 }32 }33 }34这样的程序结构显然不能符合我们的要求，如果我们增加一种新的日志记录的方式DatabaseLog，那就要修改Log类，随着记录方式的变化，switch语句在不断的变化，这样就引起了整个应用程序的不稳定，进一步分析上面的代码，发现对于EventLog 和FileLog是两种完全不同的记录方式，它们之间不应该存在必然的联系，而应该把它们分别作为单独的对象来对待。
1///<summary>2/// EventLog类3///</summary>4public class EventLog5{6public void Write()7 {8 Console.WriteLine("EventLog Write Success!");9 }10}1112///<summary>13/// FileLog类14///</summary>15public class FileLog16{17public void Write()18 {19 Console.WriteLine("FileLog Write Success!");20 }21}22进一步抽象，为它们抽象出一个共同的父类，结构图如下：实现代码：1///<summary>2///Log类3///</summary>4public abstract class Log5{6public abstract void Write();7}8此时EventLog和FileLog类的代码应该如下：1///<summary>2/// EventLog类3///</summary>4public class EventLog:Log5{6public override void Write()7 {8 Console.WriteLine("EventLog Write Success!");9 }10}11///<summary>12/// FileLog类13///</summary>14public class FileLog:Log15{16public override void Write()17 {18 Console.WriteLine("FileLog Write Success!");19 }20}21此时我们再看增加新的记录日志方式DatabaseLog的时候，需要做哪些事情？只需要增加一个继承父类Log的子类来实现，而无需再去修改EventLog和FileLog类，这样的设计满足了类之间的层次关系，又很好的符合了面向对象设计中的单一职责原则，每一个类都只负责一件具体的事情。
到这里似乎我们的设计很完美了，事实上我们还没有看客户程序如何去调用。
在应用程序中，我们要使用某一种日志记录方式，也许会用到如下这样的语句：EventLog eventlog = new EventLog();eventlog.Write();当日志记录的方式从EventLog变化为FileLog，我们就得修改所有程序代码中出现上面语句的部分，这样的工作量是可想而知的。
此时就需要解耦具体的日志记录方式和应用程序。
这就要引入Factory Method模式了，每一个日志记录的对象就是工厂所生成的产品，既然有两种记录方式，那就需要两个不同的工厂去生产了，代码如下： 1///<summary>2/// EventFactory类3///</summary>4public class EventFactory5{6public EventLog Create()7 {8return new EventLog();9 }10}11///<summary>12/// FileFactory类13///</summary>14public class FileFactory15{16public FileLog Create()17 {18return new FileLog();19 }20}21这两个工厂和具体的产品之间是平行的结构，并一一对应，并在它们的基础上抽象出一个公用的接口，结构图如下：实现代码如下：1///<summary>2/// LogFactory类3///</summary>4public abstract class LogFactory5{6public abstract Log Create();7}8此时两个具体工厂的代码应该如下：1///<summary>2/// EventFactory类3///</summary>4public class EventFactory:LogFactory 5{6public override EventLog Create()8return new EventLog();9 }10}11///<summary>12/// FileFactory类13///</summary>14public class FileFactory:LogFactory15{16public override FileLog Create()17 {18return new FileLog();19 }20}21这样通过工厂方法模式我们把上面那对象创建工作封装在了工厂中，此时我们似乎完成了整个Factory Method的过程。
这样达到了我们应用程序和具体日志记录对象之间解耦的目的了吗？看一下此时客户端程序代码：1///<summary>2/// App类3///</summary>4public class App5{6public static void Main(string[] args)8 LogFactory factory = new EventFactory();910 Log log = factory.Create();1112 log.Write();13 }14}15在客户程序中，我们有效地避免了具体产品对象和应用程序之间的耦合，可是我们也看到，增加了具体工厂对象和应用程序之间的耦合。
那这样究竟带来什么好处呢？我们知道，在应用程序中，Log对象的创建是频繁的，在这里我们可以把LogFactory factory =new EventFactory();这句话放在一个类模块中，任何需要用到Log对象的地方仍然不变。
要是换一种日志记录方式，只要修改一处为：LogFactory factory =new FileFactory();其余的任何地方我们都不需要去修改。
有人会说那还是修改代码，其实在开发中我们很难避免修改，但是我们可以尽量做到只修改一处。
结构图适用性在以下情况下，适用于工厂方法模式：1. 当一个类不知道它所必须创建的对象的类的时候。
2.当一个类希望由它的子类来指定它所创建的对象的时候。
3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
生活中的例子工厂方法定义一个用于创建对象的接口，但是让子类决定实例化哪个类。
压注成型演示了这种模式。
塑料玩具制造商加工塑料粉，将塑料注入到希望形状的模具中。
玩具的类别（车，人物等等）是由模具决定的。
usingpublic{}public{{ Console.WriteLine("Bulb Light is Turned on"); }{ Console.WriteLine("Bulb Light is Turned off"); } }public{{ Console.WriteLine("Tube Light is Turned on"); }{ Console.WriteLine("Tube Light is Turned off"); } }public{}public{{}public{{}public{{Creator c1 =Creator c2 =Light l1 = c1.factory();Light l2 = c2.factory();l1.TurnOn();l1.TurnOff();Console.WriteLine("-----------------");l2.TurnOn();l2.TurnOff();}}客户端创建BulbCreator对象，客户端持有此对象的类型是Creator，而实际类型是BulbCreator。