工厂方法模式
什么是工厂方法模式
工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化推迟到其子类。
这个接口就是工厂接口，子类就是具体工厂类，而需要创建的对象就是产品对象。客户端代码只需要调用工厂接口的方法，而无需关心具体的产品对象是如何创建的。
用于创建对象的过程中将实例化的逻辑封装在一个工厂方法中。
把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。
在 Go 语言中，工厂方法模式经常被用于对象的创建和初始化。
工厂方法模式的主要优点有：
用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程（对创建过程复杂的对象很有作用）；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
其缺点是：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
角色
工厂方法模式包含四个主要角色：
- 抽象产品类（Product）
- 具体产品类（ConcreteProduct）
- 抽象工厂接口（Factory）
- 具体工厂类（ConcreteFactory）
抽象产品类定义了产品的接口。
具体产品类实现了具体的产品逻辑。
抽象工厂类定义了创建产品的接口。
具体工厂类实现了具体的产品创建逻辑。
工厂方法代码
工厂方法模式举例
场景:
创建狗子的案例:
创建狗子的接口工厂(接口MakeDogs)
创建狗子具体工厂(实现上面的接口)
狗子接口（sleep()、run()）
泰迪、柴犬（具体的狗子）
抽象产品类:
type IDog interface {
Sleep()
Run()
}
具体产品类:
柴犬:
// 柴犬
type ChaiDog struct {
}
func (c ChaiDog) Sleep() {
fmt.Println("睡觉")
}
func (c ChaiDog) Run() {
fmt.Println("奔跑")
}
泰迪:
// 泰迪
type Teddy struct {
}
func (t Teddy) Sleep() {
fmt.Println("睡觉")
}
func (t Teddy) Run() {
fmt.Println("奔跑")
}
抽象工厂类（接口工厂）:
创建狗子的抽象接口
type IDogFactory interface {
MakeDogs(dogType string) IDog
}
具体工厂类:
type DogFactory struct {
}
// 工厂方法,这是一个特殊的方法,用来创建不同的狗子
func (d DogFactory) MakeDogs(dogType string) IDog {
if dogType == "teddy" {
return &Teddy{}
}
if dogType == "chaidog" {
return &ChaiDog{}
}
return nil
}
场景类:
func main() {
factory := &DogFactory{}
// 传入teddy，产生对应的狗子
t := factory.MakeDogs("teddy")
t.Sleep()
t.Run()
// 传入chaidog，产生对应的狗子
c := factory.MakeDogs("chaidog")
c.Sleep()
c.Run()
}
简单工厂方法代码
缩小为简单工厂模式。
一个模块仅需要一个工厂类，没有必要把它实例化出来。java使用静态方法就可以了。
场景:
创建狗子的案例:
没有创建狗子的接口工厂
创建狗子的具体工厂(MakeDogs())
狗子接口（sleep()、run()）
泰迪、柴犬（具体的狗子）
抽象产品类:
type IDog interface {
Sleep()
Run()
}
具体产品类:
柴犬:
// 柴犬
type ChaiDog struct {
}
func (c ChaiDog) Sleep() {
fmt.Println("睡觉")
}
func (c ChaiDog) Run() {
fmt.Println("奔跑")
}
泰迪:
// 泰迪
type Teddy struct {
}
func (t Teddy) Sleep() {
fmt.Println("睡觉")
}
func (t Teddy) Run() {
fmt.Println("奔跑")
}
抽象工厂类（接口工厂）:
去掉。
具体工厂类:
// 工厂方法,这是一个特殊的方法,用来创建不同的狗子
func MakeDogs(dogType string) IDog {
if dogType == "teddy" {
return &Teddy{}
}
if dogType == "chaidog" {
return &ChaiDog{}
}
return nil
}
场景类:
func main() {
t := ex.MakeDogs("teddy")
t.Sleep()
t.Run()
c := ex.MakeDogs("chaidog")
c.Sleep()
c.Run()
}
工厂方法代码3
升级为多个工厂类。
假如有1个产品类有5个具体实现，每个实现类的初始化方法都不相同，如果写在一个工厂方法中，会导致这个方法巨大无比。
为每一个产品定义一个创建者。
创建狗子的案例:
创建狗子的接口工厂（MakeDogs()）
创建泰迪狗子的具体工厂（实现上面的接口）
创建泰迪柴犬的具体工厂（实现上面的接口）
狗子接口（sleep()、run()）
泰迪、柴犬（具体的狗子）
接口工厂类:
type IDogFactory interface {
// 无需再传递参数了
MakeDogs() IDog
}
抽象产品类:
type IDog interface {
Sleep()
Run()
}
具体产品类:
柴犬:
// 柴犬
type ChaiDog struct {
}
func (c ChaiDog) Sleep() {
fmt.Println("睡觉")
}
func (c ChaiDog) Run() {
fmt.Println("奔跑")
}
泰迪:
// 泰迪
type Teddy struct {
}
func (t Teddy) Sleep() {
fmt.Println("睡觉")
}
func (t Teddy) Run() {
fmt.Println("奔跑")
}
具体工厂:
// 创建柴犬的具体工厂
type ChaiDogFactory struct {
}
func (c ChaiDogFactory) MakeDogs() IDog {
return &ChaiDog{}
}
// 创建柴犬的具体工厂
type ChaiDogFactory struct {
}
func (c ChaiDogFactory) MakeDogs() IDog {
return &ChaiDog{}
}
场景类:
func main() {
f1 := &example.TeddyFactory{}
dog1 := f1.MakeDogs()
dog1.Sleep()
dog1.Run()
f2 := &example.ChaiDogFactory{}
dog2 := f2.MakeDogs()
dog2.Sleep()
dog2.Run()
}