工厂模式
工厂模式(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
}