设计模式-工厂模式

简单工厂模式概述

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。工厂模式属于创建型模式，它提供了一种创建对象的广泛方式。
在工厂模式中，我们可以根据参数的不同返回不同类的实例；简单工厂专门定义了一个类来负责创建其他类的实例，被创建的类通常都具有共同的父类。

面向对象基本设计原则

在理解工厂模式之前，我们先了解下面向对象基本设计原则，了解这些设计原则有助于我们更好地理解设计模式。

• 单一职责原则（Single Responsibility Principle）：类的职责功能要单一，不能将太多的职责放在同一个类中。

• 开闭原则（Open-Closed principle）：对拓展开放，对修改关闭。

• 里氏替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类，以保证继承复用的基础。

• 依赖倒置原则（Dependecy-Inversion
  Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。

• 接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口。

• 合成复用原则：在系统中应该尽量多使用组合和聚合关联关系，尽量少使用甚至不使用继承关系。

• 迪米特法则：一个软件实体对其他实体的引用越少越好，或者说如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用，而是通过引入一个第三者发生间接交互。

简单工厂模式的结构

1. Factory(工厂)

   核心部分，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象。

2. Product(抽象类产品)：

   工厂类所创建的所有对象的父类，封装了产品对象的公共方法，所有的具体产品为其子类对象。

3. ConcreteProduct(具体产品)：

   简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法。

简单工厂模式的实现

1. 创建抽象类接口

interface Product {
    void create();
}

2. 创建具体产品的实现实体类

static class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("创造了 ProductA");
    }
}

static class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("创造了 ProductB");
    }
}

// 新增ProductC
static class ProductC implements Product {
    @Override
    public void create() {
        System.out.println("创造了 ProductC");
    }
}

3. 创建一个核心工厂，用于生成所需实体类的对象

static class ProductFactory {
    public Product manageProduct(String productType) {
        switch (productType) {
            case "ProductA":
                return new ProductA();
            case "ProductB":
                return new ProductB();
            // 新增ProductC
            case "ProductC":
                return new ProductC();
            default:
                throw new IllegalStateException("unexpected value:" + productType);
        }
    }
}

4. 使用该工厂，通过传递类型信息来获取实体类的对象

// 简单工厂模式
static class ProductFactoryClient{
    public static void main(String[] args) {
        ProductFactory factory = new ProductFactory();
        Product productA = factory.manageProduct("ProductA");
        productA.create();
        Product productB = factory.manageProduct("ProductB");
        productB.create();
        Product productC = factory.manageProduct("ProductC");
        productC.create();
    }
}

通过分析，我们发现，如果我需要创建ProductC，需要创建一个ProductC类，并且在核心工厂类中还必须增加判断。很明显不符合里氏替换原则（对拓展开放，对修改关闭），因此，我们需要优化简单工厂模式。

简单工厂模式->工厂模式

实际上，在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
话不多说，直接上代码

public class FactoryMode {
    interface Product {
        void create();
    }

    static class ProductA implements Product {
        @Override
        public void create() {
            System.out.println("创造了 ProductA");
        }
    }

    static class ProductB implements Product {
        @Override
        public void create() {
            System.out.println("创造了 ProductB");
        }
    }

    // 新增ProductC
    static class ProductC implements Product {
        @Override
        public void create() {
            System.out.println("创造了 ProductC");
        }
    }

    interface ProductFactory {
        Product manageProduct();
    }

    static class ProductAFactory implements ProductFactory {
        @Override
        public Product manageProduct() {
            return new ProductA();
        }
    }

    static class ProductBFactory implements ProductFactory {
        @Override
        public Product manageProduct() {
            return new ProductB();
        }
    }

    // 新增ProductC的处理
    static class ProductCFactory implements ProductFactory {
        @Override
        public Product manageProduct() {
            return new ProductC();
        }
    }

    // 简单工厂模式
    static class ProductFactoryClient {
        public static void main(String[] args) {
            Product productA = new ProductAFactory().manageProduct();
            productA.create();
            Product productB = new ProductBFactory().manageProduct();
            productB.create();
            Product productC = new ProductCFactory().manageProduct();
            productC.create();
        }
    }
}

通过对比分析，我们发现优化后，无需修改ProductFactory工厂类内部逻辑，只需要新增ProductCFactory 类实现ProductFactory 接口即可。