-
让品牌有温度、有情感
专注品牌策划15年
生成器模式（生成器模式的应用场景）
发布时间：2023-05-28 06:59:26
稿源：
创意岭 阅读：
129
大家好！今天让创意岭的小编来大家介绍下关于生成器模式的问题，以下是小编对此问题的归纳整理，让我们一起来看看吧。
开始之前先推荐一个非常厉害的Ai人工智能工具，一键生成原创文章、方案、文案、工作计划、工作报告、论文、代码、作文、做题和对话答疑等等
只需要输入关键词，就能返回你想要的内容，有小程序、在线网页版、PC客户端和批量生成器
本文目录:
JAVA中建造者模式的主要思想，方法是什么，如何设计的？
java有23种经典设计模式，分为三类：创建型、结构型和行为型。Builder，建造者，属于创建型的设计模式，相同的还有工厂方法模式、抽象工厂、单例模式和原型模式。建造者模式抽象了对象的实例化过程，用来帮助系统去创建、组合和表示实例对象。建造者模式中一个常见的栗子就是StringBuilder。
建造者模式可以说是对工厂模式的扩展，工厂类提供了生产单个产品的功能，而建造者模式则可以将各种产品集中起来进行统一管理。工厂模式关注的是整个产品，建造者模式关注的是产品各组成部分的创建过程。
比如要创建一辆车，你只关心汽车本身（之后加以使用），就用工厂模式创建；若还关注该汽车的各部分是怎么造出来的（或者不同的工厂对产品的各部分的造法不同，就用Builder）。如StringBuilder对字符串的整合，append()、delete（）、insert()改变数据。
it is in my house
23种经典设计模式的java实现之生成器模式在这里我们使用一个构建房屋的场景来说明“生成器”——builder模式的使用。
这个模式的定义是：
1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装**式时。
2、当构造过程必须允许被构造的对象有不同的表示时。
简单的说，它有点像工厂模式，但是最终生成“产品”的是Director而非Factory，Director可以使用的builder来生成产品。而builder——生成器则遵循统一的接口，实现不同的内容，从而达到将一个复杂对象的构建与它的表示分离的目标。
下面看这个实际的例子吧：
首先，这是我们最终需要生成的产品——房屋，它具有房间数量和门数量的属性。
package com.alex.designpattern.builder;
/** *//**
* 最终我们需要的产品——房屋
*
* @author <a href="mailto:huqiyes@gmail.com">huqi</a>
* @serialData 2007
*/
public class House ...{
int roomNumber;
int doorNumber;
public House() ...{
roomNumber = 0;
doorNumber = 0;
}
public int getRoomNumber() ...{
return roomNumber;
}
public int getDoorNumber() ...{
return doorNumber;
}
}
下面就是房屋的真正构建者——“生成器”的接口定义，以及它的一个实现。
package com.alex.designpattern.builder;
/** *//**
* 房屋构建者的接口
*
* @author <a href="mailto:huqiyes@gmail.com">huqi</a>
* @serialData 2007
*/
public interface HouseBuilder ...{
public void BuildRoom(int roomNo);
public void BuildDoor(int room1, int room2);
public House getHouse();
}
package com.alex.designpattern.builder;
public class ConcreteHouseBuilderA implements HouseBuilder ...{
private House house;
public ConcreteHouseBuilderA() ...{
house = new House();
}
public void BuildRoom(int roomNo) ...{
// you can create a new Room added to a House
house.roomNumber = house.roomNumber + roomNo;
}
public void BuildDoor(int room1, int room2) ...{
// you can create a new door assotiated with 2 room
// and added this door into a house
house.doorNumber = house.doorNumber + room1 + room2;
}
public House getHouse() ...{
return house;
}
}
那么，这就是所谓的Director——最终构建房屋的“表示者”。我们需要给它提供“生成器”，然后由它来构建房屋。
package com.alex.designpattern.builder;
/** *//**
* 房屋(构建)的“表示”者，通过它我们可以对同一种构建采用不同的表示方式
*
* @author <a href="mailto:huqiyes@gmail.com">huqi</a>
* @serialData 2007
*/
public class HouseDirector ...{
public static House CreateHouse(HouseBuilder concreteBuilder) ...{
concreteBuilder.BuildRoom(1);
concreteBuilder.BuildRoom(2);
concreteBuilder.BuildDoor(1, 2);
concreteBuilder.BuildDoor(2, 1);
return concreteBuilder.getHouse();
}
}
最后，当然是我们的测试启动类了，可以看到，使用生成器模式的简单过程就是：
1、创建生成器对象。
2、表示者使用此生成器对象构建最终产品。
package com.alex.designpattern.builder;
/** *//**
* A test client to create a house <br>
* but we do not know how the room and door be created
* <p>
*
* Builder（生成器模式）
* <p>
* 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
*/
public class Test ...{
public static void main(String[] args) ...{
ConcreteHouseBuilderA myHouseBuilder = new ConcreteHouseBuilderA();
House myHouse = HouseDirector.CreateHouse(myHouseBuilder);
System.out.println("My house has room: " + myHouse.getRoomNumber());
System.out.println("My house has door: " + myHouse.getDoorNumber());
}
}
什么是建造者模式
建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式
实用范围
1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。[1]
2 当构造过程必须允许被构造的对象有不同表示时。
角色
在这样的设计模式中，有以下几个角色：
1 builder：为创建一个产品对象的各个部件指定抽象接口。
2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
3 Director：构造一个使用Builder接口的对象。
4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
例子
Builder
public interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
}
//具体建造工具
ConcreteBuilder
public class ManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Person();
}
public void buildbody() {
person.setBody("建造男人的身体");
}
public void buildFoot() {
person.setFoot("建造男人的脚");
}
public void buildHead() {
person.setHead("建造男人的头");
}
public Person buildPerson() {
return person;
}
}
//建造者
Director
public class PersonDirector {
public Person constructPerson(PersonBuilder pb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}
Product
public class Person {
private String head;
private String body;
private String foot;
public String getHead() {
return head;
}
public void setHead(String head) {
this.head = head;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
}
public class Man extends Person {
}
Test
public class Test{
public static void main(String[] args) {
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new ManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}
result
建造男人的身体
建造男人的脚
建造男人的头
扩展
建造者模式在使用过程中可以演化出多种形式：
省略抽象建造者角色
如果系统中只需要一个具体的建造者的话，可以省略掉抽象建造者。这是代码可能如下：
class FoodManager
{
private:
BuilderA * builder;
public:
FoodManager() {builder = new BuilderA();};
void Construct()
{
builder->BuildRiceNoodles();
builder->BuildDrink();
builder->BuildCoolDish();
}
};
省略指导者角色
在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略掉指导者角色，让Builder自己扮演指导者和建造者双重角色。这是代码可能如下：
//builder
class Builder
{
private:
Food * food;
public:
Builder(){food = new Food();}
void BuildRiceNoodles() {//..};
void BuildCoolDish(){//..};
void BuildDrink(){//..};
Food * getFood(){return food;}
void Construct()
{
BuildRiceNoodles();
BuildCoolDish();
BuildDrink();
}
};
同时，客户端也需要进行相应的调整，如下：
//client
int _tmain(int argc, _TCHAR* argv[])
{
Builder * builder = new Builder();
builder->Construct();
Food *food = builder->getFood();
food->show();
return 0;
}
C#中的StringBuilder就是这样一个例子。
以上就是关于生成器模式相关问题的回答。希望能帮到你，如有更多相关问题，您也可以联系我们的客服进行咨询，客服也会为您讲解更多精彩的知识和内容。
推荐阅读：
赣公网安备 50019002502384号
