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

Posted 2022-12-05 凌星An

文章目录

• 建造者模式
• • 介绍
  • 类图：
  • 代码实现：
  • • 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、需要生成的对象内部属性本身相互依赖。

与工厂模式的区别

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