工厂模式是一种非常常用的创建型设计模式，其提供了创建对象的最佳方式。在创建对象时，不会对客户端暴露对象的创建逻辑，而是通过使用共同的接口来创建对象。
工厂模式分类
工厂模式可以分为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
