建造者模式

建造者（Builder）模式的主要角色如下。

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
2. 抽象建造者（Abstract Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

package builder

import "fmt"

/**
 * 业务场景: 农民种菜,村里安排农民收菜
 * 产品:韭菜
 * 抽象建造者:人
 * 具体建造者:农民伯伯
 * 指挥者:村
 */
//韭菜
type Leek struct {
}

// 韭菜建造者抽象-农民
type PeasantInter interface {
	Water() error         // 浇水
	Fertilization() error // 施肥
	Reap() *Leek          // 收割
}

// 建造者实体 - 农民
type Peasant struct {
}

func (p *Peasant) Water() error {
	fmt.Println("给韭菜浇水")
	return nil
}
func (p *Peasant) Fertilization() error {
	fmt.Println("给韭菜施肥")
	return nil
}
func (p *Peasant) Reap() *Leek {
	fmt.Println("收割韭菜")
	return &Leek{}
}

// 指挥者 - 农村
type Village struct {
	peasant Peasant
}

func (v *Village) SetF(p Peasant) {
	v.peasant = p
}

func (v *Village) getProduct() *Leek {
	return v.peasant.Reap()
}

// 开始指挥建造者割韭菜
func (v *Village) Gen() *Leek {
	v.peasant.Water()
	v.peasant.Fertilization()
	return v.peasant.Reap()
}

桥接

• abstractioin

定义抽象类的接口 –维护一个指向Implementor类型对象的指针

• RefinedAbstraction

扩充由abstraction定义的接口

• Implementor

定义实现类的接口，该接口不一定要与abstraction的接口完全一致；事实上这两个接口也可以完全不同。一般来讲，implementor接口仅提供基本操作，而abstraction定义了基于这些操作的较高层次的操作。

• ConcreteImplementor

实现Implementor接口并定义它的具体实现。

package main

import (
    "fmt"
)

type Company interface {
    Runing()
}

type BigCompany struct {
    Worker
}

func (pB *BigCompany) Running() {
    fmt.Println("员工都是螺丝钉")
    pB.Worker.Leaving()
    fmt.Println("员工跑路后随时可以找人顶替")
}

type SmallCompany struct {
    Worker
}

func (pS *SmallCompany) Running() {
    fmt.Println("随便一个员工都是骨干")
    pS.Worker.Leaving()
    fmt.Println("员工跑路后，公司运转受阻")
}

type Worker interface {
    Leaving()
}

type GoodWorker struct {
}

func (pG *GoodWorker) Leaving() {
    fmt.Println("好员工跑路后")
}

type NormalWorker struct {
}

func (pN *NormalWorker) Leaving() {
    fmt.Println("普通员工跑路后")
}

func main() {
    pgoodworker := &GoodWorker{}
    pnormalworker := &NormalWorker{}
    pbigCompany := &BigCompany{Worker: pgoodworker}
    pbigCompany.Running()
    pbigCompany2 := &BigCompany{Worker: pnormalworker}
    pbigCompany2.Running()
    psmallCompany := &SmallCompany{Worker: pgoodworker}
    psmallCompany.Running()
    psmallCompany2 := &SmallCompany{Worker: pnormalworker}
    psmallCompany2.Running()

    return
}

状态模式

状态机