Go和Java实现简单工厂模式

这篇具有很好参考价值的文章主要介绍了Go和Java实现简单工厂模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Go和Java实现简单工厂模式

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

1、简单工厂模式

简单工厂模式对对象创建管理方式最为简单,只需要创建一个简单的工厂类然后在里面创建对象,该模式通过向工

厂传递类型来指定要创建的对象。

由于 Go 本身是没有构造函数的,一般而言我们采用 NewName 的方式创建对象/接口,当它返回的是接口的时

候,其实就是简单工厂模式。

2、Go实现简单计算器

下面实现一个简单的计算器,包含简单的加减乘除功能。文章来源地址https://www.toymoban.com/news/detail-558425.html

package factory

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

// ============加法===========
type AddOperation struct {
	// 包含两个操作数
	numberA float64
	numberB 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 float64
	numberB 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 float64
	numberB 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 factory

import "errors"

// ============除法============
type DivOperation struct {
	// 包含两个操作数
	numberA float64
	numberB 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 constant

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

import "proj/constant"

// ============工厂类============
type OperationFactory struct {
}

func (operationFactory *OperationFactory) CreateOperate(operate string) Operation {
	switch operate {
	case constant.Add:
		return &AddOperation{}
	case constant.Sub:
		return &SubOperation{}
	case constant.Mul:
		return &MulOperation{}
	case constant.Div:
		return &DivOperation{}
	}
	return nil
}
package main

import "fmt"
import . "proj/factory"
import "proj/constant"

// 测试
func main() {

	// 全局变量
	var numberA float64 = 200
	var numberB float64 = 100
	var operation Operation
	var result float64
	var err error

	// ============创建工厂============
	operationFactory := OperationFactory{}

	// ============加法============
	operation = operationFactory.CreateOperate(constant.Add)
	operation.SetNumberA(numberA)
	operation.SetNumberB(numberB)
	result, err = operation.Calculate()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("Add Result:", result)
	}

	// ============减法============
	operation = operationFactory.CreateOperate(constant.Sub)
	operation.SetNumberA(numberA)
	operation.SetNumberB(numberB)
	result, err = operation.Calculate()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("Sub Result:", result)
	}

	// ============乘法============
	operation = operationFactory.CreateOperate(constant.Mul)
	operation.SetNumberA(numberA)
	operation.SetNumberB(numberB)
	result, err = operation.Calculate()
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("Mul Result:", result)
	}

	// ============除法============
	operation = operationFactory.CreateOperate(constant.Div)
	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

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 {

    @Override
    public double Calculate() {
        return this.getNumberA() + this.getNumberB();
    }
}
package com.factory;

// ============减法============
public class SubOperation extends Operation {

    @Override
    public double Calculate() {
        return this.getNumberA() - this.getNumberB();
    }
}
package com.factory;

// ============乘法============
public class MulOperation extends Operation {

    @Override
    public double Calculate() {
        return this.getNumberA() * this.getNumberB();
    }
}
package com.factory;

// ============除法============
public class DivOperation extends Operation {

    @Override
    public 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 class OperationFactory {

    public Operation CreateOperate(OperationType operate) {
        switch (operate) {
            case ADD:
                return new AddOperation();
            case SUB:
                return new SubOperation();
            case MUL:
                return new MulOperation();
            case DIV:
                return new DivOperation();
        }
        return null;
    }
}
package com.factory;

public class Test {

