一、工厂模式

工厂模式是一种非常常用的创建型设计模式，其提供了创建对象的最佳方式。在创建对象时，不会对客户端暴露对象的创建逻辑，而是通过使用共同的接口来创建对象。

工厂模式分类

工厂模式可以分为3类：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

工厂模式的优点

• 解耦：将对象的创建和使用进行分离
• 可复用：对于创建过程比较复杂且在很多地方都使用到的对象，通过工厂模式可以提高对象创建的代码的复用性。
• 降低成本：由于复杂对象通过工厂进行统一管理，所以只需要修改工厂内部的对象创建过程即可维护对象，从而达到降低成本的目的。

工厂模式理论

简单工厂模式

简单工厂模式本身是违背开闭原则的，虽可通过反射+配置文件解决，但总体来说不友好。

• 何时使用简单工程模式？
  • 需要创建的对象少
  • 客户端不需要关注对象的创建过程
• 优点
  • 调用者想创建一个对象，只需要知道其名称即可
• 缺点
  • 违背开闭原则，每增加一个对象都需要修改工厂类。
• 总结
  简单工厂模式代码简单，虽有多处if分支且违背开闭原则，但扩展性和可读性尚可，这样的代码在大多数情况下并无问题。

工厂方法模式

简单工厂模式违背了开闭原则，而工厂方法模式则是简单工厂模式的进一步深化，其不像简单工厂模式通过一个工厂来完成所有对象的创建，而是通过不同的工厂来创建不同的对象，每个对象有对应的工厂创建。

• 何时使用工厂方法模式？

  • 一个类不需要知道所需对象的类，只需要知道具体类对应的工厂类。
  • 一个类通过其子类来决定创建哪个对象，工厂类只需提供一个创建对象的接口。
  • 将创建对象的任务委托给具体工厂，也可以动态指定由哪个工厂的子类创建。

• 简单工厂模式和工厂方法模式对比
  当对象的创建过程比较复杂，需要组合其他类对象做各种初始化操作时，推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中使得每个工厂类不过于复杂。而使用简单工厂模式则会将所有的创建逻辑都放到一个工厂类，会导致工厂类过于复杂。

• 优点

  • 调用者想创建一个对象，只需要知道其名称即可。
  • 扩展性高，如果增加一个类，只需要扩展一个工厂类。
  • 对调用者屏蔽对象具体实现，调用者只需要关注接口。

• 缺点

  • 当增加一个具体类时，需要增加其对应的工厂类，在一定程度上增加了系统的复杂度。

抽象工厂模式

抽象工厂模式是对工厂方法模式的进一步深化。在工厂方法模式中，工厂仅可创建一种对象；然而，在抽象工厂模式中，工厂不仅可创建一种对象，还可创建一组对象。

• 何时使用抽象工厂模式？
  • 需要一组对象完成某种功能或多组对象完成不同的功能。
  • 系统稳定，不会额外增加对象
• 优点
  • 扩展性高，可通过一组对象实现某个功能
• 缺点
  • 一旦增加就需要修改原有代码，不符合开闭原则，所以尽可能用在不需要修改的场景。

代码实现

接下来，对简单工厂模式、工厂方法模式和抽象工厂模式进行代码实现。

假设我们有产品电脑，通过工厂模式来创建具体的电脑对象。
首先先定义具体类(即产品)，包括

package factory.model;


/**
 *  电脑：开机，关机
 */
public interface Computer {

    void powerOn();

    void powerOff();
}

华为电脑：实现了Computer接口

package factory.model;

public class HuaweiComputer implements Computer {
    public void powerOn() {
        System.err.println("Huawei Computer power on");
    }

    public void powerOff() {
        System.err.println("Huawei Computer power off");
    }
}

小米电脑：实现了Computer接口

package factory.model;

public class XiaomiComputer implements Computer {
    public void powerOn() {
        System.err.println("Xiaomi Computer power on");
    }

    public void powerOff() {
        System.err.println("Xiaomi Computer power off");
    }
}

• 简单工厂模式
  简单工厂模式结构比较简单，创建对象的任务由工厂类来完成。

工厂类，根据类型创建相应的对象：

package factory.simple;

import factory.model.Computer;
import factory.model.HuaweiComputer;
import factory.model.XiaomiComputer;

public class ComputerFactory {


    public Computer create(String type){
        if (type == null || type.length() == 0){
            return null;
        }
        if ("Huawei".equalsIgnoreCase(type)) {
            return new HuaweiComputer();
        } else if ("Xiaomi".equalsIgnoreCase(type)) {
            return new XiaomiComputer();
        }
        return null;
    }
}

Client客户端：

package factory.simple;

import factory.model.Computer;

public class Client {

    public static void main(String[] args) {
        Computer huawei = new ComputerFactory().create("Huawei");
        huawei.powerOn();
        huawei.powerOff();
        Computer xiaomi = new ComputerFactory().create("Xiaomi");
        xiaomi.powerOn();
        xiaomi.powerOff();
    }
}
// 结果
Huawei Computer power on
Huawei Computer power off
Xiaomi Computer power on
Xiaomi Computer power off

• 工厂方法模式

工厂方法模式将工厂类抽象出来，由具体的子工厂类实现相应的接口，从而通过具体的工厂类创建相应的具体对象。
UML类图如下：

工厂抽象类：

package factory.factoryMethod;

import factory.model.Computer;


public abstract class ComputerFactory {

    protected abstract Computer create();
}

具体工厂实现，不同的工厂负责创建相应的具体对象：

package factory.factoryMethod;

import factory.model.Computer;
import factory.model.HuaweiComputer;

