工厂模式
工厂模式定义一个用于创建对象的接口,这个接口由子类(可以理解为产品线)决定实例化哪一个类(生产衣服还是鞋子)
该模式使一个类的实例化延迟到了子类,也就是很多产品线在工厂里,当用的时候才告诉产品线干活
而子类可以重写接口方法(比如修改造鞋流程)以便创建的时候指定自己的对象类型(抽象工厂)
这个模式十分有用,尤其是创建对象的流程赋值的时候(比如造鞋的流程),如依赖于很多设置文件(鞋子依赖哪些原材料, 不同的环境配置)等
并且,你会经常在程序里看到工厂方法,用于让子类定义需要创建的对象类型,也就是生产单例
工厂模式的作用
- 用于对象的构建十分复杂
- 需要依赖具体的环境创建不同的实例
- 处理大量具有相同属性的小对象,也就是批量生产
工厂模式的注意事项
- 不能滥用工厂,仅仅会给代码增加复杂度
- 注意工厂模式的适用场景
工厂模式的实现
这里使用 Typescript 版本来实现
1 ) 工厂方法模式
// 产品接口
interface Product {
use(): void;
}
// 具体产品A
class ConcreteProductA implements Product {
use(): void {
console.log("Using ConcreteProductA");
}
}
// 具体产品B
class ConcreteProductB implements Product {
use(): void {
console.log("Using ConcreteProductB");
}
}
// 工厂接口
interface Creator {
createProduct(): Product;
}
// 具体工厂A,生产具体产品A
class ConcreteCreatorA implements Creator {
createProduct(): Product {
return new ConcreteProductA();
}
}
// 具体工厂B,生产具体产品B
class ConcreteCreatorB implements Creator {
createProduct(): Product {
return new ConcreteProductB();
}
}
// 客户端代码
function clientCode(creator: Creator) {
const product = creator.createProduct();
product.use();
}
// 使用示例
const creatorA = new ConcreteCreatorA();
clientCode(creatorA); // 输出: Using ConcreteProductA
const creatorB = new ConcreteCreatorB();
clientCode(creatorB); // 输出: Using ConcreteProductB
- 在工厂方法模式中,我们定义了一个产品接口 Product
- 和多个实现了该接口的具体产品类(ConcreteProductA 和 ConcreteProductB)
- 我们还定义了一个工厂接口 Creator,它声明了一个 createProduct 方法,用于创建产品
- 具体工厂类(ConcreteCreatorA 和 ConcreteCreatorB)实现了这个工厂接口并返回相应的具体产品实例
- 客户端代码只与工厂接口交互,从而实现了与具体产品实现的解耦
2 ) 抽象工厂模式
// 产品接口
interface Product {
use(): void;
}
// 具体产品A1
class ConcreteProductA1 implements Product {
use(): void {
console.log("Using ConcreteProductA1");
}
}
// 具体产品B1
class ConcreteProductB1 implements Product {
use(): void {
console.log("Using ConcreteProductB1");
}
}
// 具体产品A2
class ConcreteProductA2 implements Product {
use(): void {
console.log("Using ConcreteProductA2");
}
}
// 具体产品B2
class ConcreteProductB2 implements Product {
use(): void {
console.log("Using ConcreteProductB2");
}
}
// 抽象工厂接口
interface AbstractFactory {
createProductA(): Product;
createProductB(): Product;
}
// 具体工厂1,生产具体产品A1和B1
class ConcreteFactory1 implements AbstractFactory {
createProductA(): Product {
return new ConcreteProductA1();
}
createProductB(): Product {
return new ConcreteProductB1();
}
}
// 具体工厂2,生产具体产品A2和B2
class ConcreteFactory2 implements AbstractFactory {
createProductA(): Product {
return new ConcreteProductA2();
}
createProductB(): Product {
return new ConcreteProductB2();
}
}
// 客户端代码
function clientCode(factory: AbstractFactory) {
const productA = factory.createProductA();
productA.use();
const productB = factory.createProductB();
productB.use();
}
// 使用示例
const factory1 = new ConcreteFactory1();
clientCode(factory1); // 输出: Using ConcreteProductA1 和 Using ConcreteProductB1
const factory2 = new ConcreteFactory2();
clientCode(factory2); // 输出: Using ConcreteProductA2 和 Using ConcreteProductB2
- 在抽象工厂模式中,我们定义了一个抽象工厂接口 AbstractFactory
- 它声明了创建不同但相关或属于同一产品族的具体产品的方法
- (如 createProductA 和 createProductB)
- 具体工厂类(ConcreteFactory1 和 ConcreteFactory2)实现了这个抽象工厂接口
- 并返回相应产品族的具体产品实例
- 客户端代码与抽象工厂接口交互,从而可以创建整个产品族的产品
工厂方法模式与抽象工厂模式的不同
- 工厂方法模式与抽象工厂模式都是面向对象编程中常用的设计模式
- 它们的主要目的是将对象的创建与使用相分离,以增加系统的灵活性和可扩展性
- 然而,它们之间存在一些关键的不同点
1 ) 产品对象的范围
- 工厂方法模式:
- 专注于单一产品对象的创建。每个具体工厂类只负责创建单一的具体产品类实例
- 这意味着,如果你有多个产品类需要创建,你将需要多个工厂类,每个工厂类对应一个产品类
- 抽象工厂模式
- 则负责创建一系列相关的产品对象,即产品族
- 每个具体工厂类都能创建同一产品族中的多个不同类型的产品实例
- 这种模式适用于那些需要一起使用的一组相关产品的场景
2 ) 系统的扩展性
- 工厂方法模式:
- 当需要增加新的产品类型时,只需要添加新的产品类和对应的工厂类即可,而不影响已有的代码
- 这使得工厂方法模式在添加新产品时具有较好的扩展性
- 抽象工厂模式:
- 当需要增加新的产品族时,同样只需添加新的具体工厂类和对应的产品类
- 然而,对于已有产品族的扩展,由于抽象工厂模式已经定义好了产品族的结构
- 因此可能需要修改现有的工厂类或产品类接口,这在一定程度上降低了扩展的灵活性
3 ) 复杂性和适用场景
- 工厂方法模式
- 通常比抽象工厂模式更简单,适用于产品种类较少,且每个产品类相对独立的场景
- 抽象工厂模式
- 适用于产品种类较多,且需要一起使用的场景
- 它提供了对产品族中相关产品的统一管理和创建,有助于降低系统的复杂性
- 然而,由于需要处理多个产品族和多个产品类型,抽象工厂模式的实现可能会相对复杂一些
4 ) 设计机制
- 工厂方法模式
- 主要采用的是类继承机制,通过子类实现工厂接口来决定创建哪个产品类的实例
- 抽象工厂模式
- 则采用的是对象组合机制,通过专门定义的“工厂”对象来负责创建一系列相关的产品对象
5 )总结来说
- 工厂方法模式和抽象工厂模式的主要区别在于它们所创建的产品对象的范围和系统的扩展性
- 工厂方法模式适用于单一产品对象的创建和扩展
- 而抽象工厂模式则适用于一系列相关产品的创建和管理
- 在选择使用哪种模式时,需要根据具体的业务需求和系统特点来做出决策
664



被折叠的 条评论
为什么被折叠?



