java设计模式：02-03-工厂方法模式
工厂方法模式（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();
}
}
优点：
- 可以通过一个工厂类创建多种类型的产品，减少类的数量。
缺点：
- 工厂方法变得复杂，违反单一职责原则。
总结
| 实现方式 | 优点 | 缺点 |
|---|---|---|
| 简单工厂方法 | 实现简单，集中管理对象创建 | 违反开闭原则，增加新产品需要修改工厂方法，工厂类变得复杂 |
| 标准工厂方法 | 遵循开闭原则，增加新产品只需增加相应工厂类，隐藏创建细节 | 增加了系统复杂度，每增加一种产品都需要增加相应的工厂类 |
| 参数化工厂方法 | 可以通过一个工厂类创建多种类型的产品，减少类的数量 | 工厂方法变得复杂，违反单一职责原则 |
不同的实现方式适用于不同的应用场景，选择哪种实现方式应根据具体的需求和系统的复杂度来决定。如果系统中需要频繁增加新产品类型，标准工厂方法是一个较好的选择。如果产品类型较少且创建逻辑简单，简单工厂方法和参数化工厂方法也可以考虑。
原文地址：https://blog.csdn.net/Mr_Air_Boy/article/details/140488978
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！