实验5：建造者模式

实验5：建造者模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解建造者模式的动机，掌握该模式的结构；

2、能够利用建造者模式解决实际问题。

 

[实验任务一]：计算机组装

使用建造者模式，完成下述任务：计算机组装工厂可以将CPU、内存、硬盘、主机等硬件设备组装在一起构成计算机，计算机的类型可以是笔记本，也可以是台式机。

实验要求：

1.画出对应的类图；

 

 

 

2.提交源代码；

Java

1.Builder

public abstract class Builder {

    Computer computer = new Computer();

    abstract public void buildZhuJi();

    abstract public void buildYinPan();

    abstract public void buildCpu();

    abstract public void buildNeiCun();

    public Compture getCompture(){

        return compture;

    }

}

① Compture

public class Compture {

    private String cpu;

    private String neiCun;

    private String yinPan;

    private String zhuJi;

    public String getZhuJi() {

        return zhuJi;

    }

    public void setZhuJi(String zhuJi) {

        this.zhuJi = zhuJi;

    }

    public String getYinPan() {

        return yinPan;

    }

    public void setYinPan(String yinPan) {

        this.yinPan = yinPan;

    }

    public String getNeiCun() {

        return neiCun;

    }

    public void setNeiCun(String neiCun) {

        this.neiCun = neiCun;

    }

    public String getCpu() {

        return cpu;

    }

    public void setCpu(String cpu) {

        this.cpu = cpu;

    }

}

② Factory

public class Factory {

    private Builder comptureKind;

    public void setCompture(Builder kind) {

        this.comptureKind = kind;

    }

    public Compture construct(){

        comptureKind.buildCpu();

        comptureKind.buildYinPan();

        comptureKind.buildZhuJi();

        comptureKind.buildNeiCun();

        return comptureKind.getCompture();

    }

}

③ LapBuilder

public class LapBuilder extends Builder{

    @Override

    public void buildZhuJi() {

        compture.setZhuJi("LZJ");

    }

    @Override

    public void buildYinPan() {

        compture.setYinPan("LYP");

    }

    @Override

    public void buildCpu() {

        compture.setCpu("LC");

    }

    @Override

    public void buildNeiCun() {

        compture.setNeiCun("LNC");

    }

}

④ Store

public class Store {

    public static void main(String[] args) {

        Builder lap;

        Factory factory=new Factory();

        for (int i = 0; i < 2; i++) {

            if(i==1)

                lap = new LapBuilder();

            else

                lap=new TaiShiBuilder();

            factory.setCompture(lap);

            factory.construct();

            System.out.println(lap.getCompture().getCpu());

            System.out.println(lap.getCompture().getNeiCun());

            System.out.println(lap.getCompture().getYinPan());

            System.out.println(lap.getCompture().getZhuJi());

        }

 

    }

}

⑤ TaiShiBuilder

public class TaiShiBuilder extends Builder{

    @Override

    public void buildZhuJi() {

        compture.setZhuJi("TZJ");

    }

    @Override

    public void buildYinPan() {

        compture.setYinPan("TYP");

    }

    @Override

    public void buildCpu() {

        compture.setCpu("TC");

    }

    @Override

    public void buildNeiCun() {

        compture.setNeiCun("TNC");

    }

}

 

C++:

// ShiYan_5.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"

using namespace std;

class Compture {

private:

string cpu;

string neiCun;

string yinPan;

string zhuJi;

public:

string getZhuJi() {

return zhuJi;

}

void setZhuJi(string z) {

zhuJi = z;

}

string getYinPan() {

return yinPan;

}

void setYinPan(string y) {

yinPan = y;

}

string getNeiCun() {

return neiCun;

}

void setNeiCun(string n) {

neiCun = n;

}

string getCpu() {

return cpu;

}

void setCpu(string c) {

cpu = c;

}

};

class Builder {

public:

Compture* compture = new Compture();

virtual  void buildZhuJi() = 0;

virtual  void buildYinPan() = 0;

virtual  void buildCpu() = 0;

virtual  void buildNeiCun() = 0;

public:

Compture* getCompture(){

return compture;

}

};

class Factory {

private:

Builder* comptureKind;

public:

void setCompture(Builder* kind) {

comptureKind = kind;

}

Compture* construct(){

comptureKind->buildCpu();

comptureKind->buildYinPan();

comptureKind->buildZhuJi();

comptureKind->buildNeiCun();

return comptureKind->getCompture();

}

};

class LapBuilder :public Builder{

public:

void buildZhuJi() {

compture->setZhuJi("LZJ");

}

void buildYinPan() {

compture->setYinPan("LYP");

}

void buildCpu() {

compture->setCpu("LC");

}

void buildNeiCun() {

compture->setNeiCun("LNC");

}

};

class TaiShiBuilder :public Builder{

public:

void buildZhuJi() {

compture->setZhuJi("TZJ");

}

void buildYinPan() {

compture->setYinPan("TYP");

}

void buildCpu() {

compture->setCpu("TC");

}

void buildNeiCun() {

compture->setNeiCun("TNC");

}

};

int main()

{

Builder* lap;

Factory* factory = new Factory();

for (int i = 0; i < 2; i++) {

if (i == 1)

lap = new LapBuilder();

else

lap = new TaiShiBuilder();

factory->setCompture(lap);

factory->construct();

cout << lap->getCompture()->getCpu()<<endl;

cout << lap->getCompture()->getNeiCun()<<endl;

cout << lap->getCompture()->getYinPan()<<endl;

cout << lap->getCompture()->getZhuJi() << endl;

}

system("pause");

return 0;

}

3.注意编程规范。