设计模式之golang实现

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

/**
	多个实现了同一接口的类
	用一个工厂去实现不同的需求
 */
func main() {
	factory := ShapeFactory{}
	factory.getShape("SQUARE").Draw()
	factory.getShape("CIRCLE").Draw()
	factory.getShape("RECTANGLE").Draw()
}

//1.创建一个接口
type Shape interface {
	Draw()
}

//2.创建实现接口的实体类
type Rectangle struct {
}

func (this Rectangle) Draw()  {
	fmt.Println("Inside Rectangle::draw() method")
}
type Square struct {
}

func (this Square) Draw()  {
	fmt.Println("Inside Square::draw() method")
}
type Circle struct {
}

func (this Circle) Draw()  {
	fmt.Println("Inside Circle::draw() method")
}

//3.工厂
type ShapeFactory struct {
}

func (this ShapeFactory) getShape(shapeType string) Shape {
	if shapeType == "CIRCLE" {
		return Circle{}
	} else if shapeType == "RECTANGLE" {
		return Rectangle{}
	} else if shapeType == "SQUARE" {
		return Square{}
	}
	return nil
}

抽象工厂模式

func main() {
	var c WorkerCreator
	c = new(ProgrammerCreator)
	p := c.Create()
	taskProject := "project"
	p.Work(&taskProject)

	c = new(FarmerCreator)
	f := c.Create()
	taskFarmland := "farmland"
	f.Work(&taskFarmland)

}
//首先定义了interface Worker，其中包含一个接口Work(task *string)
type Worker interface {
	Work(task *string)
}

//然后定义创建Worker的interface WorkerCreator，包含一个接口Create() ，返回值为Worker
type WorkerCreator interface {
	Create() Worker
}

type Programmer struct {
}

func (p *Programmer) Work(task *string)  {
	fmt.Println("Programmer process", *task)
}

type ProgrammerCreator struct {
}

func (c *ProgrammerCreator) Create() Worker {
	s := new(Programmer)
	return s
}

type Farmer struct {
}

func (f *Farmer) Work(task *string) {
	fmt.Println("Farmer process", *task)
}

type FarmerCreator struct {
}

func (c *FarmerCreator) Create() Worker {
	s := new(Farmer)
	return s
}