public class HuaweiComputerFactory extends ComputerFactory {
    protected Computer create() {
        return new HuaweiComputer();
    }
}

package factory.factoryMethod;

import factory.model.Computer ;
import factory.model.XiaomiComputer;

public class XiaomiComputerFactory extends ComputerFactory {
    protected Computer create() {
        return new XiaomiComputer();
    }
}

Client客户端：

package factory.factoryMethod;

import factory.model.Computer ;

public class Client {

    public static void main(String[] args) {
        Computer computer = new HuaweiComputerFactory().create();
        computer.powerOn();
        computer.powerOff();
        Computer computer1 = new XiaomiComputerFactory().create();
        computer1.powerOn();
        computer1.powerOff();
    }
}
// 结果
Huawei Computer power on
Huawei Computer power off
Xiaomi Computer power on
Xiaomi Computer power off

• 抽象工厂模式

假设Huawei电脑和Xiaomi电脑两个品牌都能够生产笔记本电脑和台式电脑。在抽象工厂模式中，一个具体工厂类具备生产多种类型产品的能力。例如在本例子中，Huawei电脑工厂类能够生产台式电脑和笔记本电脑。
UML类图：

首先定义具体产品类：

package factory.abstractFactory.model;


/**
 *  电脑：开机，关机
 */
public interface Computer {

    void powerOn();

    void powerOff();
}

台式电脑：

package factory.abstractFactory.model;

public abstract class DesktopComputer implements Computer {
    public abstract void powerOn();

    public abstract void powerOff();
}

package factory.abstractFactory.model;

public class HuaweiDesktopComputer extends DesktopComputer {
    @Override
    public void powerOn() {
        System.err.println("HuaweiDesktopComputer power on");
    }

    @Override
    public void powerOff() {
        System.err.println("HuaweiDesktopComputer power off");
    }
}

package factory.abstractFactory.model;

public class XiaomiDesktopComputer extends DesktopComputer {
    @Override
    public void powerOn() {
        System.err.println("XiaomiDesktopComputer power on");
    }

    @Override
    public void powerOff() {
        System.err.println("XiaomiDesktopComputer power off");
    }
}

笔记本电脑：

package factory.abstractFactory.model;

public abstract class NoteBookComputer implements Computer {
    public abstract void powerOn();

    public abstract void powerOff();
}

package factory.abstractFactory.model;

public class HuaweiNoteBookComputer extends NoteBookComputer {
    @Override
    public void powerOn() {
        System.err.println("HuaweiNoteBookComputer power on");
    }

    @Override
    public void powerOff() {
        System.err.println("HuaweiNoteBookComputer power off");
    }
}

package factory.abstractFactory.model;

public class XiaomiNoteBookComputer extends NoteBookComputer {
    @Override
    public void powerOn() {
        System.err.println("XiaomiNoteBookComputer power on");
    }

    @Override
    public void powerOff() {
        System.err.println("XiaomiNoteBookComputer power off");
    }
}

抽象工厂类，定义了生产台式电脑和笔记本电脑的抽象方法，由不同品牌的具体工厂类实现：

package factory.abstractFactory;

import factory.abstractFactory.model.Computer;

public abstract class AbstractComputerFactory {

    public abstract Computer createDesktopComputer();

    public abstract Computer createNoteBookComputer();
}

Huawei工厂类：

package factory.abstractFactory;

import factory.abstractFactory.model.Computer;
import factory.abstractFactory.model.HuaweiDesktopComputer;
import factory.abstractFactory.model.HuaweiNoteBookComputer;

public class HuaweiComputerFactory extends AbstractComputerFactory {
    public Computer createDesktopComputer() {
        return new HuaweiDesktopComputer();
    }

    public Computer createNoteBookComputer() {
        return new HuaweiNoteBookComputer();
    }
}

Xiaomi工厂类：

package factory.abstractFactory;

import factory.abstractFactory.model.Computer;
import factory.abstractFactory.model.XiaomiDesktopComputer;
import factory.abstractFactory.model.XiaomiNoteBookComputer;

public class XiaomiComputerFactory extends AbstractComputerFactory {
    public Computer createDesktopComputer() {
        return new XiaomiDesktopComputer();
    }

    public Computer createNoteBookComputer() {
        return new XiaomiNoteBookComputer();
    }
}

Client客户端：

package factory.abstractFactory;

import factory.abstractFactory.model.Computer;

public class Client {

    public static void main(String[] args) {
        HuaweiComputerFactory huaweiComputerFactory = new HuaweiComputerFactory();
        Computer desktopComputer = huaweiComputerFactory.createDesktopComputer();
        desktopComputer.powerOn();
        desktopComputer.powerOff();
        Computer noteBookComputer = huaweiComputerFactory.createNoteBookComputer();
        noteBookComputer.powerOn();
        noteBookComputer.powerOff();

        XiaomiComputerFactory XiaomiComputerFactory = new XiaomiComputerFactory();
        Computer desktopComputer1 = XiaomiComputerFactory.createDesktopComputer();
        desktopComputer1.powerOn();
        desktopComputer1.powerOff();
        Computer noteBookComputer1 = XiaomiComputerFactory.createNoteBookComputer();
        noteBookComputer1.powerOn();
        noteBookComputer1.powerOff();
    }
}
// 结果
HuaweiDesktopComputer power on
HuaweiDesktopComputer power off
HuaweiNoteBookComputer power on
HuaweiNoteBookComputer power off
XiaomiDesktopComputer power on
XiaomiDesktopComputer power off
XiaomiNoteBookComputer power on
XiaomiNoteBookComputer power off