当前位置： 首页 > article >正文

工厂方法模式和抽象工厂模式

article 2024/11/13 22:40:35

工厂方法模式

一个工厂只能创建一种产品

工厂方法模式的结构 

工厂方法模式包含以下4个角色 

Product（抽象产品）

ConcreteProduct（具体产品）

Factory（抽象工厂）

ConcreteFactory（具体工厂）

模式缺点

  1. 系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，会给系统带来一些额外的开销
  2. 增加了系统的抽象性和理解难度
  3. 一个具体工厂只能创建一种具体产品/如果我们想更换另外一种产品，仍然需要修改具体的工厂类

模式适用环境

  1. 客户端不知道它所需要的对象的类(客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体产品对象由具体工厂类创建)
  2. 抽象工厂类通过其子类来指定创建哪个对象

代码示例

Program

namespace 工厂模式
{
    internal class Program
    {
        static void Main(string[] arg)
        {
            IFactory factory = new TVFactroy();
            factory.ManfactureProduct().ShowInfo();

            //创建工厂
            IFactory factory1 = new WaterFactroy();
            factory1.ManfactureProduct().ShowInfo();
        }
    }
}

工厂基类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    /// <summary>
    /// 抽象工厂基类
    /// </summary>
    public abstract class IFactory
    {
        //生产产品
        public abstract IProduct ManfactureProduct();
    }
}

产品基类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    /// <summary>
    /// 抽象产品类
    /// </summary>
    public abstract class IProduct
    {
        public string Name { get; set; }//产品名称
        public abstract void ShowInfo();//展示产品信息
    }
}

具体电视工厂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    public class TVFactroy : IFactory
    {
        public override IProduct ManfactureProduct()
        {
            return new TVProduct("龙江彩电");
        }
    }
}

具体水工厂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    internal  class WaterFactroy: IFactory
    {
        public override IProduct ManfactureProduct()
        {
            return new WahingMachineProduck("龙江水");
        }
    }
}

水工厂里生产的产品

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    public class WahingMachineProduck : IProduct
    {
        public WahingMachineProduck(string name)
        {
            Name = name;
        }
        public override void ShowInfo()
        {
            Console.WriteLine($"一台{Name}被生产出来了");
        }
    }
}

电视工厂中生产的产品

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂模式
{
    public class TVProduct : IProduct
    {
        public TVProduct(string name)
        {
            Name = name;
        }
        public override void ShowInfo()
        {
            Console.WriteLine($"一台{Name}被生产出来了");
        }
    }
}

抽象工厂模式

一个工厂可以生产多个产品

抽象工厂方法模式的结构

抽象工厂模式包含以下4个角色：

• AbstractFactory （抽象工厂）
• ConcreteFactory （具体工厂）
• AbstractProduct （抽象产品）
• ConcreteProduct （具体产品）

代码示例



namespace _008_抽象工厂
{
    /// <summary>
    /// 抽象工厂
    /// </summary>
    public abstract class AbstractFactory
    {
        public  abstract AbstractProductTV CreateProductTV();//电视机生产线
        public abstract AbstractProductIceBox CreateProductIceBox();//冰盒子生产线
    }
}



namespace _008_抽象工厂
{
    /// <summary>
    /// 冰盒子基类__抽象产品B
    /// </summary>
    public abstract class AbstractProductIceBox
    {
        public string Name { get; set; }//产品名称
        public abstract void ShowInfo();//展示产品信息
    }
}



namespace _008_抽象工厂
{
    /// <summary>
    /// 电视机基类__抽象产品A
    /// </summary>
    public abstract class AbstractProductTV
    {
        public string Name { get; set; }//产品名称
        public abstract void ShowInfo();//展示产品信息
    }
}


namespace _008_抽象工厂
{
    /// <summary>
    /// 海尔冰箱_具体产品B1
    /// </summary>
    public class HaiErBox : AbstractProductIceBox
    {
        public override void ShowInfo()
        {
            Name = "海尔冰箱";
            Console.WriteLine($"一台{Name}被生产出来了");
        }
    }
}

namespace _008_抽象工厂
{
    /// <summary>
    /// 美的冰箱_具体产品B2
    /// </summary>
    public class MeiDiBox : AbstractProductIceBox
    {
        public override void ShowInfo()
        {
            Name = "美的冰箱";
            Console.WriteLine($"一台{Name}被生产出来了");
        }
    }
}

namespace _008_抽象工厂
{
    public class HaiErTV : AbstractProductTV
    {/// <summary>
    /// 海尔电视_具体产品A1
    /// </summary>
        public override void ShowInfo()
        {
            Name = "海尔电视";
            Console.WriteLine($"一台{Name}被生产出来了");
        }
    }
}

namespace _008_抽象工厂
{
    /// <summary>
    /// 美的电视_具体产品A2
    /// </summary>
    public class MeiDiTV:AbstractProductTV
    {
        public override void ShowInfo()
        {
            Name = "美的电视";
            Console.WriteLine($"一台{Name}被生产出来了");
        }
    }
}



namespace _008_抽象工厂
{
    /// <summary>
    /// 美的工厂__具体工厂
    /// </summary>
    public class MeiDiFactory : AbstractFactory
    {
        public override AbstractProductIceBox CreateProductIceBox()
        {
            return new MeiDiBox();
        }

        public override AbstractProductTV CreateProductTV()
        {
            return new MeiDiTV();
        }
    }
}




namespace _008_抽象工厂
{
    /// <summary>
    /// 海尔工厂__具体工厂
    /// </summary>
    public class HaiErFactory : AbstractFactory
    {
        public override AbstractProductTV CreateProductTV()
        {
            return new HaiErTV();
        }

