Go和Java实现工厂方法模式

本文通过计算器案例来说明工厂方法模式的使用，使用Go语言和Java语言实现。

1、工厂方法模式

工厂方法模式是最常用的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方

式。

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

的对象。

• 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂方法模式使其创建过程延迟到

  子类进行。

• 主要解决：主要解决接口选择的问题。

• 何时使用：我们明确地计划不同条件下创建不同实例时。

• 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

• 关键代码：创建过程在其子类执行。

• 应用实例：1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个

  汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

• 优点：1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只

  要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

• 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定

  程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

• 使用场景：1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到

  什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计

  一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一

  个接口。

• 注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注

  意的地方就是复杂对象适合使用工厂方法模式，而简单对象，特别是只需要通过 new 就可以完成创建的对

  象，无需使用工厂方法模式。如果使用工厂方法模式，就需要引入一个工厂类，会增加系统的复杂度。

• 适用性：1、当一个类不知道它所必须创建的对象的类的时候。2、当一个类希望由它的子类来指定它所创建

  的对象的时候。3、当类将创建对象的职责委托给多个帮助子类中的某一个，并且类希望将哪一个帮助子类是

  代理者这一信息局部化的时候。

简单说工厂方法模式就是为了提供代码结构的扩展性，屏蔽每⼀个功能类中的具体实现逻辑，让外部可以更加简单

的只是知道调⽤即可，同时这也是去掉众多 ifelse 的⽅式。

2、Go实现简单计算器

下面实现一个简单的计算器，包含简单的加减乘除功能。

package factory// 这里实现一个简单的计算器
// 计算接口,包含计算数的设置和结果的计算
type Operation interface {// 设置进行计算的两个数SetNumberA(float64)SetNumberB(float64)// 计算Calculate() (float64, error)
}

package factory// ============加法===========
type AddOperation struct {// 包含两个操作数numberA float64numberB float64
}func (addOperation *AddOperation) Calculate() (float64, error) {return addOperation.numberA + addOperation.numberB, nil
}func (addOperation *AddOperation) SetNumberA(numberA float64) {addOperation.numberA = numberA
}func (addOperation *AddOperation) SetNumberB(numberB float64) {addOperation.numberB = numberB
}

package factory// ============减法============
type SubOperation struct {// 包含两个操作数numberA float64numberB float64
}func (subOperation *SubOperation) Calculate() (float64, error) {return subOperation.numberA - subOperation.numberB, nil
}func (subOperation *SubOperation) SetNumberA(numberA float64) {subOperation.numberA = numberA
}func (subOperation *SubOperation) SetNumberB(numberB float64) {subOperation.numberB = numberB
}

package factory// ============乘法============
type MulOperation struct {// 包含两个操作数numberA float64numberB float64
}func (mulOperation *MulOperation) Calculate() (float64, error) {return mulOperation.numberA * mulOperation.numberB, nil
}func (mulOperation *MulOperation) SetNumberA(numberA float64) {mulOperation.numberA = numberA
}func (mulOperation *MulOperation) SetNumberB(numberB float64) {mulOperation.numberB = numberB
}

package factoryimport "errors"// ============除法============
type DivOperation struct {// 包含两个操作数numberA float64numberB float64
}func (divOperation *DivOperation) Calculate() (float64, error) {if divOperation.numberB == 0 {return -1, errors.New("被除数不能为0")} else {return divOperation.numberA / divOperation.numberB, nil}
}func (divOperation *DivOperation) SetNumberA(numberA float64) {divOperation.numberA = numberA
}func (divOperation *DivOperation) SetNumberB(numberB float64) {divOperation.numberB = numberB
}

package constantconst (Add = "+"Sub = "-"Mul = "*"Div = "/"
)

package factoryimport "proj/constant"// ============工厂接口============
type OperationFactory interface {CreateOperate() Operation
}// ============加法工厂类============
type AddFactory struct {
}func (addFactory *AddFactory) CreateOperate() Operation {return &AddOperation{}
}// ============减法工厂类============
type SubFactory struct {
}func (subFactory *SubFactory) CreateOperate() Operation {return &SubOperation{}
}// ============乘法工厂类============
type MulFactory struct {
}func (mulFactory *MulFactory) CreateOperate() Operation {return &MulOperation{}
}// ============除法工厂类============
type DivFactory struct {
}func (divFactory *DivFactory) CreateOperate() Operation {return &DivOperation{}
}// 用一个简单工厂封装工厂方法
type OperationFactoryCreate struct {
}func (operationFactoryCreate *OperationFactoryCreate) NewOperationFactory(operate string) OperationFactory {switch operate {case constant.Add:return &AddFactory{}case constant.Sub:return &SubFactory{}case constant.Mul:return &MulFactory{}case constant.Div:return &DivFactory{}}return nil
}

