# 简单工厂模式实现

## 项目概述

本项目实现了设计模式中的**简单工厂模式（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. **抽象工厂模式**：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类

## 总结

简单工厂模式是一种简单实用的创建型设计模式，适用于创建对象较少且变化不大的场景。通过封装对象创建逻辑，它降低了系统的耦合度，提高了代码的可维护性。