diff --git a/README.md b/README.md
index 3049010..d601928 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,230 @@
-# FactoryPattern
+# 简单工厂模式实现
 
+## 项目概述
+
+本项目实现了设计模式中的**简单工厂模式（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. **抽象工厂模式**：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类
+
+## 总结
+
+简单工厂模式是一种简单实用的创建型设计模式，适用于创建对象较少且变化不大的场景。通过封装对象创建逻辑，它降低了系统的耦合度，提高了代码的可维护性。
\ No newline at end of file