建造者模式-游戏角色
常见设计模式及应用场景
常见设计模式及应用场景设计模式是一种解决特定问题的经验总结，可以提高代码的可重用性、可读性和灵活性。
在软件开发过程中，常见的设计模式有23种，下面将对其中的几种常见的设计模式及其应用场景进行介绍。
1. 单例模式（Singleton Pattern）：单例模式用于限制一个类只能有一个实例，并提供一个全局访问点。
在需要频繁创建和销毁对象的场景下，可以使用单例模式来减少系统开销。
例如，在多线程环境下需要共享某个资源时，通过单例模式可以保证该资源只有一个实例。
2. 工厂模式（Factory Pattern）：工厂模式用于创建对象，把实例化对象的过程封装在一个工厂类中。
它解耦了对象的创建和使用，提高了代码的可扩展性。
例如，一个电商平台上有多种类型的商品，可以通过工厂模式根据用户的选择来创建相应类型的商品。
3. 观察者模式（Observer Pattern）：观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
观察者模式适用于对象之间存在一种一对多的关系，并且对象之间需要保持一致。
例如，一个新闻发布系统中，当发布一条新闻时，系统需要通知所有订阅该新闻频道的用户。
4. 策略模式（Strategy Pattern）：策略模式定义了一系列可以互相替换的算法，并根据具体情况选择合适的算法。
使用策略模式可以避免使用大量的if-else语句，提高代码的可维护性和扩展性。
例如，在一个电商平台中，根据会员等级的不同，可以采用不同的折扣策略来计算商品的价格。
5. 适配器模式（Adapter Pattern）：适配器模式用于将两个不兼容的接口转换为可兼容的接口，使得不同的类可以协同工作。
适配器模式可以增强代码的复用性和灵活性。
例如，一个音频播放器只支持mp3格式的音乐文件，当我们需要播放其他格式的音乐文件时，可以使用适配器模式将不同格式的音乐文件转换为mp3格式。
6. 建造者模式（Builder Pattern）：建造者模式可以将创建复杂对象的过程与表示分离，使得同样的创建过程可以创建不同的表示。
建造者模式实验报告(3篇)
第1篇一、实验目的本次实验旨在通过实际操作，深入理解建造者模式的设计理念、结构和应用场景。
通过构建一个具体的案例，验证建造者模式在处理复杂对象构建过程中的优势，以及如何实现灵活性和可扩展性。
二、实验环境- 开发工具：Java Development Kit (JDK) 1.8- 编程语言：Java- 案例选择：汽车制造系统三、实验内容本次实验将采用建造者模式设计并实现一个汽车制造系统，其中包含不同类型的汽车（如轿车、SUV、跑车等）及其各个部件的配置。
四、实验步骤1. 定义产品类（Product）：- 创建一个抽象的汽车类，定义汽车的基本属性，如品牌、引擎类型、颜色、车轮数量等。
- 为每种类型的汽车创建具体的实现类，如C轿车、SUV车型、跑车等。
2. 定义抽象建造者（Builder）：- 创建一个抽象的建造者类，定义构建产品的各个部分的方法，如setBrand()、setEngineType()等。
3. 定义具体建造者（ConcreteBuilder）：- 为每种类型的汽车创建具体的建造者类，实现抽象建造者接口，具体确定如何构建产品的各个部分。
4. 定义指挥者（Director）：- 创建一个指挥者类，负责调用建造者的方法来构建产品，控制构建顺序和方式。
5. 实现客户端代码：- 在客户端代码中，创建一个指挥者对象，指定要构建的汽车类型和配置。
- 通过指挥者调用相应的建造者方法，构建出最终的汽车产品。
五、实验结果通过以上步骤，成功实现了汽车制造系统。
以下是实验结果的关键点：1. 灵活性和可扩展性：- 通过建造者模式，可以轻松地添加新的汽车类型和配置，只需创建相应的具体建造者类即可。
- 客户端代码无需修改，即可构建新的汽车产品。
2. 封装性和可读性：- 建造者模式将构建过程与产品表示分离，使得代码结构清晰，易于理解和维护。
- 客户端代码只关注产品构建的顺序和方式，无需关心具体的构建细节。
3. 示例代码：```java// 汽车产品类public abstract class Car {protected String brand;protected String engineType;protected String color;protected int wheelNumber;public abstract void setBrand(String brand);public abstract void setEngineType(String engineType);public abstract void setColor(String color);public abstract void setWheelNumber(int wheelNumber); }// 具体轿车产品类public class SedanCar extends Car {@Overridepublic void setBrand(String brand) {this.brand = brand;}@Overridepublic void setEngineType(String engineType) {this.engineType = engineType;}@Overridepublic void setColor(String color) {this.color = color;}@Overridepublic void setWheelNumber(int wheelNumber) {this.wheelNumber = wheelNumber;}}// 建造者接口public interface Builder {void setBrand(String brand);void setEngineType(String engineType);void setColor(String color);void setWheelNumber(int wheelNumber);Car build();}// 具体轿车建造者类public class SedanCarBuilder implements Builder { private Car car;public SedanCarBuilder() {car = new SedanCar();}@Overridepublic void setBrand(String brand) {car.setBrand(brand);}@Overridepublic void setEngineType(String engineType) { car.setEngineType(engineType);}@Overridepublic void setColor(String color) {car.setColor(color);}@Overridepublic void setWheelNumber(int wheelNumber) {car.setWheelNumber(wheelNumber);}@Overridepublic Car build() {return car;}}// 指挥者类public class Director {private Builder builder;public Director(Builder builder) {this.builder = builder;}public void construct(String brand, String engineType, String color, int wheelNumber) {builder.setBrand(brand);builder.setEngineType(engineType);builder.setColor(color);builder.setWheelNumber(wheelNumber);}public Car getCar() {return builder.build();}}// 客户端代码public class Client {public static void main(String[] args) {Builder builder = new SedanCarBuilder();Director director = new Director(builder);director.construct("Toyota", "V6", "Red", 4);Car car = director.getCar();System.out.println("Car brand: " + car.getBrand());System.out.println("Car engine type: " + car.getEngineType());System.out.println("Car color: " + car.getColor());System.out.println("Car wheel number: " + car.getWheelNumber());}}```六、实验总结通过本次实验，我们深入理解了建造者模式的设计理念和应用场景。
C++设计模式-Builder建造者模式
作用:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
Builder模式和AbstractFactory模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。
而在AbstractFactory模式中对象是直接返回的，AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。
适用于以下情况:1)当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2)当构造过程必须允许被构造的对象有不同的表示时。
UML图如下：Builder：定义创建对象过程的抽象，提供构建不同组成部分的接口其中：BuildPartA,BuildPartB,BuildPartC是对一个对象不同部分的构建函数接口,由Builder 的派生类ConcreteBuilder1、ConcreteBuilder2来具体实现.另外还有一个需要注意的函数,就是Director::Construct函数,这个函数里面通过调用上面的接口函数完成对象的构建--也就是说各个不同部分装配的过程都是一致的(同样的调用的Construct函数),但是不同的构建方式会有不同的表示(根据Builder的实际类型来决定如何构建,也就是多态)Builder模式是基于这样的一个情况:一个对象可能有不同的组成部分,这几个部分的不同的创建对象会有不同的表示,但是各个部分之间装配的方式是一致的.比方说一辆单车,都是由车轮车座等等的构成的(一个对象不同的组成部分),不同的品牌生产出来的也不一样(不同的构建方式).虽然不同的品牌构建出来的单车不同,但是构建的过程还是一样的也就是说,Director::Construct函数中固定了各个组成部分的装配方式,而具体是装配怎样的组成部分由Builder的派生类实现.实现:Builder模式的实现基于以下几个面向对象的设计原则:1)把变化的部分提取出来形成一个基类和对应的接口函数,在这里不会变化的是都会创建PartA 和PartB,变化的则是不同的创建方法,于是就抽取出这里的Builder基类和BuildPartA,BuildPartB接口函数2)采用聚合的方式聚合了会发生变化的基类,就是这里Director聚合了Builder类的指针.以上，通过两个派生类ConcreteBuilder1、ConcreteBuilder2定义了两种不同的建造细节（建造步骤是一样的，由Construct函数确定），通过两个派生类所建造出来的对象，对外部所展现出来的属性或者功能是不一样的，由各自Builder派生类中的建造方法（BuildPartA、BuildPartB、BuildPartC）决定。
如何使用RPGMaker进行角色扮演游戏开发和设计
如何使用RPGMaker进行角色扮演游戏开发和设计RPGMaker是一款专为角色扮演游戏（RPG）开发和设计的软件工具。
它为游戏爱好者和开发人员提供了一个简便的平台，用于创建自己的RPG游戏。
本文将分为五个章节，介绍如何使用RPGMaker进行角色扮演游戏的开发和设计。
第一章：RPGMaker介绍与安装RPGMaker是一款由Enterbrain公司开发的游戏制作工具。
它提供了一个直观的图形化界面，使开发者可以轻松地创建游戏地图、角色、对话和事件。
首先，我们需要从RPGMaker官方网站上下载并安装软件。
安装完成后，我们可以开始我们的角色扮演游戏的开发之旅。
第二章：创建游戏地图和角色游戏地图是RPG的核心组成部分之一。
在RPGMaker中，我们可以使用图块（tiles）来设计游戏地图。
图块是一种小图像，用于构建地图的各个元素，如地面、墙壁、树木等。
通过拖放图块，我们可以轻松地创建各种场景。
然后，我们可以使用RPGMaker的角色编辑器来设计游戏中的主角、敌人和NPC等角色。
编辑器提供了各种选项，如选择角色的外观、技能和属性等。
第三章：事件的创建与管理在RPGMaker中，事件是游戏中的交互元素。
通过创建事件，我们可以为游戏添加对话、任务、剧情和战斗等元素。
通过事件编辑器，我们可以指定事件的触发条件、行为和效果。
比如，我们可以创建一个NPC事件，当玩家接近NPC时，触发对话，并根据玩家的选择给予奖励或任务。
通过灵活使用事件，我们可以为角色扮演游戏增加更多的内容和深度。
第四章：战斗系统的设计与开发在角色扮演游戏中，战斗系统是至关重要的组成部分。
RPGMaker提供了一个简单但功能强大的战斗系统。
通过战斗编辑器，我们可以定义战斗的规则、技能和效果。
战斗系统是基于回合制的，玩家和敌人交替进行行动。
我们可以设置技能的消耗、伤害和特效等属性。
通过合理设计战斗系统，我们可以提供有趣和挑战性的游戏体验。
第五章：测试与发布游戏在完成角色扮演游戏的开发和设计后，我们需要对游戏进行测试和优化。
建造者模式在项目中的应用
建造者模式在项目中的应用一、引言建造者模式是一种创建型设计模式，它允许你分步骤地构造复杂对象。
该模式允许你使用相同的创建代码生成不同类型和形式的对象。
在本文中，将介绍建造者模式在项目中的应用，包括建造者模式的基本概念、优点和缺点，以及如何在项目中实现建造者模式。
二、建造者模式的基本概念1. 建造者：定义了产品的创建过程和最终结果，并提供了一个接口来返回最终创建结果。
2. 具体建造者：实现了建造者接口，并提供了具体的创建方法。
3. 产品：表示被构建的复杂对象。
4. 指挥者：指导具体建造者如何构建产品。
三、建造者模式的优点1. 将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
2. 可以更加精细地控制对象的构建过程，从而可以更好地满足需求。
3. 可以减少重复代码，提高代码复用性。
四、建造者模式的缺点1. 建造者模式需要额外定义多个类，增加了系统复杂度。
2. 对象必须有一个共同的接口，才能使用相同的构建过程。
五、建造者模式在项目中的应用建造者模式在实际项目中有很多应用场景，以下是其中几个典型的应用场景。
1. 安装程序安装程序通常需要进行一系列操作，例如检查系统配置、安装文件、创建快捷方式等。
这些操作可以使用建造者模式来实现。
具体建造者可以是不同类型的安装程序，例如 Windows 安装程序和 Linux 安装程序。
2. 网站生成器网站生成器通常需要根据用户需求生成不同类型和形式的网站。
这些网站可以使用建造者模式来实现。
具体建造者可以是不同类型的网站生成器，例如博客生成器和电商网站生成器。
3. 游戏角色创建在游戏开发中，角色创建通常需要进行一系列操作，例如选择职业、设置属性、选择技能等。
这些操作可以使用建造者模式来实现。
具体建造者可以是不同类型的角色创建器，例如战士创建器和法师创建器。
4. 订单处理订单处理通常需要根据用户需求生成不同类型和形式的订单。
这些订单可以使用建造者模式来实现。
建造者模式的应用例子及其演化过程
建造者模式的应用例子及其演化过程软件设计模式是软件开发中常用的一种模式化的解决方案。
在软件开发中，常常需要为每个对象进行繁琐的初始化和参数设置工作。
而建造者模式是一种松耦合的解决方案，可以有效减轻开发者的工作负担，提高代码的可阅读性和可维护性。
同时，建造者模式在实现业务逻辑复杂的对象时，可以大幅度降低代码重构的难度。
本文将通过实际案例分析建造者模式的应用范围，以及建造者模式在实际开发中的演化过程。
一、案例分析在实际开发过程中，建造者模式适用于需要构建大量具有相似结构的对象的场景。
下面通过一个实际案例来说明建造者模式的应用。
假设我们正在开发一个游戏，这个游戏需要计算一个英雄角色的属性值。
这个英雄角色有攻击力、防御力、生命值三个属性。
同时，在每个英雄的属性之间会存在一定比例的关系。
比如，攻击力越高，则防御和生命值就可能越低。
因此，在游戏开发中，需要设计一个英雄属性计算器。
这个计算器的功能是，可以根据不同的英雄类型，计算出每个英雄角色的三个属性值。
在这种情况下，我们可以使用建造者模式来实现英雄属性计算器的功能。
具体实现方式如下：1.定义抽象建造者类HeroBuilder，其中包含用于设置英雄属性的方法。
```javapublic abstract class HeroBuilder {protected Hero hero = new Hero();public abstract void buildAttack();public abstract void buildDefense();public abstract void buildHP();public Hero getHero() {return hero;}}```2.定义具体英雄建造者类WarriorBuilder和MageBuilder。
这两个具体建造者分别用于构建战士和法师两种不同类型的英雄。
具体实现方式如下。
```javapublic class WarriorBuilder extends HeroBuilder {public void buildAttack() {hero.setAttack(100);}public void buildDefense() {hero.setDefense(50);}public void buildHP() {hero.setHP(500);}}public class MageBuilder extends HeroBuilder {public void buildAttack() {hero.setAttack(70);}public void buildDefense() {hero.setDefense(30);}public void buildHP() {hero.setHP(300);}}```由于不同类型的英雄之间属性存在比例关系，因此我们可以通过在英雄建造者中添加一些计算逻辑来实现这些比例关系。
建造者模式
建造者模式目录1.建造者模式简介 (2)2.建造者模式解析 (2)2.1什么是建造者模式？ (2)2.2详解 (2)3.具体案例造房子 (3)3.1 第一版用户自己去造房子 (3)3.2 第二版工程队去造房子 (3)3.3 第三版由设计师来造房子 (4)4.建造者模式的结构 (5)5.建造者模式应用的场景 (5)6.建造者模式与抽象工厂模式的比较 (5)7.建造者模式总结 (6)1.建造者模式简介将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
Builder模式是一步一步创建一个复杂的对象，它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们。
用户不知道内部的具体构建细节。
Builder模式是非常类似抽象工厂模式，细微的区别大概只有在反复使用中才能体会到。
2.建造者模式解析2.1什么是建造者模式？Builder模式是一种对象创建型模式，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态创建具有复合属性的对象。
2.2详解Builder是什么？是为了创建一个Product对象的各个部件指定的抽象接口。
ConcreteBuilder是什么呢？它是具体建造者，实现Builder接口，构造和装配各个部件。
Product当然就是产品角色了，Director是什么？指挥者主要是构建一个Builder接口的对象，用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。
建造者的好处就是使的建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品内部的表示，只需要在定义一个具体的建造者就可以了。
3.具体案例造房子类：MainClass(客户端)、House、PingFangBuilder、HouseDicrector方法：makeHouse()接口：HouseBuilder3.1 第一版用户自己去造房子在house里面我用Private定义几个属性。
建造者模式的优势与典型应用案例
建造者模式的优势与典型应用案例在软件开发领域中，设计模式是一种通用的解决方案，用于解决常见的问题。
其中，建造者模式是一种创建型设计模式，用于将一个复杂对象的构建过程与其表示相分离，以便相同的构建过程可以创建不同的表示。
本文将介绍建造者模式的优势和典型应用案例。
一、建造者模式的优势1.1 提供灵活性和可扩展性建造者模式可以将复杂对象的构建过程分解为多个简单的步骤，每个步骤由一个具体的建造者实现。
通过定义不同的建造者实现，可以构建出不同的表示。
这有助于提供灵活性和可扩展性，使得系统能够适应不同的需求变化。
1.2 隐藏复杂对象的创建细节使用建造者模式可以将复杂对象的创建细节隐藏起来，使得客户端不需要知道对象的具体创建过程。
客户端只需要知道如何使用建造者对象，而不需要关心对象的内部实现细节。
这样可以降低系统的耦合度，提高代码的可维护性和可读性。
1.3 代码复用和可读性建造者模式可以将相同的构建过程用于创建不同的表示，从而实现代码的复用。
通过定义不同的建造者实现，可以复用已有的构建过程，减少重复代码的编写。
同时，由于将构建过程拆分为多个步骤，使得代码更加清晰可读，易于理解和维护。
1.4 构建过程逐步完善建造者模式支持逐步完善构建过程，即可以在创建对象的过程中逐步填充对象的属性和方法。
这使得构建过程更加灵活，可以根据实际需求来进行调整和改进。
同时，逐步完善构建过程也有助于提高代码的可测试性，方便进行单元测试和集成测试。
二、建造者模式的典型应用案例2.1 汽车制造业在汽车制造业中，建造者模式可以用于构建不同类型的汽车。
汽车的构建过程可以分解为多个步骤，如组装发动机、安装座椅、喷涂车身等。
通过定义不同的建造者，可以实现不同类型的汽车的构建过程。
例如，可以定义一个轿车建造者和一个SUV建造者，分别用于构建轿车和SUV。
2.2 游戏角色创建在游戏开发中，建造者模式可以用于创建不同类型的游戏角色。
游戏角色的构建过程可以分解为多个步骤，如设置角色属性、选择武器装备、设定技能等。
建造者模式-游戏角色
完整解决方案Sunny公司开发人员决定使用建造者模式来实现游戏角色的创建，其基本结构如图8-3所示：图7-1 游戏角色创建结构图在图7-1中，ActorController充当指挥者，ActorBuilder充当抽象建造者，HeroBuilder、AngelBuilder和DevilBuilder充当具体建造者，Actor充当复杂产品。
完整代码如下所示：//Actor角色类：复杂产品，考虑到代码的可读性，只列出部分成员属性，且成员属性的类型均为String，真实情况下，有些成员属性的类型需自定义class Actor{private String type; //角色类型private String sex; //性别private String face; //脸型private String costume; //服装private String hairstyle; //发型public void setType(String type) {this.type = type;}public void setSex(String sex) {this.sex = sex;}public void setFace(String face) {this.face = face;}public void setCostume(String costume) {this.costume = costume;}public void setHairstyle(String hairstyle) {this.hairstyle = hairstyle;}public String getType() {return (this.type);}public String getSex() {return (this.sex);}public String getFace() {return (this.face);}public String getCostume() {return (this.costume);}public String getHairstyle() {return (this.hairstyle);}}//角色建造器：抽象建造者abstract class ActorBuilder{protected Actor actor = new Actor();public abstract void buildType();public abstract void buildSex();public abstract void buildFace();public abstract void buildCostume();public abstract void buildHairstyle();//工厂方法，返回一个完整的游戏角色对象public Actor createActor(){return actor;}}//英雄角色建造器：具体建造者class HeroBuilder extends ActorBuilder{public void buildType(){actor.setType("英雄");}public void buildSex(){actor.setSex("男");}public void buildFace(){actor.setFace("英俊");}public void buildCostume(){actor.setCostume("盔甲");}public void buildHairstyle(){actor.setHairstyle("飘逸");}}//天使角色建造器：具体建造者class AngelBuilder extends ActorBuilder {public void buildType(){actor.setType("天使");}public void buildSex(){actor.setSex("女");}public void buildFace(){actor.setFace("漂亮");}public void buildCostume(){actor.setCostume("白裙");}public void buildHairstyle(){actor.setHairstyle("披肩长发");}}//恶魔角色建造器：具体建造者class DevilBuilder extends ActorBuilder {public void buildType(){actor.setType("恶魔");}public void buildSex(){actor.setSex("妖");}public void buildFace(){actor.setFace("丑陋");}public void buildCostume(){actor.setCostume("黑衣");}public void buildHairstyle(){actor.setHairstyle("光头");}}指挥者类ActorController定义了construct()方法，该方法拥有一个抽象建造者ActorBuilder类型的参数，在该方法内部实现了游戏角色对象的逐步构建，代码如下所示：//游戏角色创建控制器：指挥者class ActorController{//逐步构建复杂产品对象public Actor construct(ActorBuilder ab){Actor actor;ab.buildType();ab.buildSex();ab.buildFace();ab.buildCostume();ab.buildHairstyle();actor=ab.createActor();return actor;}}为了提高系统的灵活性和可扩展性，我们将具体建造者类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：import javax.xml.parsers.*;import org.w3c.dom.*;import org.xml.sax.SAXException;import java.io.*;class XMLUtil{//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象public static Object getBean(){try{//创建文档对象DocumentBuilderFactory dFactory =DocumentBuilderFactory.newInstance();DocumentBuilder builder = dFactory.newDocumentBuilder();Document doc;doc = builder.parse(new File("config.xml"));//获取包含类名的文本节点NodeList nl = doc.getElementsByTagName("className");Node classNode=nl.item(0).getFirstChild();String cName=classNode.getNodeValue();//通过类名生成实例对象并将其返回Class c=Class.forName(cName);Object obj=c.newInstance();return obj;}catch(Exception e){e.printStackTrace();return null;}}}配置文件config.xml中存储了具体建造者类的类名，代码如下所示：<?xml version="1.0"?><config><className>AngelBuilder</className></config>编写如下客户端测试代码：class Client{public static void main(String args[]){ActorBuilder ab; //针对抽象建造者编程ab = (ActorBuilder)XMLUtil.getBean(); //反射生成具体建造者对象ActorController ac = new ActorController();Actor actor;actor = ac.construct(ab); //通过指挥者创建完整的建造者对象String type = actor.getType();System.out.println(type + "的外观：");System.out.println("性别：" + actor.getSex());System.out.println("面容：" + actor.getFace());System.out.println("服装：" + actor.getCostume());System.out.println("发型：" + actor.getHairstyle());}}编译并运行程序，输出结果如下：天使的外观：性别：女面容：漂亮服装：白裙发型：披肩长发在建造者模式中，客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型，指挥者将指导具体建造者一步一步构造一个完整的产品（逐步调用具体建造者的buildX()方法），相同的构造过程可以创建完全不同的产品。
建造者模式的作用和意义
建造者模式的作用和意义建造者模式，这可真是个挺有意思的东西呢。
你有没有搭过积木呀？一块一块小小的积木，在你手里能变成各种各样的东西，可能是一座漂亮的小房子，也可能是一辆酷炫的小汽车。
这就有点像建造者模式的作用呢。
建造者模式就像是一个超级有耐心、超级有创意的积木搭建大师。
它能把那些看起来零零散散的小零件，按照一定的规则和顺序，组合成一个完整的、很棒的大东西。
比如说，你要盖一栋大楼。
这可不是一件简单的事儿啊。
要是没有个好的方法，那可就乱套了。
建造者模式就出现啦，它就像一个智慧的指挥家。
混凝土、钢筋、砖块，这些就好比是建造大楼的原材料，也就是程序里的各个组件。
如果没有建造者模式，就好像一群工人各自为政，拿着材料乱堆一气，最后盖出来的可能就是个歪歪扭扭、随时会倒的怪物建筑。
可是有了建造者模式呢，就不一样啦。
它有条不紊地指挥着，先把地基打好，用钢筋混凝土筑牢根基，就像给大楼穿上了一双结实的鞋子，让它稳稳地站在地上。
然后一层一层地往上砌砖，每一层都按照设计的高度和宽度来，这就像是给大楼穿上了一件合身的衣服，规规矩矩的。
从意义上来说，建造者模式给我们带来了好多方便。
它让整个构建的过程变得清晰起来。
就像我们画画的时候，要是没有一个好的步骤，颜料到处乱涂，最后画出来的东西肯定乱七八糟。
建造者模式就是那个告诉我们先画轮廓，再上颜色，一块一块地把画完善起来的好帮手。
在软件开发中也是这样啊。
它可以让不同的开发人员专注于不同的部分。
就好比盖房子的时候，有的工人专门负责砌墙，有的工人专门负责安装水电。
大家都按照建造者模式这个大计划来，各司其职，效率不就提高了嘛。
再说说定制化这方面。
你去买衣服，有的衣服是那种批量生产的，大家都一样，没什么个性。
但是如果有个设计师按照你的身材、你的喜好，一件一件地给你做衣服呢？这就很特别了。
建造者模式就可以做到这样的定制化。
你想要一个软件有这个功能，不要那个功能，就像你想要衣服上有这个口袋，不要那个装饰一样。
软件开发的23种设计模式
软件开发的23种设计模式 ⼆⼗三种设计模式1.单例模式（Singleton Pattern）定义：Ensure a class has only one instance, and provide a global point of access to it.（确保某⼀个类只有⼀个实例，⽽且⾃⾏实例化并向整个系统提供这个实例。
）通⽤代码：（是线程安全的）public class Singleton {private static final Singleton singleton = new Singleton();//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){return singleton;}//类中其他⽅法，尽量是staticpublic static void doSomething(){}}使⽤场景：●要求⽣成唯⼀序列号的环境；●在整个项⽬中需要⼀个共享访问点或共享数据，例如⼀个Web页⾯上的计数器，可以不⽤把每次刷新都记录到数据库中，使⽤单例模式保持计数器的值，并确保是线程安全的；●创建⼀个对象需要消耗的资源过多，如要访问IO和数据库等资源；●需要定义⼤量的静态常量和静态⽅法（如⼯具类）的环境，可以采⽤单例模式（当然，也可以直接声明为static的⽅式）。
线程不安全实例：public class Singleton {private static Singleton singleton = null;//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){if(singleton == null){singleton = new Singleton();}return singleton;}}解决办法：在getSingleton⽅法前加synchronized关键字，也可以在getSingleton⽅法内增加synchronized来实现。
设计模式二三事
问题发现 问题1: 条件判断臃肿，不具备扩展性 问题2: 任务类耦合度高
解决方案 使用状态模式优化状态流转 使用观察者模式优化消息通知
状态模式
环境类（Context）角色 抽象状态（State）角色 具体状态（Concrete State）角色
优化后的任务类 耦合度降低 符合开闭原则
观察者模式
活动迭代重构_类图
最终的类图展示了活动迭代重构的结构。 使用设计模式成功地改进了活动构建 和风险控制。
总结
小明通过自主分析和设计模式的知识，成功完成了活动模型的重构和迭 代。 设计模式是软件设计的最佳实践，持续学习和应用非常重要。
场景一：单例模式
小明：老师，什么是单例模式？ 老师：单例模式是一种保证类只有一个实例的设计模式。 小明：它有什么优点和缺点呢？ 老师：它可以节省资源，但可能会引入全局状态。
结合优化思路 创建策略模式的环境类 奖励服务调用的过程
继续优化
策略类的状态问题 单例模式的介绍
单例模式 单例模式的定义和作用 使用饿汉式单例模式优化策略类设计
任务模型的设计 01
LOREM IPSUM DOLOR
任务模型设计 任务状态与消息通知的优化设计 状态模式与观察者模式应用
背景 老师提出任务模型设计需求 考虑任务状态流转和消息通知
设计模式的分类
创建型设计模式 结构型设计模式 行为型设计模式
常用的设计模式
单例模式 工厂模式 观察者模式
单例模式
单例模式的定义 应用场景 示例代码
工厂模式
工厂模式的定义 应用场景 示例代码
观察者模式
观察者模式的定义 应用场景 示例代码
奖励的发放策略 02
LOREM IPSUM DOLOR
游戏角色设计(中英对照)
游戏角色设计Game character design一．游戏角色角色作为一个游戏的灵魂，一直贯穿着一个游戏的始终，始终是游戏玩家关注的焦点。
所谓游戏角色，简单的说，就是在游戏中你控制的角色。
Game character is the soul of the game, running through the whole process of the game; the game character has always been a focus of the game player. What is game character? In brief, it is just the character that you can control in the game.现在，游戏角色不仅成为一种特殊的文化现象，而且进一步以其衍生产品的开发和扩展形成了利润丰厚庞大的游戏产业。
游戏角色设计就像拍电影、做动画一样,除了技术方面,它们必须顾及美观和玩家的欣赏心理.Nowadays, the Game character is not only a special culture phenomenon ,but also further extends (扩展）and develops to be a huge profitable （利益丰厚的）game industry（游戏产业）. The game character design is like a movie, like an animation （动画）, in addition to the technical aspects（技术方面）, they must consider the appreciation（欣赏）of appearance（外观）and game player.比如比卡丘、愤怒的小鸟、超级马里奥，这些年轻人喜爱和熟悉的游戏角色,其巨大的市场号召力证明了它们的创造者的成功。
C#设计模式系列：建造者模式（Builder）
C#设计模式系列：建造者模式（Builder）11.1 定义 建造者模式（Builder）将复杂的构建与其表⽰相分离，使得同样的构建过程可以创建不同的表⽰。
1.2 使⽤频率 中低22.1 结构图2.2 参与者 建造者模式参与者： ◊ Builder：为创建⼀个Product对象的各个部件指定抽象接⼝； ◊ ConcreteBuilder ° 实现Builder的接⼝以构造和装配该产品的各个部件 ° 定义并明确它所创建的表⽰ ° 提供⼀个检索Product的接⼝ ◊ Director：构造⼀个使⽤Builder接⼝的对象； ◊ Product ° 表⽰被构造的复杂对象。
ConcreteBuilder创建该产品的内部表⽰并定义它的装配过程 ° 包含定义组成部件的类，包括将这些部件装配成最终产品的接⼝ 在建造者模式中，Director规定了创建⼀个对象所需要的步骤和次序，Builder则提供了⼀些列完成这些步骤的⽅法，ConcreteBuilder给出了这些⽅法的具体实现，是对象的直接创建者。
3 建造者模式结构实现 Product.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural{public class Product{private List<string> _parts = new List<string>();public void Add(string part){_parts.Add(part);}public void Show(){Console.WriteLine("Product Parts");foreach (string part in _parts){Console.WriteLine(part);}}}} Builder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public abstract class Builder{public abstract void BuildPartA();public abstract void BuildPartB();public abstract Product GetResult();}} ConcreteBuilder1.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public class ConcreteBuilder1 : Builder{private Product _product = new Product();public override void BuildPartA(){_product.Add("PartA");}public override void BuildPartB(){_product.Add("PartB");}public override Product GetResult(){return _product;}}} ConcreteBuilder2.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public class ConcreteBuilder2 : Builder{private Product _product = new Product();public override void BuildPartA(){_product.Add("PartX");}public override void BuildPartB(){_product.Add("PartY");}public override Product GetResult(){return _product;}}} Director.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Structural {public class Director{///<summary>/// Builder uses a complex series of steps///</summary>public void Construct(Builder builder){builder.BuildPartA();builder.BuildPartB();}}} Program.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using DesignPatterns.BuilderPattern.Structural; namespace DesignPatterns.BuilderPattern{class Program{static void Main(string[] args){// Create director and buildersDirector director = new Director();Builder b1 = new ConcreteBuilder1();Builder b2 = new ConcreteBuilder2();// Construct two productsdirector.Construct(b1);Product p1 = b1.GetResult();p1.Show();director.Construct(b2);Product p2 = b2.GetResult();p2.Show();}}} 运⾏输出：Product PartsPartAPartBProduct PartsPartXPartY请按任意键继续. . .4、建造者模式实践应⽤ Vehicle.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{///<summary>/// The 'Product' class///</summary>public class Vehicle{private string _vehicleType;private Dictionary<string, string> _parts = new Dictionary<string, string>();///<summary>/// Constructor///</summary>public Vehicle(string vehicleType){this._vehicleType = vehicleType;}///<summary>/// Indexer///</summary>public string this[string key]{get { return _parts[key]; }set { _parts[key] = value; }}public void Show(){Console.WriteLine("\n---------------------------");Console.WriteLine("Vehicle Type: {0}", _vehicleType);Console.WriteLine(" Frame : {0}", _parts["frame"]);Console.WriteLine(" Engine : {0}", _parts["engine"]);Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);Console.WriteLine(" #Doors : {0}", _parts["doors"]);}}} VehicleBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{///<summary>/// The 'Builder' abstract class///</summary>public abstract class VehicleBuilder{protected Vehicle vehicle;// Gets vehicle instancepublic Vehicle Vehicle{get { return vehicle; }}// Abstract build methodspublic abstract void BuildFrame();public abstract void BuildEngine();public abstract void BuildWheels();public abstract void BuildDoors();}} MotorCycleBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{public class MotorCycleBuilder : VehicleBuilder {public MotorCycleBuilder(){vehicle = new Vehicle("MotorCycle");}public override void BuildFrame(){vehicle["frame"] = "MotorCycle Frame";}public override void BuildEngine(){vehicle["engine"] = "500 cc";}public override void BuildWheels(){vehicle["wheels"] = "2";}public override void BuildDoors(){vehicle["doors"] = "0";}}} CarBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical {public class CarBuilder : VehicleBuilder{public CarBuilder(){vehicle = new Vehicle("Car");}public override void BuildFrame(){vehicle["frame"] = "Car Frame";}public override void BuildEngine(){vehicle["engine"] = "2500 cc";}public override void BuildWheels(){vehicle["wheels"] = "4";}public override void BuildDoors(){vehicle["doors"] = "4";}}} ScooterBuilder.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical {public class ScooterBuilder : VehicleBuilder{public ScooterBuilder(){vehicle = new Vehicle("Scooter");}public override void BuildFrame(){vehicle["frame"] = "Scooter Frame";}public override void BuildEngine(){vehicle["engine"] = "50 cc";}public override void BuildWheels(){vehicle["wheels"] = "2";}public override void BuildDoors(){vehicle["doors"] = "0";}}} Shop.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DesignPatterns.BuilderPattern.Practical{public class Shop{public void Construct(VehicleBuilder vehicleBuilder) {vehicleBuilder.BuildFrame();vehicleBuilder.BuildEngine();vehicleBuilder.BuildWheels();vehicleBuilder.BuildDoors();}}} Program.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using DesignPatterns.BuilderPattern.Practical; namespace DesignPatterns.BuilderPattern{class Program{static void Main(string[] args){VehicleBuilder builder;// Create shop with vehicle buildersShop shop = new Shop();// Construct and display vehiclesbuilder = new ScooterBuilder();shop.Construct(builder);builder.Vehicle.Show();builder = new CarBuilder();shop.Construct(builder);builder.Vehicle.Show();builder = new MotorCycleBuilder();shop.Construct(builder);builder.Vehicle.Show();}}} 运⾏输出：---------------------------Vehicle Type: ScooterFrame : Scooter FrameEngine : 50 cc#Wheels: 2#Doors : 0---------------------------Vehicle Type: CarFrame : Car FrameEngine : 2500 cc#Wheels: 4#Doors : 4---------------------------Vehicle Type: MotorCycleFrame : MotorCycle FrameEngine : 500 cc#Wheels: 2#Doors : 0请按任意键继续. . .5 建造者模式适⽤情形： ◊ 需要⽣成的产品对象有复杂的内部结构 ◊ 需要⽣成的产品对象的属性相互依赖，建造者模式可以强迫⽣成顺序 ◊ 在对象创建过程中会使⽤到系统中的⼀些其他对象，这些对象在产品对象的创建过程中不易得到 建造者模式特点： ◊ 建造者模式的使⽤使得产品的内部表对象可以独⽴地变化。
什么情况下才应该使用建造者模式
什么情况下才应该使用建造者模式一、什么是建造者模式建造者模式是一种创建型设计模式，它允许你创建复杂对象的过程与其表示分离，使得同样的构建过程可以创建不同的表示形式，通常用于创建对象构造器参数数量较多的对象。
二、建造者模式的特点1、将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示形式。
2、隐藏系统组件的复杂性，使用户仅需要指定需要的部件构造方式即可得到所需对象。
3、封装复杂构建过程，使其可以独立变化，而不会影响其他部分。
三、什么情况下应该使用建造者模式1、需要创建复杂的对象，其构造器参数数量较多，且参数之间存在一定的依赖关系。
例如汽车制造业，在制造汽车时需要大量的构造参数，如发动机、车轮、座椅、空调等，这些构造参数之间存在着一定的依赖关系，使用建造者模式可以将不同的构造参数组合成不同的汽车对象。
2、需要创建可复用的对象，可以通过调用不同的构造器，创建不同的表示形式。
例如使用建造者模式可以设计一个模板化的房屋模型，根据不同的需求，调用不同的构造器，创建不同的风格、不同大小的住宅。
3、需要隐藏构造细节，使得用户只需关注如何创建对象，无需了解对象的构建细节。
例如在游戏制作中，需要创建一系列特定的游戏角色，使用建造者模式可以隐藏构建细节，使得用户只需指定角色类型，即可创建所需角色。
四、建造者模式的优缺点优点：1、通过建造者模式，可以将对象的构建与表示分离，使得构建过程可以灵活地改变，而不会对用户造成影响。
2、使用建造者模式可以封装构建细节，使得对象的构建过程更加简单灵活，且易于扩展。
3、可以创建不同形式的对象表示方式，以满足不同的用户需求。
缺点：1、建造者模式需要创建许多不同的类，增加系统复杂性。
2、建造者模式的创建过程较为复杂，需要多个类之间的协作，需要耗费较多的时间和精力。
五、建造者模式的实例在实际应用中，建造者模式被广泛使用，例如在Java的StringBuilder类中，就是使用了建造者模式，其允许你将多个字符串连接在一起，构建成一个新的字符串。
java 建造者模式链式调用条件处理
一、概述建造者模式是一种创建型设计模式，通过使用链式调用的方式来构建复杂的对象。
在Java中，建造者模式可以帮助我们简化对象的构建过程，并且提供了一种灵活的方式来处理不同的构建条件。
本文将介绍Java建造者模式的基本原理以及如何使用链式调用来处理条件。
二、建造者模式的基本原理建造者模式通过将一个复杂对象的构建过程分解成多个简单的步骤来实现。
它包括以下几个主要角色：1. 产品（Product）：需要被构建的复杂对象。
2. 抽象建造者（Builder）：定义了构建产品的接口，包括构建产品的各个步骤。
3. 具体建造者（ConcreteBuilder）：实现了抽象建造者接口，负责具体的产品构建过程。
4. 指挥者（Director）：负责组装具体建造者来构建最终的产品。
三、Java建造者模式的实现在Java中，建造者模式可以通过链式调用的方式来实现。
链式调用是指在调用对象方法时，每次调用都返回一个新的对象，从而可以在一个表达式中连续调用多个方法。
这种方式可以使代码更加清晰、简洁，并且提供了一种灵活的方式来处理条件。
四、链式调用的条件处理在使用建造者模式的过程中，有时候会根据不同的条件来设置对象的属性或调用不同的方法。
链式调用可以很好地处理这种情况。
下面是一些处理条件的示例代码：1. 使用if-else语句处理条件```javapublic class ProductBuilder {private Product product;public ProductBuilder() {product = new Product();}public ProductBuilder setName(String name) {product.setName(name);return this;}public ProductBuilder setPrice(int price) {product.setPrice(price);return this;}public ProductBuilder setCategory(String category) { if (category.equals("book")) {product.setDiscount(0.1);} else {product.setDiscount(0.0);}product.setCategory(category);return this;}public Product build() {return product;}}```2. 使用策略模式处理条件```javapublic interface DiscountStrategy {double applyDiscount(double price);}public class BookDiscountStrategy implementsDiscountStrategy {Overridepublic double applyDiscount(double price) { return price * 0.9;}}public class OtherDiscountStrategy implements DiscountStrategy {Overridepublic double applyDiscount(double price) { return price;}}public class ProductBuilder {private Product product;public ProductBuilder() {product = new Product();}public ProductBuilder setName(String name) {product.setName(name);return this;}public ProductBuilder setPrice(int price) {product.setPrice(price);return this;}public ProductBuilder setCategory(String category) {DiscountStrategy discountStrategy;if (category.equals("book")) {discountStrategy = new BookDiscountStrategy();} else {discountStrategy = new OtherDiscountStrategy();}product.setPrice(discountStrategy.applyDiscount(product.getPri ce()));product.setCategory(category);return this;}public Product build() {return product;}}```3. 使用Optional类处理可选属性```javapublic class Product {private String name;private int price;private String category;private Optional<Double> discount;public Product(String name, int price, String category) { = name;this.price = price;this.category = category;this.discount = Optional.empty();}public Product setDiscount(double discount) {this.discount = Optional.of(discount);return this;}}public class ProductBuilder {private Product product;public ProductBuilder(String name, int price, String category) {product = new Product(name, price, category);}public Product build() {return product;}}```五、总结建造者模式是一种非常有用的设计模式，它可以帮助我们简化对象的构建过程，并且提供了一种灵活的方式来处理条件。
射击类游戏的设计模式教程(一)
常见的游戏设计模式有很多，游戏开发者在选择过程中要注意类别，有些对游戏项目引擎设计并没有很多的利用价值，以下是经过精心挑选的射击类游戏常见的设计模式，在设计游戏时可以参考使用。
为了方便大家更加系统地学习和掌握各种常用的设计模式，下面通过一个综合实例——“多人联机射击游戏”来学习如何在实际开发中综合使用设计模式。
反恐精英(Counter-Strike,CS)、三角洲部队、战地等多人联机射击游戏广受玩家欢迎，在多人联机射击游戏的设计中，可以使用多种设计模式。
下面我选取一些较为常用的设计模式进行分析：1、抽象工厂模式在联机射击游戏中提供了多种游戏场景，不同的游戏场景提供了不同的地图、不同的背景音乐、不同的天气等，因此可以使用抽象工厂模式进行设计，类图如图1所示：图1抽象工厂模式实例类图在图1中，SceneFactory充当抽象工厂，其子类SceneAFactory等充当具体工厂，可以创建具体的地图(Map)、背景音乐(Music)和天气(Weather)等产品对象，如果需要增加新场景，只需增加新的具体场景工厂类即可。
2、建造者模式在联机射击游戏中每一个游戏人物角色都需要提供一个完整的角色造型，包括人物造型、服装、武器等，可以使用建造者模式来创建一个完整的游戏角色，类图如图2所示：图2建造者模式实例类图在图2中，PlayerCreatorDirector充当指挥者角色，PlayerBuilder是抽象建造者，其子类PlayerBuilderA和PlayerBuilderB是具体建造者，用于创建不同的游戏角色，Player是所创建的完整产品，即完整的游戏角色，它包含形体(body)、服装(costume)和武器(weapon)等组成部分。
3、工厂方法模式在射击游戏中，AK47冲锋步枪、狙击枪、手枪等不同武器(Weapon)的外观、使用方法和杀伤力都不相同，玩家可以使用不同的武器，而且游戏升级时还可以增加新的武器，无需对现有系统做太多修改，可使用工厂方法模式来设计武器系统，类图如图3所示：图3工厂方法模式实例类图在图3中，WeaponFactory接口表示抽象武器工厂，其子类AK47GunFactory 生产AK47Gun，SniperRifleFactory生产SniperRifle，不同的武器的display()、use()和fire()等方法有不同的实现。
设计模式的理解与应用
设计模式的理解与应用设计模式的理解与应用引言设计模式是软件开发中常用的一种思想和方法，它提供了一套经过验证的解决方案，能够帮助开发人员解决常见的设计问题。
本文将介绍设计模式的基本概念、分类以及常见的应用场景。
一、设计模式的基本概念1.1 设计模式的定义设计模式是在软件开发中针对特定问题所提出的一种解决方案。
它是经过多次实践和验证，在特定环境下能够提高代码质量、可维护性和可复用性的一种编程思想。
1.2 设计模式的目标设计模式主要有以下几个目标：- 提高代码质量：通过使用设计模式，可以使代码结构更清晰、更易于理解和维护。
- 提高可维护性：设计模式可以降低代码之间的耦合度，使得修改某个功能时不会影响到其他部分。
- 提高可复用性：通过将常见功能封装成独立的组件，可以在不同项目中重复使用。
- 提高可扩展性：通过使用设计模式，可以更容易地添加新功能或修改现有功能。
二、设计模式的分类2.1 创建型模式创建型模式主要关注对象的创建方式，包括以下几种常见的设计模式：- 单例模式：确保一个类只有一个实例，并提供全局访问点。
- 工厂模式：将对象的创建过程封装在工厂类中，客户端通过工厂类来创建对象。
- 抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
- 建造者模式：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
2.2 结构型模式结构型模式主要关注对象之间的组合方式，包括以下几种常见的设计模式：- 适配器模式：将一个类的接口转换成客户端所期望的另一种接口。
- 装饰器模式：动态地给一个对象添加一些额外的职责，同时又不改变其结构。
- 代理模式：为其他对象提供一种代理以控制对这个对象的访问。
- 桥接模式：将抽象部分与它们的实现部分分离，使它们可以独立地变化。
2.3 行为型模式行为型模式主要关注对象之间的通信方式和责任分配，包括以下几种常见的设计模式：- 观察者模式：定义对象之间的一种一对多的依赖关系，当一个对象状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
设计模式-创造型模式
设计模式-创造型模式创建型模式共分五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。
下⾯来⼀⼀介绍简单⼯⼚⽅法模式（普通、多个⽅法、多个静态⽅法）/*定义⼀个通⽤接⼝，提供需要通⽤⽅法*/public interface Sender {public void send();}public class SmsSender implements Sender {@Overridepublic void send() {System.out.println("this is sms sender!");}}public class MailSender implements Sender{@Overridepublic void send() {System.out.println("this is mailsender!");}}/*定义⼀个⼯⼚类，提供⽣产⽅法，有可能是⼀个，也可能是多个，甚⾄是静态的，让类把实例化推迟到⼦类*/public class SendFactory {public Sender produce(String type) {if ("mail".equals(type)) {return new MailSender();} else if ("sms".equals(type)) {return new SmsSender();} else {System.out.println("请输⼊正确的类型!");return null;}}}/*测试*/public class FactoryTest {public static void main(String[] args) {SendFactory factory = new SendFactory();Sender sender = factory.produce("sms");sender.send();}}抽象⼯⼚模式 上⾯的简单⼯⼚模式会有⼀个问题，如果业务扩展，我们需要⼀个发送通知的功能，那么就需要修改⼯⼚类代码，这也违反了闭包原则(不可修改)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
完整解决方案Sunny公司开发人员决定使用建造者模式来实现游戏角色的创建，其基本结构如图8-3所示：图7-1 游戏角色创建结构图在图7-1中，ActorController充当指挥者，ActorBuilder充当抽象建造者，HeroBuilder、AngelBuilder和DevilBuilder充当具体建造者，Actor充当复杂产品。
完整代码如下所示：//Actor角色类：复杂产品，考虑到代码的可读性，只列出部分成员属性，且成员属性的类型均为String，真实情况下，有些成员属性的类型需自定义class Actor{private String type; //角色类型private String sex; //性别private String face; //脸型private String costume; //服装private String hairstyle; //发型public void setType(String type) {this.type = type;}public void setSex(String sex) {this.sex = sex;}public void setFace(String face) {this.face = face;}public void setCostume(String costume) {this.costume = costume;}public void setHairstyle(String hairstyle) {this.hairstyle = hairstyle;}public String getType() {return (this.type);}public String getSex() {return (this.sex);}public String getFace() {return (this.face);}public String getCostume() {return (this.costume);}public String getHairstyle() {return (this.hairstyle);}}//角色建造器：抽象建造者abstract class ActorBuilder{protected Actor actor = new Actor();public abstract void buildType();public abstract void buildSex();public abstract void buildFace();public abstract void buildCostume();public abstract void buildHairstyle();//工厂方法，返回一个完整的游戏角色对象public Actor createActor(){return actor;}}//英雄角色建造器：具体建造者class HeroBuilder extends ActorBuilder{public void buildType(){actor.setType("英雄");}public void buildSex(){actor.setSex("男");}public void buildFace(){actor.setFace("英俊");}public void buildCostume(){actor.setCostume("盔甲");}public void buildHairstyle(){actor.setHairstyle("飘逸");}}//天使角色建造器：具体建造者class AngelBuilder extends ActorBuilder {public void buildType(){actor.setType("天使");}public void buildSex(){actor.setSex("女");}public void buildFace(){actor.setFace("漂亮");}public void buildCostume(){actor.setCostume("白裙");}public void buildHairstyle(){actor.setHairstyle("披肩长发");}}//恶魔角色建造器：具体建造者class DevilBuilder extends ActorBuilder {public void buildType(){actor.setType("恶魔");}public void buildSex(){actor.setSex("妖");}public void buildFace(){actor.setFace("丑陋");}public void buildCostume(){actor.setCostume("黑衣");}public void buildHairstyle(){actor.setHairstyle("光头");}}指挥者类ActorController定义了construct()方法，该方法拥有一个抽象建造者ActorBuilder类型的参数，在该方法内部实现了游戏角色对象的逐步构建，代码如下所示：//游戏角色创建控制器：指挥者class ActorController{//逐步构建复杂产品对象public Actor construct(ActorBuilder ab){Actor actor;ab.buildType();ab.buildSex();ab.buildFace();ab.buildCostume();ab.buildHairstyle();actor=ab.createActor();return actor;}}为了提高系统的灵活性和可扩展性，我们将具体建造者类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：import javax.xml.parsers.*;import org.w3c.dom.*;import org.xml.sax.SAXException;import java.io.*;class XMLUtil{//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象public static Object getBean(){try{//创建文档对象DocumentBuilderFactory dFactory =DocumentBuilderFactory.newInstance();DocumentBuilder builder = dFactory.newDocumentBuilder();Document doc;doc = builder.parse(new File("config.xml"));//获取包含类名的文本节点NodeList nl = doc.getElementsByTagName("className");Node classNode=nl.item(0).getFirstChild();String cName=classNode.getNodeValue();//通过类名生成实例对象并将其返回Class c=Class.forName(cName);Object obj=c.newInstance();return obj;}catch(Exception e){e.printStackTrace();return null;}}}配置文件config.xml中存储了具体建造者类的类名，代码如下所示：<?xml version="1.0"?><config><className>AngelBuilder</className></config>编写如下客户端测试代码：class Client{public static void main(String args[]){ActorBuilder ab; //针对抽象建造者编程ab = (ActorBuilder)XMLUtil.getBean(); //反射生成具体建造者对象ActorController ac = new ActorController();Actor actor;actor = ac.construct(ab); //通过指挥者创建完整的建造者对象String type = actor.getType();System.out.println(type + "的外观：");System.out.println("性别：" + actor.getSex());System.out.println("面容：" + actor.getFace());System.out.println("服装：" + actor.getCostume());System.out.println("发型：" + actor.getHairstyle());}}编译并运行程序，输出结果如下：天使的外观：性别：女面容：漂亮服装：白裙发型：披肩长发在建造者模式中，客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型，指挥者将指导具体建造者一步一步构造一个完整的产品（逐步调用具体建造者的buildX()方法），相同的构造过程可以创建完全不同的产品。
在游戏角色实例中，如果需要更换角色，只需要修改配置文件，更换具体角色建造者类即可；如果需要增加新角色，可以增加一个新的具体角色建造者类作为抽象角色建造者的子类，再修改配置文件即可，原有代码无须修改，完全符合“开闭原则”。