From 4efaae8aa1c80a689e5b8a730dd4d5ddacce0160 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=B2=90=E5=B0=8F=E6=99=A8=E6=9B=A6?= <869759698@qq.com>
Date: Mon, 7 Jan 2019 22:42:41 +0800
Subject: [PATCH] =?UTF-8?q?Update=20and=20rename=20=E5=B7=A5=E5=8E=82?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95=E6=A8=A1=E5=BC=8F.md=20to=20=E5=B7=A5?=
 =?UTF-8?q?=E5=8E=82=E6=A8=A1=E5=BC=8F.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 blogs/DesignMode/工厂方法模式.md |  20 -----
 blogs/DesignMode/工厂模式.md     | 124 +++++++++++++++++++++++++++++++
 2 files changed, 124 insertions(+), 20 deletions(-)
 delete mode 100644 blogs/DesignMode/工厂方法模式.md
 create mode 100644 blogs/DesignMode/工厂模式.md

diff --git a/blogs/DesignMode/工厂方法模式.md b/blogs/DesignMode/工厂方法模式.md
deleted file mode 100644
index f3cb0d9..0000000
--- a/blogs/DesignMode/工厂方法模式.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-工厂方法模式
----
-
-#### 目录
-
-1. 思维导图
-2. 概述
-3. 实现方式
-
-#### 思维导图
-
-#### 概述
-
-工厂方法模式，也是创建型设计模式之一。定义一个用于创建对象的接口，让子类决定实例化哪个类。
-
-在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适用工厂模式，用 new 就可以完成创建的对象无需使用工厂模式。
-
-#### 实现方式
-
diff --git a/blogs/DesignMode/工厂模式.md b/blogs/DesignMode/工厂模式.md
new file mode 100644
index 0000000..812e302
--- /dev/null
+++ b/blogs/DesignMode/工厂模式.md
@@ -0,0 +1,124 @@
+---
+工厂方法模式
+---
+
+#### 目录
+
+1. 思维导图
+2. 概述
+3. 三种实现方式
+   - 简单工厂模式 
+   - 工厂方法模式
+   - 抽象工厂模式
+
+#### 思维导图
+
+#### 概述
+
+工厂模式，也是创建型设计模式之一，它提供了一种创建对象的最佳方式。
+
+在任何需要生成复杂对象的地方，都可以使用工厂模式。复杂对象适用工厂模式，用 new 就可以完成创建的对象无需使用工厂模式。
+
+#### 实现方式
+
+##### 简单工厂模式
+
+```java
+//定义抽象产品类
+public abstract class Product {
+    public abstract void method();
+}
+```
+
+```java
+//定义具体产品
+public class ProductA extends Product {
+    @Override
+    public void method() {
+        System.out.println("产品A");
+    }
+}
+public class ProductB extends Product {
+    @Override
+    public void method() {
+        System.out.println("产品B");
+    }
+}
+```
+
+```java
+//定义一个工厂用来生产产品
+public class Factory {
+    public static Product createProduct(String type) {
+        switch (type) {
+            case "A":
+                return new ProductA();
+            case "B":
+                return new ProductB();
+            default:
+                return null;
+        }
+    }
+}
+```
+
+```java
+//客户端根据传入的参数生成不同的产品
+public class Client {
+    public static void main(String[] args) {
+        ProductA productA = (ProductA) Factory.createProduct("A");
+        if (productA != null) {
+            productA.method();
+        } else {
+            System.out.println("不存在产品A");
+        }
+    }
+}
+```
+
+这种写法很简单，但是问题也是显而易见的，每当增加新产品时就得改代码，违反了开闭原则。
+
+##### 工厂方法模式
+
+将具体产品的创建延迟到具体工厂中完成，即由子类来决定应该实例化哪一个类。
+
+```java
+//定义一个抽象工厂类
+public abstract class Factory {
+    public abstract Product createProduct();
+}
+```
+
+```java
+//具体的工厂，生产不同的产品
+public class FactoryA extends Factory {
+    @Override
+    public Product createProduct() {
+        return new ProductA();
+    }
+}
+public class FactoryB extends Factory {
+    @Override
+    public Product createProduct() {
+        return new ProductB();
+    }
+}
+```
+
+```java
+//用户决定要生产哪个产品
+public class Client {
+    public static void main(String[] args) {
+        Factory factory = new FactoryA();
+        ProductA productA = (ProductA) factory.createProduct();
+        productA.method();
+
+        new FactoryB().createProduct().method();
+    }
+}
+```
+
+缺点也是显而易见的，一个工厂只能生产一种产品，而且每一个产品都必须对应一个工厂，系统类成对增加，在一定程度上增加了系统的复杂度。
+
+##### 抽象工厂模式
+