编程语言23种设计模式（二）工厂模式

编程语言23种设计模式（二）工厂模式

二 、工厂模式

概念：

• 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

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

优点：

• 1、一个调用者想创建一个对象，只要知道其名称就可以了。
• 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

核心本质在于实例化对象不使用new，而用工厂方法来取代，实现了解耦。

---

2.1 简单工厂模式

简单工厂模式又被称为静态工厂模式，原因在于工厂类定义了一个静态方法。

简单工厂模式的主要角色如下：

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

下面是一个实例，我们将用代码来模拟造车工厂。我们分别用特斯拉（tesla)、奔驰（benz)以及大众（volkswagen)来实现一个总的车子接口。

/**
 * 所有车的统一标准规范类
 *
 * @author kimariyb
 */
public interface Car {
    /**
     * 输出车子的名字
     */
    void getName();
}

/**
 * 制造特斯拉
 *
 * @author kimariyb
 */
public class Tesla implements Car {
    @Override
    public void getName() {
        System.out.println("这是特斯拉！");
    }
}

/**
 * 制造大众车
 *
 * @author kimariyb
 */
public class Volkswagen implements Car {
    @Override
    public void getName() {
        System.out.println("这是大众！");
    }
}

/**
 * 制造奔驰车
 *
 * @author kimariyb
 */
public class Benz implements Car {
    @Override
    public void getName() {
        System.out.println("这是奔驰！");
    }
}

在这之后，最重要的就在于工厂类的编写。注意出现的魔法值和一些异常的处理。完成这一切后我们进行测试。在这里我们直接在类中编写了（不推荐）。

/**
 * 造车工厂
 *
 * @author kimariyb
 */
public class CarFactory {
    /**
     * 定义静态常量
     * 防止出现魔法值
     */
    public static final String VOLKSWAGEN = "大众";
    public static final String BENZ = "奔驰";
    public static final String TESLA = "特斯拉";

    public static Car getCar(String car) {
        if (VOLKSWAGEN.equalsIgnoreCase(car)) {
            return new Volkswagen();
        } else if (BENZ.equalsIgnoreCase(car)) {
            return new Benz();
        } else if (TESLA.equalsIgnoreCase(car)) {
            return new Tesla();
        }
        return null;
    }
}

/**
 * 测试类
 *
 * @author kimariyb
 */
public class Test {
    public static void main(String[] args) {
        Car car1 = CarFactory.getCar(CarFactory.BENZ);
        Car car2 = CarFactory.getCar(CarFactory.TESLA);
        Car car3 = CarFactory.getCar(CarFactory.VOLKSWAGEN);
        
        car1.getName();
        car2.getName();
        car3.getName();
    }
}

上面是输出的结果，可以看见它实现了对象的创建。但是它也有缺点，对于新增的产品，我们只能选择修改原有代码。这并不满足面向对象的开闭原则。

---

2.2 工厂方法模式

和简单工厂模式工厂直接负责所有产品的生产相比，工厂方法模式将生产具体产品的任务发给的具体的产品工厂。

工厂方法模式的主要角色如下。

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

• 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

  

还是上面的实例，由于简单工厂方法并不能满足开闭原则，我们可以将CarFactory修改为一个接口，并且使用具体车子工厂类来实现这一接口。

/**
 * 车子工厂
 * @author kimariyb
 */
public interface CarFactory {
    /**
     * 得到车子
     * @return 车子
     */
    Car getCar();
}

/**
 * 特斯拉工厂
 *
 * @author kimariyb
 */
public class TeslaFactory implements CarFactory {

    @Override
    public Car getCar() {
        return new Tesla();
    }
}

/**
 * 大众工厂
 * @author kimariyb
 */
public class VolkswagenFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Volkswagen();
    }
}

/**
 * 奔驰制造工厂
 *
 * @author kimariyb
 */
public class BenzFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Benz();
    }
}

很显然这样可以在不修改原有代码的情况下，来实现添加或者减少产品。很好的满足了开闭原则，下面是测试类和输出结果。

public class Test {
    public static void main(String[] args) {
        Car car1 = new TeslaFactory().getCar();
        Car car2 = new BenzFactory().getCar();
        Car car3 = new VolkswagenFactory().getCar();

        car1.getName();
        car2.getName();
        car3.getName();
    }
}

简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中，根据参数的类型进行实例化，同时不存在抽象接口。

而后者则通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品，这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则

文章来源：https://www.cnblogs.com/kimariyb/p/15579489.html