工厂方法模式(Factory Method Pattern)
工厂方法模式(Factory Method Pattern)定义了一个用于创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法使一个类的实例化延迟到其子类。它属于创建型设计模式。
工厂方法模式的应用场景
- 当一个类不知道它所需要创建的对象的类:工厂方法模式可以把对象的创建委托给子类来决定。
- 当一个类希望由其子类来指定要创建的对象:例如,框架开发时,框架定义了接口,具体的实现由应用程序提供。
- 当类的实例化操作需要集中管理,以便于后续扩展和维护。
工厂方法模式的实现方式
1. 简单工厂方法
思想:简单工厂方法定义一个静态方法,根据传入的参数决定要实例化的类,返回实例。这种方式不属于正式的设计模式,而是一种创建对象的简单方法。
实现方式:
interface Product {
void use();
}
class ConcreteProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
class ConcreteProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Unknown product type");
}
}
}
public class SimpleFactoryPattern {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.use();
Product productB = SimpleFactory.createProduct("B");
productB.use();
}
}
优点:
- 简单易用,集中管理对象创建。
缺点:
- 违反开闭原则(对扩展开放,对修改关闭),每次增加新产品都需要修改工厂方法。
- 工厂方法的参数决定了产品类型,工厂类变得复杂。
2. 标准工厂方法
思想:标准工厂方法模式定义一个创建对象的接口,让子类决定实例化哪一个类。通过这种方式,把实例化操作延迟到子类。
实现方式:
interface Product {
void use();
}
class ConcreteProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
class ConcreteProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
interface Factory {
Product createProduct();
}
class ConcreteFactoryA implements Factory {
public Product createProduct() {
return new ConcreteProductA();
}
}
class ConcreteFactoryB implements Factory {
public Product createProduct() {
return new ConcreteProductB();
}
}
public class FactoryMethodPattern {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.use();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.use();
}
}
优点:
- 遵循开闭原则,可以通过增加新工厂来扩展产品,而不需要修改已有代码。
- 工厂方法可以隐藏对象创建的细节,提供更灵活的扩展性。
缺点:
- 增加了系统的复杂度,每增加一种产品都需要增加相应的工厂类。
3. 参数化工厂方法
思想:工厂方法可以通过参数化来创建不同类型的对象,这样可以减少工厂类的数量,但也会增加方法的复杂度。
实现方式:
interface Product {
void use();
}
class ConcreteProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
class ConcreteProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
abstract class Factory {
abstract Product createProduct(String type);
}
class ConcreteFactory extends Factory {
public Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Unknown product type");
}
}
}
public class ParameterizedFactoryMethodPattern {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product productA = factory.createProduct("A");
productA.use();
Product productB = factory.createProduct("B");
productB.use();
}
}
优点:
- 可以通过一个工厂类创建多种类型的产品,减少类的数量。
缺点:
- 工厂方法变得复杂,违反单一职责原则。
总结
实现方式 | 优点 | 缺点 |
---|---|---|
简单工厂方法 | 实现简单,集中管理对象创建 | 违反开闭原则,增加新产品需要修改工厂方法,工厂类变得复杂 |
标准工厂方法 | 遵循开闭原则,增加新产品只需增加相应工厂类,隐藏创建细节 | 增加了系统复杂度,每增加一种产品都需要增加相应的工厂类 |
参数化工厂方法 | 可以通过一个工厂类创建多种类型的产品,减少类的数量 | 工厂方法变得复杂,违反单一职责原则 |
不同的实现方式适用于不同的应用场景,选择哪种实现方式应根据具体的需求和系统的复杂度来决定。如果系统中需要频繁增加新产品类型,标准工厂方法是一个较好的选择。如果产品类型较少且创建逻辑简单,简单工厂方法和参数化工厂方法也可以考虑。