[设计模式C++go]创建型模式：抽象工厂模式

Posted 2022-01-18 凌星An

抽象工厂模式

介绍

抽象工厂的功能是为一系列 相关对象或相关依赖 的对象创建一个接口

其定义为: Provide an interface for creating families of related or
dependent objectswithout specifying their concrete
classes.(为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。)

主要解决：主要解决接口选择的问题。
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决： 在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。

类图

AbstractCreator:抽象工厂，定义创建一系列产品对象的操作接口

Creator1、Creator2:具体的工厂,实现抽象工厂定义的方法，具体实现一系列产品对象的创建.

AbstractProductA、AbstractProductB:定义一类产品对象的接口

ProductA1、ProductA2、ProductB1、ProductB2：具体的产品实现对象，通常在具体的工厂里面，会选择具体的产品实现对象，来创建符合抽象工厂定义的方法返回的产品类型的对象.

代码实现

在日常生活中，倘若我们需要组装一台电脑,现在我们简单话，仅需要选择CPU和主板；在选择CPU、主板时，我们要考虑一系列的因素，现在我们只看针脚孔数，只有针脚孔数一致的CPU和主板才能配套使用。客户我们选择的CPU和主板给厂商，厂商组装电脑。但是用户有可能选择的CPU和主板针脚数不同，导致无法安装，故安装好电脑，有用户选择。我们使用代码来完成这个过程.

C++

class CPU
public:
	virtual void calculate() = 0;
protected:
	int _pins ;
;

class IntelCPU :public CPU
public:
	void calculate()
		_pins = 1156;
		std::cout << "Intel  CPU pins:" << _pins << std::endl;
	
;


class AWDCPU :public CPU
public:
	void calculate()
		_pins = 939;
		std::cout << "AWD  CPU pins:" << _pins << std::endl;
	
;

class Board
public:
	virtual void installCPU() = 0;
protected:
	int _pinHoles;
;

class IntelBoard :public Board
public:
	void installCPU()
		_pinHoles = 1156;
		std::cout << "Intel Board _pinHoles:" << _pinHoles << std::endl;
	
;

class AWDBoard :public Board
public:
	void installCPU()
		_pinHoles = 939;
		std::cout << "AWD Board _pinHoles:" << _pinHoles << std::endl;
	
;

class BrandFactory
public:
	virtual CPU* ProduceCPU() = 0;
	virtual Board* ProduceBorad() = 0;

;

class IntelFactory:public BrandFactory
	CPU* ProduceCPU()
		return new IntelCPU;
	
	Board* ProduceBorad()
		return new IntelBoard;
	
;

class AWDFactory :public BrandFactory
	CPU* ProduceCPU()
		return new AWDCPU;
	
	Board* ProduceBorad()
		return new AWDBoard;
	
;

测试：

BrandFactory* bf = new IntelFactory;
	std::cout << "选择CPU和主板" << endl;
	
	CPU* c=bf->ProduceCPU();
	c->calculate();
	Board* b = bf->ProduceBorad();
	b->installCPU();

	BrandFactory* bf1 = new AWDFactory;
	std::cout << "选择CPU和主板" << endl;
	CPU* c1 = bf1->ProduceCPU();
	c1->calculate();
	Board* b1 = bf1->ProduceBorad();
	b1->installCPU();

结果：

选择CPU和主板
Intel CPU pins:1156
Intel Board _pinHoles:1156
选择CPU和主板
AWD CPU pins:939
AWD Board _pinHoles:939

go

package AbstractFactory

import "fmt"

type CPU interface
     Calculate()


type intelCPU struct
     _pins int


func (c *intelCPU)Calculate()
      c._pins=1156
      fmt.Println("Intel CPU pins:",c._pins)

type awdCPU struct
     _pins int


func (c *awdCPU)Calculate()
      c._pins=939
      fmt.Println("AWD CPU pins:",c._pins)


type Board interface
      InstallCPU()



type intelBoard struct
     _pinHoles int


func (c *intelBoard)InstallCPU()
      c._pinHoles=1156
      fmt.Println("Intel Board pinHoles:",c._pinHoles)

type awdBoard struct
    _pinHoles int


func (c *awdBoard)InstallCPU()
      c._pinHoles=939
      fmt.Println("AWD Board pinHoles:",c._pinHoles)


type BrandFactory interface
       ProduceCPU()*CPU
       ProduceBoard()*Board


type IntelFactory struct
       


func (f *IntelFactory)ProduceCPU()CPU
       return &intelCPU
       


func (f *IntelFactory)ProduceBoard()Board
        return &intelBoard
       

type AWDFactory struct



func (f *AWDFactory)ProduceCPU()CPU
       c :=&awdCPU
       return c


func (f *AWDFactory)ProduceBoard()Board
       b :=&awdBoard
       return b

测试

package main

import (
"fmt"
af "AbstractFactory"
)
func main()
   fmt.Println("选择CPU和主板")
   bf :=&af.IntelFactory
   c :=bf.ProduceCPU()
   c.Calculate()
   b :=bf.ProduceBoard()
   b.InstallCPU();
   fmt.Println("选择CPU和主板")
   bf1 :=&af.AWDFactory
   c1 :=bf1.ProduceCPU()
   c1.Calculate()
   b1 :=bf1.ProduceBoard()
   b1.InstallCPU();

结果:

选择CPU和主板
Intel CPU pins: 1156
Intel Board pinHoles: 1156
选择CPU和主板
AWD CPU pins: 939
AWD Board pinHoles: 939

优缺点：

优点：
1.分离接口和实现
使用抽象工厂来创建需要的对象，而不知道具体的实现是谁，只是面向产品的接口编程.
2.切换产品簇变得容易
选用不同的工厂实现，就相当于在切换不同的产品簇
缺点：
1.不太容易扩展新的产品
倘若我们需要增加一个产品，显示器；那么我们需要修改BrandFactory的代码
产品族难扩展，产品等级易扩展。
2.容易造成层次复杂
抽象工厂的实现很需要分出层次来，没一层负责一种选择，也就是一层屏蔽一种变化

与其他设计模式的联想

抽象工厂模式和工厂模式

工厂模式一般是针对单独的产品对象的创建，而抽象工厂模式注重产品簇对象的创建，这是它们的区别

如果把抽象创建的产品簇简化，这个产品簇只有一个产品的话，这时候，抽象工厂和工厂方法是差不多的。