一. 组合模式
1. 背景
在现实生活中，存在很多“部分-整体”的关系，例如，大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样，例如，文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。
2. 定义和特点
(1). 定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。
(2). 优点：
A. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
B. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；
(3). 缺点
A. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
B. 不容易限制容器中的构件；
C. 不容易用继承的方法来增加构件的新功能；
3. 具体实现
(1). 模式结构
可以自身嵌套结构。
(2). 使用场景
存储上下级关系，CEO→技术主管→员工；CEO→销售主管→员工。
(3). 代码实操
上下级自身嵌套代码：
/// <summary> /// 员工类 /// </summary> public class Employee { private string name; private string dept; private int salary; //代表下级子类 private List<Employee> subordinates;
//构造函数 public Employee(string name, string dept, int sal) { this.name = name; this.dept = dept; this.salary = sal; subordinates = new List<Employee>(); }
public void add(Employee e) { subordinates.Add(e); }
public void remove(Employee e) { subordinates.Remove(e); }
public List<Employee> getSubordinates() { return subordinates; }
public string toString() { return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary + " ]"); } }
复制代码
测试代码：
{ // 1、树形机构的场景，使用组合模式 Employee CEO = new Employee("张三", "CEO", 30000);
Employee headMarketing = new Employee("李四", "技术经理", 20000); Employee headSales = new Employee("王五", "销售经理", 20000);
Employee clerk1 = new Employee("赵六", "销售", 10000); Employee clerk2 = new Employee("钱七", "销售", 10000);
Employee salesExecutive1 = new Employee("Tony", "技术", 10000); Employee salesExecutive2 = new Employee("Mark", "技术", 10000);
CEO.add(headSales); CEO.add(headMarketing);
headSales.add(clerk1); headSales.add(clerk2);
headMarketing.add(salesExecutive1); headMarketing.add(salesExecutive2);
//打印该组织的所有员工 Console.WriteLine(CEO.toString()); foreach (Employee headEmployee in CEO.getSubordinates()) { Console.WriteLine(headEmployee.toString()); foreach (Employee employee in headEmployee.getSubordinates()) { Console.WriteLine(employee.toString()); } } }
复制代码
运行结果：
4. 适用场景分析
A. 在需要表示一个对象整体与部分的层次结构的场合。
B. 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。
更多 C++后台开发技术点知识内容包括 C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，MongoDB，ZK，流媒体，音视频开发，Linux 内核，TCP/IP，协程，DPDK 多个高级知识点。
C/C++Linux服务器开发高级架构师/C++后台开发架构师免费学习地址
【文章福利】另外还整理一些C++后台开发架构师 相关学习资料，面试题，教学视频，以及学习路线图，免费分享有需要的可以点击领取
二. 建筑者模式
1. 背景
在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 OPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。
生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。
以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式可以很好地描述该类产品的创建。
2. 定义和特点
(1). 定义
指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
(2). 优点
A. 各个具体的建造者相互独立，有利于系统的扩展。
B. 客户端不必知道产品内部组成的细节，便于控制细节风险。
(3). 缺点
A. 产品的组成部分必须相同，这限制了其使用范围。
B. 如果产品的内部变化复杂，该模式会增加很多的建造者类。
(4). 与工厂方法模式的区别
建造者模式注重零部件的组装过程，而工厂方模式更注重零部件的创建过程，但两者可以结合使用。
3. 具体实现
(1). 模式结构
建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。
A. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
B. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
C. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
D. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。
PS：如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。
结构图如下：
(2). 使用场景
现在要构建自行车，包括核心组件 frame、seat、tire，而每个组件可选的材料有多种，自行车的构建顺序是固定的，比如按照这个顺序：BuidFrame、BuildSeat、BuildTire。这个场景就可以使用建筑者模式。
(3). 代码实操
各种自行车材料代码：
/// <summary> /// 自行车框架 /// </summary> public interface IFrame { void show(); } /// <summary> /// 自行车座椅 /// </summary> public interface ISeat { void show(); } /// <summary> /// 自行车轮胎 /// </summary> public interface ITire { void show(); } /// <summary> /// 合金自行车框架1 /// </summary> public class AlloyFrame1 : IFrame { public void show() { Console.WriteLine("我是合金自行车框架1"); } } /// <summary> /// 合金自行车框架2 /// </summary> public class AlloyFrame2 : IFrame { public void show() { Console.WriteLine("我是合金自行车框架2"); } } /// <summary> /// 真皮座椅1 /// </summary> public class DermisSeat1 : ISeat { public void show() { Console.WriteLine("我是真皮座椅1"); } } /// <summary> /// 真皮座椅2 /// </summary> public class DermisSeat2 : ISeat { public void show() { Console.WriteLine("我是真皮座椅2"); } } /// <summary> /// 结实的轮胎1 /// </summary> public class SolidTire1 : ITire { public void show() { Console.WriteLine("我是结实的轮胎1"); } } /// <summary> /// 结实的轮胎2 /// </summary> public class SolidTire2 : ITire { public void show() { Console.WriteLine("我是结实的轮胎2"); } }
复制代码
自行车代码：
/// <summary> /// 自行车类 /// </summary> public class Bike { /// <summary> /// 自行车框架 /// </summary> public IFrame frame { set; get; } /// <summary> /// 自行车座椅 /// </summary> public ISeat seat { set; get; } /// <summary> /// 自行车 轮胎 /// </summary> public ITire tire { set; get; }
/// <summary> /// 获取自行车的详情信息 /// </summary> public void GetDetils() { Console.WriteLine("自行车的详细信息如下："); frame.show(); seat.show(); tire.show(); } }
复制代码
抽象建筑者和具体建筑者：
/// <summary> /// 抽象建筑者类 /// 如果只有一个具体的建筑者类，则可以省略该抽象建筑者类的 /// </summary> public abstract class AbstractBuilder { public Bike mBike = new Bike();
public abstract void BuildFrame();
public abstract void BuildSeat();
public abstract void BuildTire();
/// <summary> /// 返回自行车对象 /// </summary> /// <returns></returns> public abstract Bike Build();
} /// <summary> /// 自行车建筑者类1 /// </summary> public class BikeBuilder1: AbstractBuilder { /// <summary> /// 构建frame /// </summary> public override void BuildFrame() { mBike.frame = new AlloyFrame1(); }
/// <summary> /// 构建seat /// </summary> public override void BuildSeat() { mBike.seat = new DermisSeat1(); }
/// <summary> /// 构建tire /// </summary> public override void BuildTire() { mBike.tire = new SolidTire1(); }
/// <summary> /// 返回直行车对象 /// </summary> /// <returns></returns> public override Bike Build() { return mBike; } } /// <summary> /// 自行车建筑者类2 /// </summary> public class BikeBuilder2 : AbstractBuilder { /// <summary> /// 构建frame /// </summary> public override void BuildFrame() { mBike.frame = new AlloyFrame2(); }
/// <summary> /// 构建seat /// </summary> public override void BuildSeat() { mBike.seat = new DermisSeat2(); }
/// <summary> /// 构建tire /// </summary> public override void BuildTire() { mBike.tire = new SolidTire2(); }
/// <summary> /// 返回直行车对象 /// </summary> /// <returns></returns> public override Bike Build() { return mBike; } }
复制代码
指挥者：
/// <summary> /// 指挥者 /// 调用建造者中的方法完成复杂对象的创建 /// 如果只有一个建筑者的话,可以省略该指挥者的角色 /// </summary> public class BikeDirector { private AbstractBuilder _builder; public BikeDirector(AbstractBuilder builder) { this._builder = builder; } /// <summary> /// Bike的构建和组装 /// </summary> /// <returns></returns> public Bike CreateBike() { _builder.BuildFrame(); _builder.BuildSeat(); _builder.BuildTire();
return _builder.Build(); } }
复制代码
测试代码：
//1.普通模式 { Console.WriteLine("-------------------下面是普通模式构建自行车-------------------------"); //1. 构建自行车 Bike b = new Bike(); b.frame = new AlloyFrame1(); b.seat = new DermisSeat2(); b.tire = new SolidTire1();
//2. 输出自行车信息 b.GetDetils(); }
//2. 使用建筑者模式 { Console.WriteLine("-------------------下面是使用建筑者模式构建自行车-------------------------"); //1. 构建建筑者 BikeBuilder1 builder = new BikeBuilder1(); builder.BuildFrame(); builder.BuildSeat(); builder.BuildTire(); //2. 构建自行车 Bike bike = builder.Build(); //3. 输出自行车的信息 bike.GetDetils(); }
//3. 引入抽象建筑者父类 { Console.WriteLine("-------------------下面是 引入抽象建筑者父类 构建自行车-------------------------"); //1. 构建建筑者1 AbstractBuilder builder = new BikeBuilder1(); builder.BuildFrame(); builder.BuildSeat(); builder.BuildTire(); //2. 构建自行车 Bike bike = builder.Build(); //3. 输出自行车的信息 bike.GetDetils();
//1. 构建建筑者2 AbstractBuilder builder2 = new BikeBuilder2(); builder2.BuildFrame(); builder2.BuildSeat(); builder2.BuildTire(); //2. 构建自行车 Bike bike2 = builder2.Build(); //3. 输出自行车的信息 bike2.GetDetils(); }
//4. 引入指挥者 { Console.WriteLine("-------------------下面是 引入指挥者 构建自行车-------------------------"); //指挥者1 BikeDirector dirctor1 = new BikeDirector(new BikeBuilder1()); Bike bike1 = dirctor1.CreateBike(); bike1.GetDetils();
//指挥者2 BikeDirector dirctor2 = new BikeDirector(new BikeBuilder2()); Bike bike2 = dirctor2.CreateBike(); bike2.GetDetils(); }
复制代码
运行效果：
4. 适用场景分析
建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。
A. 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
B. 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
原文链接：https://www.cnblogs.com/yaopengfei/p/13462519.html
评论