抽象工厂模式
优点
- 提供一个创建一系列相关或者依赖对象的接口,而无需指定他们具体的类。
- 解决接口选择的问题。
- 抽象工厂模式不可以增加产品,但是可以增加产品族
- 增加新的具体工厂和产品族很方便,无须修改已有系统,符合“开闭原则”。
- 如果同一家工厂需要生产不止一种产品,那么使用工厂模式会造成工厂过多的情况,使用抽象工厂模式可以使同一个工厂组成一个“产品族”,即可以生产多种产品。
缺点
- 产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。
场景
- 当需要创建的对象是一系列相互关联或相互依赖的产品族时,便可以使用抽象工厂模式。说的更明白一点,就是一个继承体系中,如果存在着多个等级结构(即存在着多个抽象类),并且分属各个等级结构中的实现类之间存在着一定的关联或者约束,就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束,则使用多个独立的工厂来对产品进行创建,则更合适一点。
代码

package Abstract_Factory
import "fmt"
type mouse interface {
click()
}
type AsusMouse struct {
}
func (a *AsusMouse) click() {
fmt.Println("Asus Mouse Check screen")
}
type LogitechMouse struct {
}
func (l *LogitechMouse) click() {
fmt.Println("Logitech Mouse Check screen")
}
type keyboard interface {
press()
}
type AsusKeyboard struct {
}
func (a *AsusKeyboard) press() {
fmt.Println("Asus keyboard press")
}
type LogitechKeyboard struct {
}
func (l *LogitechKeyboard) press() {
fmt.Println("Logitech Keyboard press")
}
type AbstractFactory interface {
produceMouse(brand string) mouse
produceKeyboard(brand string) keyboard
}
type MouseFactory struct {
}
func (m *MouseFactory) produceMouse(brand string) mouse {
switch brand {
case "Asus":
return &AsusMouse{}
case "Logitech":
return &LogitechMouse{}
}
return nil
}
func (m *MouseFactory) produceKeyboard(brand string) keyboard {
return nil
}
type KeyboardFactory struct {
}
func (k KeyboardFactory) produceMouse(brand string) mouse {
return nil
}
func (k KeyboardFactory) produceKeyboard(brand string) keyboard {
switch brand {
case "Asus":
return &AsusKeyboard{}
case "Logitech":
return &LogitechKeyboard{}
}
return nil
}
func NewFactory(factory string) AbstractFactory {
switch factory {
case "mouse":
return &MouseFactory{}
case "keyboard":
return &KeyboardFactory{}
}
return nil
}
package Abstract_Factory
import "testing"
func TestNewFactory(t *testing.T) {
factory := NewFactory("mouse")
AsusMouse := factory.produceMouse("Asus")
AsusMouse.click()
}
其他设计模式