工厂模式
简单工厂模式
简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，属于类创建型模式
简单工厂模式专门定义一个工厂类来负责创建其他类的实例，可以根据参数的不同返回不同类的实例
注意：被创建的具体实例是有共性的，通常具有共同的父类，或是实现了同一个接口
// You can edit this code!
// Click here and start typing.
package main
// 牛排工厂
type SteakFactory struct{}
func (f *SteakFactory) NewSteak(typ string) Steak {
var s Steak
if typ == "A" {
s = &SteakA{}
} else if typ == "B" {
s = &SteakB{}
}
// 工厂也可以额外包装好
s.prepare()
s.bake()
s.pack()
return s
}
// 牛排产品 接口
type Steak interface {
prepare() error
bake() error
pack() error
delivery() error
}
// A类牛排
type SteakA struct{}
func (a *SteakA) prepare() error {
// ...
return nil
}
func (a *SteakA) bake() error {
// ...
return nil
}
func (a *SteakA) pack() error {
// ...
return nil
}
func (a *SteakA) delivery() error {
// ...
return nil
}
// B类牛排
type SteakB struct{}
func (b *SteakB) prepare() error {
// ...
return nil
}
func (b *SteakB) bake() error {
// ...
return nil
}
func (b *SteakB) pack() error {
// ...
return nil
}
func (b *SteakB) delivery() error {
// ...
return nil
}
func main() {
// 创建工厂
f := SteakFactory{}
// 生产牛排
a := f.NewSteak("A")
b := f.NewSteak("B")
// 派送牛排
a.delivery()
b.delivery()
}
// see: https://go.dev/play/p/tOomWNfU1C0
工厂方法模式
现在牛排的总类越来越多，成千上万种牛排丢到一个工厂生产，那这个工厂的实现必然非常臃肿
于是，需要将原来的工厂“拆”成很多个具体的小工厂，分别负责若干种牛排的精细化生产。比如生产甜牛排要一个工厂，生产咸牛排又是另一个工厂
这时，原来工厂创建对象的具体方法就可以抽象成为一个创建对象的接口（即工厂方法）而不是具体的实现了
// You can edit this code!
// Click here and start typing.
package main
// ---------
// 牛排工厂 接口
type SteakFactory interface {
NewSteak(typ string) Steak
}
// 牛排产品 接口
type Steak interface {
prepare() error
bake() error
pack() error
delivery() error
}
// ---------
// 具体的牛排工厂实现,只生产AB类牛排，AB类都是咸牛排
type ABSteakFactory struct{}
func (f *ABSteakFactory) NewSteak(typ string) Steak {
var s Steak
if typ == "A" {
s = &SteakA{}
} else if typ == "B" {
s = &SteakB{}
}
// 工厂也可以额外包装好
s.prepare()
s.bake()
s.pack()
return s
}
// A类牛排
type SteakA struct{}
func (a *SteakA) prepare() error {
// ...
return nil
}
func (a *SteakA) bake() error {
// ...
return nil
}
func (a *SteakA) pack() error {
// ...
return nil
}
func (a *SteakA) delivery() error {
// ...
return nil
}
// B类牛排
type SteakB struct{}
func (b *SteakB) prepare() error {
// ...
return nil
}
func (b *SteakB) bake() error {
// ...
return nil
}
func (b *SteakB) pack() error {
// ...
return nil
}
func (b *SteakB) delivery() error {
// ...
return nil
}
func main() {
// 创建工厂
f := ABSteakFactory{}
// 生产牛排
a := f.NewSteak("A")
b := f.NewSteak("B")
// 派送牛排
a.delivery()
b.delivery()
}
// see: https://go.dev/play/p/i7prWABFR2C
抽象工厂模式
现在工厂发现，可以做牛排，也可以做羊排猪排。于是工厂开始拓展业务
但是，受限于设备和原料，咸牛排工厂只能做咸羊排猪排，甜牛排工厂也只能做甜羊排猪排
我们说，一个工厂生产出的肉排，其同味道的。牛排、羊排和猪排在味道上是相关的
抽象工厂模式，提供【创建一系列相关的、或者有相互依赖关系的对象】的若干接口
抽象工厂模式中，不但工厂是抽象的，产品也是抽象的，而且有多个产品需要创建。因此，这个抽象工厂会对应到多个实际工厂，每个实际工厂负责创建多个实际产品。我们定义好工厂的接口和产品的接口，由每个具体的工厂去决定它们生产什么具体产品
// You can edit this code!
// Click here and start typing.
package main
// ---------工厂是抽象的，产品也是抽象的----
// 肉食工厂 接口
type MeetFactory interface {
NewSteak(typ string) Steak
NewPork(typ string) Pork
NewLambChop(typ string) LambChop
}
// 牛排产品 接口
type Steak interface {
prepareSteak() error
bakeSteak() error
packSteak() error
deliverySteak() error
}
// 猪排产品 接口
type Pork interface {
preparePork() error
bakePork() error
packPork() error
deliveryPork() error
}
// 羊排产品 接口
type LambChop interface {
prepareLambChop() error
bakeLambChop() error
packLambChop() error
deliveryLambChop() error
}
// ---------以下是工厂和产品的具体实现
// 具体的工厂实现: 甜肉食工厂
type SweetMeetFactory struct{}
func (f *SweetMeetFactory) NewSteak(typ string) Steak {
var s Steak
// ...
return s
}
func (f *SweetMeetFactory) NewPork(typ string) Pork {
var p Pork
// ...
return p
}
func (f *SweetMeetFactory) NewLambChop(typ string) LambChop {
var ls LambChop
// ...
return ls
}
// 具体的牛排实现: 甜A牛排
type SteakA struct{}
func (a *SteakA) prepare() error {
// ...
return nil
}
func (a *SteakA) bake() error {
// ...
return nil
}
func (a *SteakA) pack() error {
// ...
return nil
}
func (a *SteakA) delivery() error {
// ...
return nil
}
// 甜猪排实现
// 甜羊排实现
}
