设计模式之抽象工厂练习

题目：

设计一个电脑主板架构，电脑包括（显卡，内存，CPU）3个固定的插口，显卡具有显示功能（display，功能实现只要打印出意义即可），内存具有存储功能（storage），cpu具有计算功能（calculate）。

现有Intel厂商，nvidia厂商，Kingston厂商，均会生产以上三种硬件。

要求组装两台电脑，

1台（Intel的CPU，Intel的显卡，Intel的内存）

1台（Intel的CPU， nvidia的显卡，Kingston的内存）

用抽象工厂模式实现。

代码实现：

package main

import "fmt"

//=======抽象层
//定义主板
type Borad struct {
    Card
    Disk
    Cpu
}

//定义显卡接口
type Card interface {
    Display()
}

//定义硬盘接口
type Disk interface {
    Storage()
}

//定义cpu
type Cpu interface {
    Calculate()
}

//定义制造商接口
type BoardFactory interface {
    FactoryCard() Card
    FactoryDisk() Disk
    FactoryCpu() Cpu
}

// ============实现层 制造商
//英特尔显卡
type IntelCard struct {
}

func (ic *IntelCard) Display() {
    fmt.Println("英特尔制造显卡")
}

//英特尔硬盘
type IntelDisk struct {
}

func (id *IntelDisk) Storage() {
    fmt.Println("英特尔制造硬盘")
}

//英特尔
type IntelCpu struct {
}

func (ic *IntelCpu) Calculate() {
    fmt.Println("英特尔CPU")
}

//英特尔工厂
type IntelFactory struct {
}

func (i *IntelFactory) FactoryCpu() Cpu {
    return new(IntelCpu)
}

func (i *IntelFactory) FactoryCard() Card {
    return new(IntelCard)
}

func (i *IntelFactory) FactoryDisk() Disk {
    return new(IntelDisk)
}

//Kingston显卡
type KingstonCard struct {
}

func (ic *KingstonCard) Display() {
    fmt.Println("Kingston 制造显卡")
}

//Kingston硬盘
type KingstonDisk struct {
}

func (id *KingstonDisk) Storage() {
    fmt.Println("Kingston 制造硬盘")
}

//Kingston Cpu
type KingstonCpu struct {
}

func (ic *KingstonCpu) Calculate() {
    fmt.Println("Kingston CPU")
}

//Kingston工厂
type KingstonFactory struct {
}

func (i *KingstonFactory) FactoryCpu() Cpu {
    return new(KingstonCpu)
}

func (i *KingstonFactory) FactoryCard() Card {
    return new(KingstonCard)
}

func (i *KingstonFactory) FactoryDisk() Disk {
    return new(KingstonDisk)
}

//Kingston显卡
type NvidiaCard struct {
}

func (ic *NvidiaCard) Display() {
    fmt.Println("Nvidia 制造显卡")
}

//英伟达硬盘
type NvidiaDisk struct {
}

func (id *NvidiaDisk) Storage() {
    fmt.Println("Nvidia 制造硬盘")
}

//Kingston Cpu
type NvidiaCpu struct {
}

func (ic *NvidiaCpu) Calculate() {
    fmt.Println("Nvidia CPU")
}

//英伟达
type NvidiaFactory struct {
}

func (i *NvidiaFactory) FactoryCpu() Cpu {
    return new(NvidiaCpu)
}

func (i *NvidiaFactory) FactoryCard() Card {
    return new(NvidiaCard)
}

func (i *NvidiaFactory) FactoryDisk() Disk {
    return new(NvidiaDisk)
}

func main() {
    var intelFactory BoardFactory
    var kingstonFactory BoardFactory
    var nvidiaFactory BoardFactory
    intelFactory = new(IntelFactory)
    kingstonFactory = new(KingstonFactory)
    nvidiaFactory = new(NvidiaFactory)
    var Board1 = Borad{
        Card: intelFactory.FactoryCard(),
        Disk: intelFactory.FactoryDisk(),
        Cpu:  intelFactory.FactoryCpu(),
    }
    Board1.Display()
    Board1.Storage()
    Board1.Calculate()

    var Borad2 = Borad{
        Card: intelFactory.FactoryCard(),
        Disk: kingstonFactory.FactoryDisk(),
        Cpu:  nvidiaFactory.FactoryCpu(),
    }

    Borad2.Display()
    Borad2.Storage()
    Borad2.Calculate()
}

抽象工厂优缺点：

• 优点：增加产品族（厂商）很方便，无需修改已有产品族，以及产品结构（显卡，硬盘，CPU）
• 缺点：产品结构发生改变，所有工厂代码都要修改，违背开闭原则

本作品采用《CC 协议》，转载必须注明作者和本文链接