Go教程

[设计模式、C++、go]创建型模式:建造者模式

本文主要是介绍[设计模式、C++、go]创建型模式:建造者模式,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

  • 建造者模式
    • 介绍
    • 类图:
    • 代码实现:
      • C++
        • 测试
      • go
        • 测试
    • 优缺点
    • 使用场景
    • 与工厂模式的区别

建造者模式

介绍

建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象

定义: Separate the construction of a complex object from its
representation sothat the same construction process can create
different representations.(将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。)

主要解决: 主要解决在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。
何时使用: 一些基本部件不会变,而其组合经常变化的时候。
如何解决: 将变与不变分离开。
关键代码:
建造者:创建和提供实例,
导演:管理建造出来的实例的依赖关系。

类图:

在这里插入图片描述
Product:产品类,通常是实现了模板方法模式,也就是有模板方法和基本方法
Builder:抽象建造者(抽象类或接口),规范产品的组件,一般是由子类实现
ConcreteBuilder: 具体建造者,实现抽象建造者定义的所有方法,并且返回一个组件好的对象
Director: 导演类,负责安排已有模块的顺序,然后告诉Builder开始建造

代码实现:

如果我们要组装一批iPhone手机和OPPO手机:
倘若组装过程主要分为两部:组装、外观设计
而这两种手机的步骤不太一样
iPhone:组装、外观设计(印品牌logo、外观上色)
OPPO:组装、外观设计(外观上色、印品牌logo)

C++

class PhoneBuilder{
public:
	virtual void Package() = 0;
	virtual void Design() = 0;
	
	std::string GetResult(){
		return _phone;
	}
protected:
	 void Logo() ;
	 void Color() ;
protected:
	std::string _phone;
};

class iPhone :public PhoneBuilder{
public:
	void Package(){
		_phone += "packing\n";
	}
	void Design(){
		Logo();
		Color();
	}
	std::string GetResult(){
		return _phone;
	}
protected:
	void Logo(){
		_phone += "Logo iPhone\n";
	}
	void Color(){
		_phone += "Set Red color\n";
	}
	
};

class OPPO :public PhoneBuilder{
public:
	void Package(){
		_phone += "Packing\n";
	}
	void Design(){
		Color();
		Logo();
	}
	std::string GetResult(){
		return _phone;
	}
protected:
	void Logo(){
		_phone += "Logo OPPO\n";
	}
	void Color(){
		_phone += "Set white color\n";
	}
	
};

class PhoneDirector{
public:
	void Package(PhoneBuilder* o){
		o->Package();
		o->Design();
	}
	
};



测试

    PhoneDirector pd;
	PhoneBuilder* o=new OPPO;
	pd.Package(o);
	
	std::cout << o->GetResult() << std::endl;
	
	PhoneBuilder* i = new iPhone;
	pd.Package(i);
	std::cout << i->GetResult() << std::endl;

go

package Builder

type PhoneBuilder interface{
   Package()
   Design()
   GetResult()string
}

type phone struct{
     _phone string
}

func (p *phone)GetResult()string{
     return p._phone
}

type IPhone struct{
    phone
}

func (p *IPhone)Package(){
   p._phone +="Packaging iPhone\n"
}

func (p *IPhone)Design(){
    p.logo()
    p.color()
}

func (p *IPhone)logo(){
    p._phone +="Logo iPhone\n"
}

func (p *IPhone)color(){
    p._phone += "Set red color\n"
}
type OPPO struct{
    phone
}

func (p *OPPO)Package(){
   p._phone +="Packaging OPPO\n"
}

func (p *OPPO)Design(){
    p.logo()
    p.color()
}

func (p *OPPO)logo(){
    p._phone +="Logo OPPO\n"
}

func (p *OPPO)color(){
    p._phone += "Set white color\n"
}


type PhoneDirectorInterface interface{
      Produce(pb PhoneBuilder)
}

type PhoneDirectorStruct struct{
}

func (p *PhoneDirectorStruct)Produce(pb PhoneBuilder){
       pb.Package()
       pb.Design()
}

测试

package main

import (
   "fmt"
  b "Builder"
)


func main(){
    pd :=b.PhoneDirectorStruct{}
    fmt.Println("Produce iPhone")
    iphone :=&b.IPhone{}
    pd.Produce(iphone)
    fmt.Println(iphone.GetResult())
    fmt.Println("Produce OPPO")
    oppo :=&b.OPPO{}
    pd.Produce(oppo)
    fmt.Println(oppo.GetResult())


}

优缺点

优点:
1、建造者独立,易扩展。
2、便于控制细节风险。
由于具体的建造者是独立的,因此对建造过程逐步细化,不会对其他模块产生任何影响

缺点:
1、产品必须有共同点,范围有限制。
2、如内部变化复杂,会有很多的建造类。

使用场景

1、需要生成的对象具有复杂的内部结构。
2、需要生成的对象内部属性本身相互依赖。

与工厂模式的区别

注意事项:
与工厂模式的区别是:建造者模式更加关注与零件装配的顺序。

这篇关于[设计模式、C++、go]创建型模式:建造者模式的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!