    public static void main(String[] args) {

        // 全局变量
        Operation operation = null;
        double result = 0;

        // ============创建工厂============
        OperationFactory operationFactory = new OperationFactory();

        // ============加法============
        operation = operationFactory.CreateOperate(OperationType.ADD);
        operation.setNumberA(200);
        operation.setNumberB(100);
        result = operation.Calculate();
        System.out.println("result :" + result);

        // ============减法============
        operation = operationFactory.CreateOperate(OperationType.SUB);
        operation.setNumberA(200);
        operation.setNumberB(100);
        result = operation.Calculate();
        System.out.println("result :" + result);

        // ============乘法============
        operation = operationFactory.CreateOperate(OperationType.MUL);
        operation.setNumberA(200);
        operation.setNumberB(100);
        result = operation.Calculate();
        System.out.println("result :" + result);

        // ============除法============
        operation = operationFactory.CreateOperate(OperationType.DIV);
        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

到了这里,关于Go和Java实现简单工厂模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java设计模式-简单工厂(Simple Factory)模式

    简单工厂(Simple Factory)模式,又称为静态工厂方法(Static Factory Method)模式。 由一个工厂类来创建具体产品,即创建具体类的实例。 简单工厂模式从概念上涉及三个角色: 抽象产品角色:是具体类的父类,规定了所有类的共同行为。一般是抽象类、或者接口。 具体产品角

    2024年02月16日
    浏览(38)
  • 用Rust实现23种设计模式之简单工厂

    在 Rust 中,可以使用结构体和 trait 来实现工厂方法模式。工厂方法模式是一种创建型设计模式,通过定义一个创建对象的接口,让子类决定实例化哪个类。下面是一个简单的示例,展示了如何使用 Rust 实现工厂方法模式: 在上述示例中,我们首先定义了一个 Product trait,它定

    2024年02月14日
    浏览(54)
  • 【C++设计模式】用简单工厂模式实现按汽车重量输出汽车类型

    2023年8月24日,周四凌晨  

    2024年02月11日
    浏览(45)
  • Go和Java实现简单工厂模式

    本文通过计算器案例来说明简单工厂模式的使用,使用Go语言和Java语言实现。 简单工厂模式对对象创建管理方式最为简单,只需要创建一个简单的工厂类然后在里面创建对象,该模式通过向工 厂传递类型来指定要创建的对象。 由于 Go 本身是没有构造函数的,一般而言我们采

    2024年02月15日
    浏览(34)
  • [设计模式Java实现附plantuml源码~创建型] 多态工厂的实现——工厂方法模式

    前言: 为什么之前写过Golang 版的设计模式,还在重新写 Java 版? 答:因为对于我而言,当然也希望对正在学习的大伙有帮助。Java作为一门纯面向对象的语言,更适合用于学习设计模式。 为什么类图要附上uml 因为很多人学习有做笔记的习惯,如果单纯的只是放一张图片,那

    2024年01月21日
    浏览(42)
  • 自学设计模式(简单工厂模式、工厂模式、抽象工厂模式)

    使用工厂模式来生产某类对象(代码简化且容易维护,类之间有血缘关系,可以通过工厂类进行生产); 简单工厂模式(用于创建简单对象) 对于简单工厂模式,需要的工厂类只有一个; 在工厂类中的公共成员函数来创建所需对象; 工厂模式 简单工厂模式会违反开放封闭

    2024年02月11日
    浏览(41)
  • 设计模式(二)、工厂模式--简单工厂模式

    简单工厂模式:又叫做静态工厂方法模式,是由一个工厂对象决定创建出哪一种产品类的实例。 需要注意的是:简单工厂模式属于创建型模式,但不属于23种GOF设计模式之一  该模式主要有以下几个模块构成: 具体说明结合代码,如下: 代码中主要是有一个cake接父类,两个

    2024年02月13日
    浏览(48)
  • 《golang设计模式》第一部分·创建型模式-04-抽象工厂模式(Abstract Factory)

    在不具体指定产品类的情况下,为相互关联的产品簇或产品集提供创建接口,并向客户隐藏具体产品创建的细节或表示的对象。 AbstractFactory(抽象工厂):它声明了一组用于创建产品的方法,每一个方法对应一种产品。 ConcreteFactory(具体工厂):它实现了在抽象工厂中声明

    2024年02月14日
    浏览(43)
  • 设计模式(简单工厂模式)

    从建筑设计领域引入到计算机科学中 设计模式一共有23种 代码设计经验的总结,稳定,拓展性更强。一系列编程思想 作用:代码更容易被他人理解、保证代码可靠性、程序的重用性。 详细介绍:[https://www.runoob.com/design-pattern/design-pattern-tutorial.html]: 学习简单工厂模式的目的:

    2024年02月13日
    浏览(42)
  • 设计模式-简单工厂模式

    简单工厂模式又称为静态工厂模式,其实就是根据传入参数创建对应具体类的实例并返回实例对象,这些类通常继承至同一个父类,该模式专门定义了一个类来负责创建其他类的实例。  这就是工厂类,提供一个方法创建具体类的实例 优点:将对象的创建于使用分离,创建完

    2024年02月12日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包