[设计模式]设计模式课程（十）--构建器模式

概述

• 使用多个简单对象一步步构建成一个复杂对象
• 有时面临“一个复杂对象”的的创建工作，通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂的对象各个部分经常面临着剧烈的变化，但将他们组合在一起的算法却相对稳定
• 将一个复杂对象的构建（HouseBuilder）与其表示（House）相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）
• 使用相同的创建代码生成不同形式的对象
• 用于“分步骤构建一个复杂对象”，分步骤是个稳定算法，而复杂对象的各个部分经常变化
• 变化点在哪里，封装哪里。主要应对“复杂对象各个部分”的频繁需求变动，缺点在于难以应对“分步骤构建算法”的需求变动
• construct不稳定--虚函数，子类--参数和返回值变化--基类，子类
• 注意不同语言中构造器内调用虚函数的差别（C++，C#）

场景

• 肯德基的汉堡、薯条、可乐、炸鸡等是不变的，而套餐组合是经常变化的

示例 

builder.cpp

class House{
    //....
};

class HouseBuilder {
public:
    House* GetResult(){
        return pHouse;
    }
    virtual ~HouseBuilder(){}
protected:
    
    House* pHouse;
    virtual void BuildPart1()=0;
    virtual void BuildPart2()=0;
    virtual void BuildPart3()=0;
    virtual void BuildPart4()=0;
    virtual void BuildPart5()=0;
    
};

class StoneHouse: public House{
    
};

class StoneHouseBuilder: public HouseBuilder{
protected:
    
    virtual void BuildPart1(){
        //pHouse->Part1 = ...;
    }
    virtual void BuildPart2(){
        
    }
    virtual void BuildPart3(){
        
    }
    virtual void BuildPart4(){
        
    }
    virtual void BuildPart5(){
        
    }
    
};


class HouseDirector{
    
public:
    HouseBuilder* pHouseBuilder;
    
    HouseDirector(HouseBuilder* pHouseBuilder){
        this->pHouseBuilder=pHouseBuilder;
    }
    
    House* Construct(){
        
        pHouseBuilder->BuildPart1();
        
        for (int i = 0; i < 4; i++){
            pHouseBuilder->BuildPart2();
        }
        
        bool flag=pHouseBuilder->BuildPart3();
        
        if(flag){
            pHouseBuilder->BuildPart4();
        }
        
        pHouseBuilder->BuildPart5();
        
        return pHouseBuilder->GetResult();
    }
};

示例2

ParlourDecorator.java

package Builder;

import java.awt.*;
import javax.swing.*;

public class ParlourDecorator 
{
    public static void main(String[] args)
    {
        try
        {
            Decorator d;
            d=(Decorator) ReadXML.getObject();
            ProjectManager m=new ProjectManager(d);
            Parlour p=m.decorate();
            p.show();
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
}

class Parlour
{
    private String wall;
    private String TV;
    private String sofa;
    
    public void setWall(String wall)
    {
        this.wall=wall;
    }
    public void setTV(String TV)
    {
        this.TV=TV;
    }
    public void setSofa(String sofa)
    {
        this.sofa=sofa;
    }
    public void show()
    {
        JFrame jf=new JFrame("建造者模式");
        Container contentPane=jf.getContentPane();
        JPanel p=new JPanel();
        JScrollPane sp=new JScrollPane(p);
        String parlour=wall+TV+sofa;
        System.out.println(parlour);
        JLabel l=new JLabel(new ImageIcon("src/Builder/"+parlour+".jpg"));
        p.setLayout(new GridLayout(1,1));
        p.setBorder(BorderFactory.createTitledBorder("客厅"));
        p.add(l);
        contentPane.add(sp,BorderLayout.CENTER);
        jf.pack();
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

abstract class Decorator
{
    protected Parlour product=new Parlour();
    public abstract void buildWall();
    public abstract void buildTV();
    public abstract void buildSofa();
    
    public Parlour getResult()
    {
        return product;
    }
}

class ConcreteDecorator1 extends Decorator
{
    public void buildWall()
    {
        product.setWall("w1");
    }
    public void buildTV()
    {
        product.setTV("TV1");
    }
    public void buildSofa()
    {
        product.setSofa("sf1");
    }
}

class ConcreteDecorator2 extends Decorator
{
    public void buildWall()
    {
        product.setWall("w2");
    }
    public void buildTV()
    {
        product.setTV("TV2");
    }
    public void buildSofa()
    {
        product.setSofa("sf2");
    }
}

class ProjectManager
{
    private Decorator builder;
    public ProjectManager(Decorator builder)
    {
        this.builder=builder;
    }
    public Parlour decorate()
    {
        builder.buildWall();
        builder.buildTV();
        builder.buildSofa();
        return builder.getResult();
    }
}

ReadXML.java

package Builder;

import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
class ReadXML
{
    public static Object getObject()
    {
        try
        {
            DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
            DocumentBuilder builder=dFactory.newDocumentBuilder();
            Document doc;                           
            doc=builder.parse(new File("src/Builder/config.xml"));
            NodeList nl=doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName="Builder."+classNode.getNodeValue();
            System.out.println("新类名："+cName);
            Class<?> c=Class.forName(cName);
              Object obj=c.newInstance();
            return obj;
         }  
         catch(Exception e)
         {
                   e.printStackTrace();
                   return null;
         }
    }
}

config.xml

<?xml version="1.0" encoding="UTF-8"?>
<config>
    <className>ConcreteDecorator1</className>
</config>

新类名：Builder.ConcreteDecorator1
w1TV1sf1