设计模式学习笔记-创建型模式

设计模式golang-创建型模式

一、工厂模式

1.作用

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

2.举例

1、定义接口

//笔
type pen interface {
	//写字
	Write()
}

2、创建实现接口的结构体

type pencil struct {
}

func (p *pencil) Write() {
	fmt.Println("铅笔")
}

type brushPen struct {
}

func (p *brushPen) Write() {
	fmt.Println("毛笔")
}

3、创建工厂

//工厂
type PenFactory struct {
}

4、使用该工厂，通过传递类型信息来获取实体类

func (this PenFactory) Produce(typ string) pen {
	switch typ {
	case "pencil":
		return this.ProducePencil()
	case "brush":
		return this.ProduceBrushPen()
	default:
		return nil
	}
}

func (PenFactory) ProducePencil() pen {
	return new(pencil)
}

func (PenFactory) ProduceBrushPen() pen {
	return new(brushPen)
}

二、抽象工厂模式

1.作用

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

2.举例

1、创建抽象工厂-某一类型产品

//抽象工厂
type AbstractFactory interface {
	Produce() pen //生产笔
}

2、创建多个实际工厂-这一类型产品下的具体多个产品

type PencilFactory struct {
}

func (PencilFactory) Produce() pen {
	return new(pencil)
}

type BrushPen struct {
}

func (BrushPen) Produce() pen {
	return new(brushPen)
}

三、单例模式

1.作用

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

2.举例

1、方式一（定义全局变量）

type Singleton interface {
	SaySomething()
}

type singleton struct {
}

func (singleton) SaySomething() {
	fmt.Println("Singleton")
}

var singletonInstance Singleton

func NewSingletonInstance() Singleton {
	if nil == singletonInstance {
		singletonInstance = &singleton{}
	}
	return singletonInstance
}

2、方式二（采用init（）方法全局之实例化一次） 推荐使用！

type Singleton2 interface {
	SaySomething()
}

type singleton2 struct {
}

func (singleton2) SaySomething() {
	fmt.Println("Singleton")
}

var singletonInstance2 Singleton2

func init() {
	singletonInstance2 = new(singleton2)
}

四、建造者模式

1.作用

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

2.举例

1、创建接口

type Item interface {
	Price() float32   //价钱
	Name() string     //名称
	Category() string //类别
}

2、创建实现 Item 接口的实体类

//食物
type Food struct {
}

func (Food) Price() float32 {
	return 0.0
}
func (Food) Name() string {
	return ""
}
func (Food) Category() string {
	return "food"
}

五、原型模式

1.作用

• 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
• 用于创建重复的对象，同时又能保证性能。

2.举例

1、创建Cloneable 接口

type Cloneable interface {
	Clone() interface{}
}

2、定义结构体，并实现Cloneable 接口

type Context struct {
}

func (this *Context) Clone() interface{} {
	new_obj := (*this)
	return &new_obj
}

3、创建原型池

• AddContext 方法将不同的实现类存入到map中，每个实现类定义一个传递类型
• GetContext 通过传递类型信息来获取对应的实体类，而不需要重复创建

//原型池
type ContextPool map[string]*Context

func (this *ContextPool) AddContext(key string, val *Context) {
	(*this)[key] = val
}

func (this *ContextPool) GetContext(key string) *Context {
	val, ok := (*this)[key]
	if ok {
		return val.Clone().(*Context)
	}
	return nil
}