|
|
# 简单工厂模式实现
|
|
|
|
|
|
## 项目概述
|
|
|
|
|
|
本项目实现了设计模式中的**简单工厂模式（Simple Factory Pattern）**，这是一种创建型设计模式，用于封装对象的创建逻辑。通过工厂类集中管理对象的创建过程，客户端代码不需要直接实例化具体产品类，从而降低了系统的耦合度。
|
|
|
|
|
|
## 设计模式说明
|
|
|
|
|
|
### 简单工厂模式简介
|
|
|
|
|
|
简单工厂模式（Simple Factory Pattern）属于创建型模式，它提供了一个创建对象的最佳方式。在简单工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，而是通过一个共同的接口来指向新创建的对象。
|
|
|
|
|
|
### 核心角色
|
|
|
|
|
|
1. **抽象产品（Product）**：定义产品的接口，是工厂方法所创建对象的超类型。
|
|
|
2. **具体产品（Concrete Product）**：实现抽象产品接口，是工厂方法创建的目标对象。
|
|
|
3. **工厂（Factory）**：负责创建具体产品实例的类，包含创建产品的逻辑。
|
|
|
|
|
|
## 类图结构
|
|
|
|
|
|
```
|
|
|
┌─────────────┐ ┌───────────────┐ ┌────────────────┐
|
|
|
│ │ │ │ │ │
|
|
|
│ Product │<────│ Factory │────>│ConcreteProductA│
|
|
|
│ (接口) │ │ (工厂类) │ │ │
|
|
|
│ │ │ │ └────────────────┘
|
|
|
└─────────────┘ └───────────────┘
|
|
|
^ │
|
|
|
│ │
|
|
|
│ v
|
|
|
┌──────────────┐ ┌────────────────┐
|
|
|
│ │ │ │
|
|
|
│ConcreteProductB│<───│ │
|
|
|
│ │ │ │
|
|
|
└──────────────┘ └────────────────┘
|
|
|
```
|
|
|
|
|
|
## 代码结构
|
|
|
|
|
|
```
|
|
|
src/
|
|
|
└── main/
|
|
|
└── java/
|
|
|
├── Product.java # 抽象产品接口
|
|
|
├── ConcreteProductA.java # 具体产品A
|
|
|
├── ConcreteProductB.java # 具体产品B
|
|
|
├── Factory.java # 工厂类
|
|
|
└── FactoryTest.java # 测试类
|
|
|
```
|
|
|
|
|
|
## 实现详情
|
|
|
|
|
|
### 1. 抽象产品接口（Product.java）
|
|
|
|
|
|
定义了所有产品共有的操作方法，是具体产品类必须实现的接口。
|
|
|
|
|
|
```java
|
|
|
package src.main.java;
|
|
|
|
|
|
/**
|
|
|
* 产品接口
|
|
|
* 定义所有产品共有的操作
|
|
|
*/
|
|
|
public interface Product {
|
|
|
/**
|
|
|
* 产品的操作方法
|
|
|
*/
|
|
|
void operation();
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 2. 具体产品实现
|
|
|
|
|
|
#### ConcreteProductA.java
|
|
|
|
|
|
```java
|
|
|
package src.main.java;
|
|
|
|
|
|
/**
|
|
|
* 具体产品A
|
|
|
* 实现产品接口的具体类
|
|
|
*/
|
|
|
public class ConcreteProductA implements Product {
|
|
|
@Override
|
|
|
public void operation() {
|
|
|
System.out.println("ConcreteProductA performing operation");
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
#### ConcreteProductB.java
|
|
|
|
|
|
```java
|
|
|
package src.main.java;
|
|
|
|
|
|
/**
|
|
|
* 具体产品B
|
|
|
* 实现产品接口的具体类
|
|
|
*/
|
|
|
public class ConcreteProductB implements Product {
|
|
|
@Override
|
|
|
public void operation() {
|
|
|
System.out.println("ConcreteProductB performing operation");
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 3. 工厂类（Factory.java）
|
|
|
|
|
|
```java
|
|
|
package src.main.java;
|
|
|
|
|
|
/**
|
|
|
* 工厂类
|
|
|
* 根据参数创建不同的具体产品实例
|
|
|
*/
|
|
|
public class Factory {
|
|
|
/**
|
|
|
* 创建产品的静态方法
|
|
|
* @param type 产品类型
|
|
|
* @return 产品实例
|
|
|
*/
|
|
|
public static Product createProduct(String type) {
|
|
|
if (type == null) {
|
|
|
return null;
|
|
|
}
|
|
|
if (type.equalsIgnoreCase("A")) {
|
|
|
return new ConcreteProductA();
|
|
|
} else if (type.equalsIgnoreCase("B")) {
|
|
|
return new ConcreteProductB();
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 4. 测试类（FactoryTest.java）
|
|
|
|
|
|
```java
|
|
|
package src.main.java;
|
|
|
|
|
|
/**
|
|
|
* 测试类
|
|
|
* 验证简单工厂模式的实现
|
|
|
*/
|
|
|
public class FactoryTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 测试创建ConcreteProductA
|
|
|
Product productA = Factory.createProduct("A");
|
|
|
System.out.println("Testing Product A:");
|
|
|
productA.operation();
|
|
|
|
|
|
// 测试创建ConcreteProductB
|
|
|
Product productB = Factory.createProduct("B");
|
|
|
System.out.println("\nTesting Product B:");
|
|
|
productB.operation();
|
|
|
|
|
|
// 测试无效类型
|
|
|
Product invalidProduct = Factory.createProduct("C");
|
|
|
System.out.println("\nTesting Invalid Product:");
|
|
|
if (invalidProduct == null) {
|
|
|
System.out.println("Invalid product type, returned null");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
## 运行程序
|
|
|
|
|
|
要运行此程序，请确保您的系统已安装Java开发环境（JDK），然后按照以下步骤操作：
|
|
|
|
|
|
1. 编译所有Java文件：
|
|
|
```
|
|
|
javac src/main/java/*.java
|
|
|
```
|
|
|
|
|
|
2. 运行测试类：
|
|
|
```
|
|
|
java src.main.java.FactoryTest
|
|
|
```
|
|
|
|
|
|
3. 预期输出：
|
|
|
```
|
|
|
Testing Product A:
|
|
|
ConcreteProductA performing operation
|
|
|
|
|
|
Testing Product B:
|
|
|
ConcreteProductB performing operation
|
|
|
|
|
|
Testing Invalid Product:
|
|
|
Invalid product type, returned null
|
|
|
```
|
|
|
|
|
|
## 设计原则
|
|
|
|
|
|
本实现遵循了以下设计原则：
|
|
|
|
|
|
1. **单一职责原则（SRP）**：每个类都有明确的单一职责。
|
|
|
2. **开闭原则（OCP）**：对扩展开放，对修改关闭。添加新的产品只需要添加新的具体产品类和修改工厂类。
|
|
|
3. **依赖倒置原则（DIP）**：高层模块依赖抽象，不依赖具体实现。
|
|
|
|
|
|
## 简单工厂模式的优缺点
|
|
|
|
|
|
### 优点
|
|
|
|
|
|
1. 实现了对象创建和使用的分离
|
|
|
2. 客户端不需要知道所创建的具体产品类的类名，只需要知道参数即可
|
|
|
3. 通过引入配置文件，可以在不修改代码的情况下更换和添加新的产品类
|
|
|
|
|
|
### 缺点
|
|
|
|
|
|
1. 工厂类集中了所有产品的创建逻辑，职责过重
|
|
|
2. 当产品种类过多时，工厂类会变得非常复杂
|
|
|
3. 违背了开闭原则，添加新产品时需要修改工厂类
|
|
|
|
|
|
## 适用场景
|
|
|
|
|
|
1. 工厂类负责创建的对象比较少
|
|
|
2. 客户端只知道传入工厂类的参数，不关心如何创建对象
|
|
|
|
|
|
## 扩展建议
|
|
|
|
|
|
如果需要更灵活的工厂模式实现，可以考虑使用：
|
|
|
|
|
|
1. **工厂方法模式**：定义一个用于创建对象的接口，让子类决定实例化哪个类
|
|
|
2. **抽象工厂模式**：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类
|
|
|
|
|
|
## 总结
|
|
|
|
|
|
简单工厂模式是一种简单实用的创建型设计模式，适用于创建对象较少且变化不大的场景。通过封装对象创建逻辑，它降低了系统的耦合度，提高了代码的可维护性。 |
