查看“设计模式：工厂模式”的源代码

[[category:设计模式]]

== 关于 ==
工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。


按实际业务场景划分，工厂模式有 3 种不同的实现方式：
# '''简单工厂模式'''：创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作“静态工厂方法模式”（Static Factory Method Pattern）。
#* 简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。（简单工厂模式不在 GoF 23 种设计模式之列。）
# '''工厂方法模式'''：“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
# '''抽象工厂模式'''。

== 简单工厂模式 ==
简单工厂模式的主要角色如下：
# '''简单工厂'''（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
# '''抽象产品'''（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
# '''具体产品'''（ConcreteProduct）：是简单工厂模式的创建目标。

其结构图如下：
:[[File:设计模式：简单工厂模式.png|600px]]

其代码如下：
<syntaxhighlight lang="java" highlight="">
//抽象产品
public interface Product {
    void show();
}

//具体产品：Product1
public class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}
//具体产品：Product2
public class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

//简单工厂
static class SimpleFactory {
    public static Product makeProduct(String kind) {
        if(shapeType == null){
            return null;
        }   
        switch (kind) {
            case "Product1":
                return new ConcreteProduct1();
            case "Product2":
                return new ConcreteProduct2();
        }
        return null;
    }
}
    
// 使用简单工厂
public class Client {
    public static void main(String[] args) {
      SimpleFactory simpleFactory = new SimpleFactory();
 
      //获取 Product1 的对象
      Product product1 = simpleFactory.makeProduct("Product1");
      //调用 Product1 的 show 方法
      product1.show();
 
      //获取 Product1 的对象
      Product product2 = simpleFactory.makeProduct("Product1");
      //调用 Product1 的 show 方法
      product2.show();
    } 
}
</syntaxhighlight>


优点：
* 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
* 客户端无需知道所创建具体产品的类名，只需知道参数即可。
* 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。
缺点：
* 简单工厂模式的'''工厂类单一，负责所有产品的创建，职责过重'''，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
* 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
* 系统扩展困难，一旦'''增加新产品不得不修改工厂逻辑'''，在产品类型较多时，可能造成逻辑过于复杂
* 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

== 工厂方法模式 ==
简单工厂模式的主要角色如下：
# 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
# 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
# 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
# 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，'''它同具体工厂之间一一对应'''。

其结构图如下：
: [[File:设计模式：工厂方法模式.png|600px]]

其代码如下：
<syntaxhighlight lang="java" highlight="">
package FactoryMethod;

//抽象产品：提供了产品的接口
interface Product {
    public void show();
}
//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}
//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}
//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

// 使用工厂方法
public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            // 获取 Product1 对象
            AbstractFactory factory1 = new ConcreteFactory1();
            Product product1 = factory1.newProduct();
            //调用 Product1 的 show 方法
            product1.show();
            
            // 获取 Product2 对象
            AbstractFactory factory2 = new ConcreteFactory1();
            Product product2 = factory2.newProduct();
            //调用 Product2 的 show 方法
            product2.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
</syntaxhighlight>


优点：
* 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
* 灵活性增强，'''对于新产品的创建，只需多写一个相应的工厂类'''。
* 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，'''满足迪米特法则、依赖倒置原则和里氏替换原则'''。
缺点：
* '''类的个数容易过多，增加复杂度'''。
* 增加了系统的抽象性和理解难度。
* '''抽象产品只能生产一种产品'''，此弊端可使用“'''抽象工厂模式'''”解决。