简单工厂模式实现

项目概述

本项目实现了设计模式中的简单工厂模式（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）

定义了所有产品共有的操作方法，是具体产品类必须实现的接口。

package src.main.java;

/**
 * 产品接口
 * 定义所有产品共有的操作
 */
public interface Product {
    /**
     * 产品的操作方法
     */
    void operation();
}

2. 具体产品实现

ConcreteProductA.java

package src.main.java;

/**
 * 具体产品A
 * 实现产品接口的具体类
 */
public class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA performing operation");
    }
}

ConcreteProductB.java

package src.main.java;

/**
 * 具体产品B
 * 实现产品接口的具体类
 */
public class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB performing operation");
    }
}

3. 工厂类（Factory.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）

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. 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类

总结

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