        public override AbstractProductIceBox CreateProductIceBox()
        {
            return new HaiErBox();
        }
    }
}

调用

namespace _008_抽象工厂
{
    internal class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory factory=new HaiErFactory();
            factory.CreateProductIceBox();
            factory.CreateProductTV();
        }
    }
}

建造者模式

建造者模式的定义

建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

  • 将客户端与包含多个部件的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可
  • 关注如何逐步创建一个复杂的对象，不同的建造者定义了不同的创建过程

甚至可以把不同具体建造者的零部件，通过指挥者构造出不同的产品

建造者模式的结构

建造者模式包含以下4个角色：

  1. Builder（抽象建造者）
  2. ConcreteBuilder（具体建造者）
  3. Product（产品）
  4. Director（指挥者）

代码示例


namespace _009_建造者模式
{
    /// <summary>
    /// 抽象建造者
    /// </summary>
    public abstract class Builder
    {
       

        public ProductCar Car { get; set; }//产品引用
        public abstract void BuildEngine_A();//建造汽车引擎
        public abstract void BuildGearBox_B();//建造变速箱
        public abstract void BuildClutch_C();//建造离合器
        public abstract void BuildSteeringWheel_D();//建造汽车方向盘
        public abstract void BuildThrottle_E();//建造加速器

        public abstract ProductCar GetBuildResult();//返回建造的结果（产品）
    }
}




namespace _009_建造者模式
{
    /// <summary>
    /// 指挥者
    /// </summary>
    public class Director
    {
        private Builder _builder;//建造者引用
        //通过构造函数传入具体建造者
        public Director(Builder builder)
        {
            _builder = builder;
        }
        //构建方法1-自动挡（没有离合器）
        public ProductCar Construct()
        {
            _builder.BuildEngine_A();
            _builder.BuildGearBox_B();
            _builder.BuildSteeringWheel_D();
            _builder.BuildThrottle_E();
            Console.WriteLine("构建自动挡汽车");
            return _builder.GetBuildResult();
        }
    }
}



namespace _009_建造者模式
{
    /// <summary>
    /// 具体建造者A-江淮汽车
    /// </summary>
    public class JiangHuaiBuilder : Builder
    {
        public JiangHuaiBuilder()
        {
            Car = new ProductCar();
        }
        
        public override void BuildClutch_C()
        {
            Car.Clutch_C = "江淮离合器";
            Console.WriteLine("建造江淮离合器");
        }

        public override void BuildEngine_A()
        {
            Car.Engine_A = "江淮引擎";
            Console.WriteLine("建造江淮引擎");
        }

        public override void BuildGearBox_B()
        {
            Car.GearBox_B = "江淮变速器";
            Console.WriteLine("建造江淮变速器");
        }

        public override void BuildSteeringWheel_D()
        {
            Car.SteeringWheel_D = "江淮方向盘";
            Console.WriteLine("建造江淮方向盘");
        }

        public override void BuildThrottle_E()
        {
            Car.Throttle_E = "江淮加速器";
            Console.WriteLine("建造江淮加速器");
        }
        
        public override ProductCar GetBuildResult()
        {
            Console.WriteLine("构建产品成功");
            //返回建造的结果
            return Car;
        }
    }
}




namespace _009_建造者模式
{/// <summary>
/// 定义产品
/// </summary>
    public class ProductCar
    {
        public string Engine_A { get; set; }//发动机
        public string GearBox_B { get; set; }//变速箱
        public string Clutch_C { get; set; }//离合器
        public string SteeringWheel_D { get; set; }//方向盘

        public string Throttle_E { get; set; }
    }
}

调用测试

namespace _009_建造者模式
{
    internal class Program
    {
        
        static void Main(string[] args)
        {
            Builder builder=new JiangHuaiBuilder();//建造者
            Director director =new Director(builder);//指挥者
            ProductCar car = director.Construct();//指挥者指挥建造产品
        }
    }
}


http://www.kler.cn/a/304010.html

相关文章：

  • 【Pikachu】目录遍历实战
  • 基于迭代重加权最小二乘法的算法及例程
  • 应用程序部署（IIS的相关使用，sql server的相关使用）
  • pycharm快速更换虚拟环境
  • 【PGCCC】Postgresql Toast 原理
  • 生成模型——PixelRNN与PixelCNN
  • 考试：软件工程（01）
  • 非网站业务怎么接入高防IP抗DDoS
  • [PICO VR眼镜]眼动追踪串流Unity开发与使用方法，眼动追踪打包报错问题解决(Eye Tracking)
  • HTML5中Checkbox标签的深入全面解析
  • 位段、枚举、联合
  • Hazel 2024
  • 24.9.14学习笔记
  • 构造函数与析构函数的执行顺序
  • 多个系统运维压力大？统一运维管理为IT轻松解忧
  • 计算机网络八股总结
  • 使用vscode上传git远程仓库流程（Gitee）
  • uniapp点击跳转到对应位置
  • 写在OceanBase开源三周年
  • [项目][WebServer][日志设计]详细讲解
  • 【JVM 工具命令】JAVA程序线上问题诊断，JVM工具命令的使用，jstat， jstack，jmap命令的使用
  • 【机器学习】使用Numpy实现神经网络训练全流程
  • 关于若依flowable的安装
  • 76-mysql的聚集索引和非聚集索引区别
  • 为什么网站加载速度总是那么不尽如人意呢？（网站优化篇）
  • 2024.9.14（RC和RS）