简单工厂模式
由于 Go 本身是没有构造函数的，一般而言我们采用 New（） 的方式创建对象/接口，当它返回的是接口的时候，其实就是简单工厂模式
1.类图如下
工厂角色：负责实现创建所有实例的内部逻辑，工厂类可以被外界直接调用，创建所需的产品对象
抽象产品角色：简单工厂模式所创建的所有对象的父类，负责描述所有实例共有的公共接口
具体产品角色：简单工厂模式所创建的具体实例对象
2.实现代码
package main
import "fmt"
// Fruit 抽象层
type Fruit interface {
Show()
}
//实现层
type Apple struct {
}
func (a *Apple) Show() {
fmt.Println("我是苹果")
}
type Banana struct {
}
func (b *Banana) Show() {
fmt.Println("我是香蕉")
}
type Pear struct {
}
func (p *Pear) Show() {
fmt.Println("我是梨")
}
//工厂模式
type Factory struct {
}
// CreatFruit 工厂的生产器返回的是抽象的方法
func (f *Factory) CreatFruit(name string) Fruit {
var fruit Fruit
if name == "apple" {
fruit = new(Apple)
} else if name == "banana" {
fruit = new(Banana)
} else if name == "pear" {
fruit = new(Pear)
}
return fruit
}
//业务逻辑层
func main() {
factory := new(Factory)
apple := factory.CreatFruit("apple")
apple.Show()
banana := factory.CreatFruit("banana")
banana.Show()
pear := factory.CreatFruit("pear")
pear.Show()
}
3.优缺点分析
优点：
1.实现了对象创建和使用的分离。
2.不需要记住具体类名，记住参数即可
缺点：
1.增加系统中类的个数，复杂度和理解度增加。
2.违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。
适用场景：
1.工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
2.客户端只知道传入工厂类的参数，对于如何创建对象并不关心
工厂方法模式
当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂
简单工厂模式 + "开闭原则" = 工厂方法模式
1.类图如下
和简单工厂模式的区别：将工厂抽取出来，形成一个抽象的工厂，返回一个抽象的产品类
抽象工厂下有具体工厂，具体工厂实现抽象工厂的方法，返回抽象产品
业务层只需要和抽象的工厂和抽象的产品打交道
2.实现代码
package main
import "fmt"
//简单工厂+开闭原则=工厂模式
type Fruit interface {
Show()
}
type Apple struct {
}
func (a *Apple) Show() {
fmt.Println("我是苹果")
}
type Banana struct {
}
func (b *Banana) Show() {
fmt.Println("我是香蕉")
}
type Pear struct {
}
func (p *Pear) Show() {
fmt.Println("我是梨")
}
type Factory interface {
CreatFruit() Fruit
}
type AppleFactory struct {
}
func (a *AppleFactory) CreatFruit() Fruit {
var apple Fruit
apple = new(Apple)
return apple
}
type BananaFactory struct {
}
func (b *BananaFactory) CreatFruit() Fruit {
var banana Fruit
banana = new(Apple)
return banana
}
type PearFactory struct {
}
func (p *PearFactory) CreatFruit() Fruit {
var pear Fruit
pear = new(Apple)
return pear
}
func main() {
//需求：需要一个具体的苹果对象
//需要一个具体的苹果工厂
appleFactory := new(AppleFactory)
//生产一个具体的苹果
apple := appleFactory.CreatFruit()
apple.Show()
}
3.优缺点分析
优点：
1.实现了对象创建和使用的分离
2.系统的可扩展性也就变得非常好，无需修改接口和原类
3.对于新产品的创建，符合开闭原则
缺点：
1.增加系统中类的个数，复杂度和理解度增加
2.增加了系统的抽象性和理解难度。
适用场景：
1.客户端不知道它所需要的对象的类。
2.抽象工厂类通过其子类来指定创建哪个对象