package mainimport ("fmt""proj/constant"
)import . "proj/factory"// 测试
func main() {// 全局变量var numberA float64 = 200var numberB float64 = 100var operationFactory OperationFactoryvar operation Operationvar result float64var err error// ============加法============operationFactory = &AddFactory{}operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Add Result:", result)}// ============减法============operationFactory = &SubFactory{}operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Sub Result:", result)}// ============乘法============operationFactory = &MulFactory{}operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Mul Result:", result)}// ============除法============operationFactory = &DivFactory{}operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Div Result:", result)}fmt.Println("========================")// 简单工厂封装工厂方法operationFactoryCreate := OperationFactoryCreate{}// ============加法============operationFactory = operationFactoryCreate.NewOperationFactory(constant.Add)operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Add Result:", result)}// ============减法============operationFactory = operationFactoryCreate.NewOperationFactory(constant.Sub)operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Sub Result:", result)}// ============乘法============operationFactory = operationFactoryCreate.NewOperationFactory(constant.Mul)operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Mul Result:", result)}// ============除法============operationFactory = operationFactoryCreate.NewOperationFactory(constant.Div)operation = operationFactory.CreateOperate()operation.SetNumberA(numberA)operation.SetNumberB(numberB)result, err = operation.Calculate()if err != nil {fmt.Println(err)} else {fmt.Println("Div Result:", result)}
}

# 程序输出
Add Result: 300
Sub Result: 100
Mul Result: 20000
Div Result: 2
========================
Add Result: 300
Sub Result: 100
Mul Result: 20000
Div Result: 2

3、Java实现简单计算器

package com.factory;// 这里实现一个简单的计算器
// 计算接口,包含计算数的设置和结果的计算
public abstract class Operation {private double numberA;private double numberB;// 设置进行计算的两个数public double getNumberA() {return numberA;}public void setNumberA(double numberA) {this.numberA = numberA;}public double getNumberB() {return numberB;}public void setNumberB(double numberB) {this.numberB = numberB;}// 计算public abstract double Calculate();
}

package com.factory;// ============加法===========
public class AddOperation extends Operation {@Overridepublic double Calculate() {return this.getNumberA() + this.getNumberB();}
}

package com.factory;// ============减法============
public class SubOperation extends Operation {@Overridepublic double Calculate() {return this.getNumberA() - this.getNumberB();}
}

package com.factory;// ============乘法============
public class MulOperation extends Operation {@Overridepublic double Calculate() {return this.getNumberA() * this.getNumberB();}
}

package com.factory;// ============除法============
public class DivOperation extends Operation {@Overridepublic double Calculate() {if (this.getNumberB() == 0) {throw new RuntimeException("被除数不能为0!");} else {return this.getNumberA() / this.getNumberB();}}
}

package com.factory;public enum OperationType {ADD, SUB, MUL, DIV;
}

package com.factory;// ============工厂接口============
public interface OperationFactory {Operation CreateOperate();
}

package com.factory;// ============加法工厂类============
public class AddFactory implements OperationFactory {@Overridepublic Operation CreateOperate() {return new AddOperation();}
}

package com.factory;// ============减法工厂类============
public class SubFactory implements OperationFactory {@Overridepublic Operation CreateOperate() {return new SubOperation();}
}

package com.factory;// ============乘法工厂类============
public class MulFactory implements OperationFactory{@Overridepublic Operation CreateOperate() {return new MulOperation();}
}

package com.factory;// ============除法工厂类============
public class DivFactory implements OperationFactory {@Overridepublic Operation CreateOperate() {return new DivOperation();}
}

package com.factory;// 用一个简单工厂封装工厂方法
// ============工厂类============
public class OperationFactoryCreate {public OperationFactory NewOperationFactory(OperationType operate) {switch (operate) {case ADD:return new AddFactory();case SUB:return new SubFactory();case MUL:return new MulFactory();case DIV:return new DivFactory();}return null;}
}

package com.factory;public class Test {public static void main(String[] args) {// 全局变量Operation operation = null;double result = 0;OperationFactory operationFactory = null;// ============加法============operationFactory = new AddFactory();operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);// ============减法============operationFactory = new SubFactory();operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);// ============乘法============operationFactory = new MulFactory();operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);// ============除法============operationFactory = new DivFactory();operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);System.out.println("========================");// 简单工厂封装工厂方法OperationFactoryCreate operationFactoryCreate = new OperationFactoryCreate();// ============加法============operationFactory = operationFactoryCreate.NewOperationFactory(OperationType.ADD);operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);// ============减法============operationFactory = operationFactoryCreate.NewOperationFactory(OperationType.SUB);operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);// ============乘法============operationFactory = operationFactoryCreate.NewOperationFactory(OperationType.MUL);operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);// ============除法============operationFactory = operationFactoryCreate.NewOperationFactory(OperationType.DIV);operation = operationFactory.CreateOperate();operation.setNumberA(200);operation.setNumberB(100);result = operation.Calculate();System.out.println("result :" + result);}
}

# 程序输出
result :300.0
result :100.0
result :20000.0
result :2.0
========================
result :300.0
result :100.0
result :20000.0
result :2.0