设计模式之抽象工厂练习

题目:

设计一个电脑主板架构,电脑包括(显卡,内存,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 协议》,转载必须注明作者和本文链接
讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容,与人为善,比聪明更重要!