设计模式学习笔记DAY04-建造者模式(Builder)

四、设计模式学习笔记DAY04-建造者模式(Builder)
1.定义:建造者模式是将一个产品的内部表象与产品的生成过程分割开来，从而可以使同一个建造过程生成具有不同的内部表象的产品对象。
2.应用:在构建一个系统时有时候候面临“一个复杂对象”的创建工作，该复杂对象通常由各个部分的子对象用一定的算法构成，由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法确相对稳定。而建造者模式所做的就是提供一种“封装机制”，来隔离出“复杂对象的各个部分经常面临着剧烈的变化”，而保持系统中“相对稳定的构建算法”。
3.区别:建造者模式和抽象工厂模式有点神似。但是细看还是能很明显看出区别，抽象工厂模式重点是要创建一系列相互关联或者依赖的对象，该系列对象由一个类或者一系列相关类继承而来，并不注重其实现。而建造者模式注重的是创建一个复杂对象的过程，该复杂对象由多个自对象聚合而来。抽象工厂重点是继承，而建造者重点是聚合。
4.示例：现在这里有PC和笔记本各自型号的CPU、主板、电源、硬盘等等（暂时只考虑这四类硬件），分别来自有三星、方正等等公司，现在各户需按照自己的意愿来组装，并且运行。(Win32控制台程序)

//BaseClass.h
#pragma once

class HardWare
{
	public:
		virtual void Run() = 0;
};

class CPU:public HardWare
{
	public:
		virtual	void Run();
};

class NoteBookCPU:public CPU
{
	public:
		virtual	void Run();
};

class ComputerCPU:public CPU
{
	public:
		virtual	void Run();
};

class MainBoard:public HardWare
{
	public:
		virtual	void Run();
};

class HardDisk:public HardWare
{
	public:
		virtual	void Run();
};

class Power:public HardWare
{
	public:
		virtual	void Run();
};

class PC
{
	public:
#define HARD_WARE_NUM	4

		PC();

		virtual void Run();
		virtual void InstallPC(HardWare* pPart);
	private:
		HardWare* m_HardWare[HARD_WARE_NUM];
		int m_nHardNum;
};

class Computer:public PC
{
	public:
		void Run();
};

class NoteBook:public PC
{
	public:
		void Run();
};

class Builder
{
	protected:
	public:
		virtual void InstallCPU() = 0;
		virtual void InstallHardDisk() = 0;
		virtual void InstallMainBoard() = 0;
		virtual void InstallPower() = 0;
		
		virtual void InstallPC() = 0;

		virtual PC* GetPC()=0;
};

class SamsungBuilder:public Builder
{
	public:
		SamsungBuilder();

		virtual void InstallCPU();
		virtual void InstallHardDisk();
		virtual void InstallMainBoard();
		virtual void InstallPower();
		
		virtual void InstallPC();

		PC* GetPC();
	private:
		PC* m_PC;
};

class FounderBuilder:public Builder
{
	public:
		FounderBuilder();

		virtual void InstallCPU();
		virtual void InstallHardDisk();
		virtual void InstallMainBoard();
		virtual void InstallPower();

		virtual void InstallPC();

		PC* GetPC();
	private:
		PC* m_PC;
};

class CliectDrictor
{
	public:
		CliectDrictor(Builder* pBuilder);
		PC* CreatePC();
	private:
		Builder* m_pBuilder;
};

//BaseClass.cpp
#include "StdAfx.h"
#include <iostream>
using namespace std;
#include "BaseClass.h"

void CPU::Run()
{
	cout<<"CPU Run"<<endl;
}

void NoteBookCPU::Run()
{
	cout<<"NoteBookCPU Run"<<endl;
}

void ComputerCPU::Run()
{
	cout<<"ComputerCPU Run"<<endl;
}

void MainBoard::Run()
{
	cout<<"MainBoard Run"<<endl;
}
void HardDisk::Run()
{
	cout<<"HardDisk Run"<<endl;
}
void Power::Run()
{
	cout<<"Power Run"<<endl;
}

PC::PC()
{
	m_nHardNum = 0;
}

void PC::InstallPC(HardWare* pPart)
{
	if (m_nHardNum < HARD_WARE_NUM)
	{
		m_HardWare[m_nHardNum] = pPart;
		m_nHardNum++;
	}
}

void PC::Run()
{
	if (0 == m_nHardNum)
	{
		cout<<"PC Run Faild"<<endl;
		return ;
	}

	for (int i = 0; i<m_nHardNum; i++)
	{
		m_HardWare[i]->Run();
	}
	cout<<"PC Run"<<endl;
}

void Computer::Run()
{
	PC::Run();
	cout<<"Computer Run"<<endl<<endl;
}

void NoteBook::Run()
{
	PC::Run();
	cout<<"NoteBook Run"<<endl<<endl;
}

SamsungBuilder::SamsungBuilder()
{
	m_PC = NULL;
}

void SamsungBuilder::InstallCPU()
{
	CPU * pCPU = new ComputerCPU();
	m_PC->InstallPC(pCPU);
}

void SamsungBuilder::InstallHardDisk()
{
	HardDisk * pDisk = new HardDisk();
	m_PC->InstallPC(pDisk);
}
void SamsungBuilder::InstallMainBoard()
{
	MainBoard * pBoard = new MainBoard();
	m_PC->InstallPC(pBoard);
}
void SamsungBuilder::InstallPower()
{
	Power * pPower = new Power();
	m_PC->InstallPC(pPower);
}

void SamsungBuilder::InstallPC()
{
	m_PC = new Computer();
}

PC* SamsungBuilder::GetPC()
{
	return m_PC;
}

FounderBuilder::FounderBuilder()
{
	m_PC = NULL;
}

void FounderBuilder::InstallCPU()
{
	CPU * pCPU = new NoteBookCPU();
	m_PC->InstallPC(pCPU);
}

void FounderBuilder::InstallHardDisk()
{
	HardDisk * pDisk = new HardDisk();
	m_PC->InstallPC(pDisk);
}
void FounderBuilder::InstallMainBoard()
{
	MainBoard * pBoard = new MainBoard();
	m_PC->InstallPC(pBoard);
}
void FounderBuilder::InstallPower()
{
	Power * pPower = new Power();
	m_PC->InstallPC(pPower);
}

void FounderBuilder::InstallPC()
{
	m_PC = new NoteBook();
}

PC* FounderBuilder::GetPC()
{
	return m_PC;
}

CliectDrictor::CliectDrictor(Builder* pBuilder)
{
	m_pBuilder = pBuilder;
}

PC* CliectDrictor::CreatePC()
{
	m_pBuilder->InstallPC();

	m_pBuilder->InstallCPU();
	m_pBuilder->InstallHardDisk();
	m_pBuilder->InstallMainBoard();
	m_pBuilder->InstallPower();
	
	return m_pBuilder->GetPC();
}

//main.cpp
#include "stdafx.h"
#include "BaseClass.h"


int _tmain(int argc, _TCHAR* argv[])
{
	SamsungBuilder* pSamsung = new SamsungBuilder();
	CliectDrictor* pClient1 = new CliectDrictor(pSamsung);
	PC* pPC1 = pClient1->CreatePC();
	pPC1->Run();

	FounderBuilder* pFounder = new FounderBuilder();
	CliectDrictor* pClient2 = new CliectDrictor(pFounder);
	PC* pPC2 = pClient2->CreatePC();
	pPC2->Run();
	
	while(1);
	return 0;
}