1、生成器模式

      我们知道工厂模式能够根据传递给构造方法返回几个不同子类中的一个，假设我们不但需要一个用于计算的算法，还要根据显示的数据不通而现实不同的界面，我们就知道改如何使用生成器模式（Builder Pattern）。生成器模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示我们用个栗子看看。还是造车。

/// <summary>
/// 造车步骤
/// </summary>
public abstract class Builder
{
    /// <summary>
    /// 造轮子
    /// </summary>
    public abstract void MakeWheels();
    /// <summary>
    /// 组装
    /// </summary>
    public abstract void Assemble();
    /// <summary>
    /// 喷漆
    /// </summary>
    public abstract void Painting();
}

     再写一个造大车跟造小车的类

/// <summary>
/// 造大车
/// </summary>
public class BigBuilder : Builder
{
    public override void Assemble()
    {
        Console.WriteLine("大车组装完成啦");
    }

    public override void MakeWheels()
    {
        Console.WriteLine("大车轮子造好啦！");
    }

    public override void Painting()
    {
        Console.WriteLine("大车喷漆完成！");
    }
}
/// <summary>
/// 造小车
/// </summary>
public class SmallBuilder : Builder
{
    public override void Assemble()
    {
        Console.WriteLine("小车组装完成啦");
    }

    public override void MakeWheels()
    {
        Console.WriteLine("小车轮子造好啦！");
    }

    public override void Painting()
    {
        Console.WriteLine("小车喷漆完成！");
    }
}

     后面加一个工厂 造车的。它使用Builder来创建不同种类的汽车

/// <summary>
/// 造车工厂
/// </summary>
public class CarFactory
{
    public Builder Builder { get; set; }
    public CarFactory(Builder builder)
    {
        Builder=builder;
    }
    /// <summary>
    /// 造车
    /// </summary>
    public void CreateCar()
    {
        Builder.MakeWheels();//轮子
        Builder.Assemble();//组装
        Builder.Painting();//喷漆
    }
    

}

//客户端调用
CarFactory cf = new(new BigBuilder());
cf.CreateCar();
cf.Builder = new SmallBuilder();
cf.CreateCar();

     所以可以看出生成器模式的好处：

    允许读者改变产品内部表示，同事也影藏了产品如何装的问题；

    每个特定的生成器都独立于其他的生成器，同事独立于程序的其他部分。所以能精确的控制生成器构建的结果；

    生成器的模式类似于抽象工厂模式，两者都返回了相同的方法个对象组成的类。他们之间主要的差别是抽象工厂返回一一系列相关的类而生成器是根据它提供的数据一步一步的构建出一个复杂的对象。　

  建造者模式的缺点：

    当组件的组合种类很多时，需要创建很多的具体建造者类。

2、适配器模式

       适配器模式（Adapter  Pattern）可以将一个程序设计接口转换为另外一个接口。当我们想让不相关的类在同一个程序里面一起工作的时候就可以用适配器的模式。一是继承可以实现，从一个不一致的类派生出一个新类添加需要的方法让派生类满足所需要的接口；二是对象组合，就是把原始类包含在新类里面，然后再新类里面创建方法转换调用。这两种方法统称为类适配器和对象适配器。说着有点指鹿为马的感觉了（程序中就是这样的）。这里有三个角色。

   初始角色：我们需要的功能，但是接口不匹配；

   目标角色：他就表现了客户需要的接口

   适配器觉得：实现了目标接口

   举个栗子 我是苹果手机想充钱，但是我只有安卓的充电线，这时候是不是就要找一个转接头来我们也可以充电了。

/// <summary>
/// 安卓充电
/// </summary>
public class Android
{
    public void AndroidCharge()
    {
        Console.WriteLine("安卓充电");
    }
}
/// <summary>
/// 苹果接口充电
/// </summary>
public interface IApple
{
    /// <summary>
    /// 目标方法
    /// </summary>
    void AppleChage();
}
public class AppleAdater : IApple
{
    Android ad = new Android();
    /// <summary>
    /// 评估充电，实际上是调用安卓的充电方法
    /// </summary>
    public void AppleChage()
    {
        ad.AndroidCharge();
    }
}

//客户端调用
IApple app = new AppleAdater();
app.AppleChage();

适配器模式的优点：

　　1.提高代码复用，复用了Adaptee中的方法

　　2.灵活性好，如没有关联的两个类A和类B，类A想借用类B的方法，可以在类A中添加一个类B的实例，然后调用类B实例的方法即可。

适配器模式的缺点：

　　1.过多使用适配器会让会同凌乱，如我们明明调用的是A接口的功能，但是却被适配成了B接口的功能。

PS:每个人都应该把自己的每一天当成一场自我的创作，在这创作中诚实的体现自己，而且把这一天当作是一个无法重复的一天，抱持着不能复制的心情过好这一天。