设计模式-----工厂模式

最新推荐文章于 2023-10-30 11:28:50 发布

sophiemantela

最新推荐文章于 2023-10-30 11:28:50 发布

阅读量219

点赞数

分类专栏：设计模式（c#）系列

本文链接：https://blog.csdn.net/sophiemantela/article/details/106080859

版权

设计模式（c#）系列专栏收录该内容

19 篇文章 1 订阅

订阅专栏

简单工厂模式

工厂方法模式

抽象工厂模式

简单工厂模式

适用场景：在工厂类负责创建的对象较少时，使用将对象的创建与对象的使用过程分离。
实现：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

优点：在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责。

缺点：在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
在这里插入图片描述

代码示例

/*
 * 简单工厂方法：定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Pattern02
{
    class Program
    {

        static void Main(string[] args)
        {

            Shape shape= Factory.GetShape("Circle");

            Console.WriteLine(shape.GetType().ToString());

            Console.ReadLine();
        }

    }
    enum shapeE
    {
        Circle,
        Retangle,
        Triangle
    }
       
    /// <summary>
    /// 抽象产品类
    /// </summary>
    abstract class Shape
    {
    }
    class Circle : Shape
    {
    }
    class Retangle : Shape
    { }
    class Triangle : Shape
    { }

    class Factory
    {
        public static Shape GetShape(string arg)
        {
            
            switch (Enum.Parse(typeof(shapeE), arg))
            {
                case shapeE.Circle:
                    return new Circle();

                case shapeE.Retangle:
                    return new Retangle();

                case shapeE.Triangle:
                    return new Triangle();
               
            }
            return null;
        }
    }


}

2. 工厂方法（factory method pattern）

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。完全符合“开闭原则”

缺点：在新增产品时，需要编写新的具体产品类。而且还要提供与之对应的具体工厂类。系统中类的个数会增多

总结：在产品结构简单，可退化，使用简单工厂模式。
在这里插入图片描述

代码示例

/*
 * 工厂方法：将类的初始化推迟到子类，由子类决定创建哪一个对象
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace Pattern01
{
    class Program
    {
        static void Main(string[] args)
        {

            Creator[] creators = new Creator[2];

            creators[0] = new CreatA();
            creators[1] = new createB();
           
            foreach (Creator creator in creators)
            {
                Product product = creator.GetProduct();
                
                 
                
                Console.WriteLine("Created {0}",
                  product.GetType().Name);
            }


            ///使用工厂子类创建产品B
            Creator factory = new createB();
            Product p = factory.GetProduct();
            p.Use();

            ///使用工厂类创建产品A；
            Creator factoryA = new CreatA();
            Product proA = factoryA.GetProduct();
            proA.Use();


            Console.ReadKey();

        }


    }
    /// <summary>
    /// 抽象产品，定义产品的接口，是工厂方法模式所创建对象的超类型
    /// </summary>
    abstract class Product
    {
      public abstract  void Use();
    }
    class concreteProductA : Product
    {
        public override void Use()
        {
            Console.WriteLine("this is a concreteProductA onject,it is running");
        }
    }
    class concreteProductB : Product
    {
        public override void Use()
        {
            Console.WriteLine("this is a concreteProductB object ,it is running ");
        }
    }

    /// <summary>
    /// 抽象工厂，负责定义创建产品对象的公共接口，由工厂子类则负责生成具体的产品对象
    /// 目的是将产品类的实例化操作延迟到工厂子类中完成。也就是有工厂子类决定实例化哪个产品
    /// </summary>
    abstract class Creator 
    {
        public abstract Product GetProduct();
    }
    class CreatA : Creator
    {
        public override Product GetProduct()
        {
            return new concreteProductA();
        }
    }
    class createB : Creator
    {

        public override Product GetProduct()
        {
            return new concreteProductB();
        }
    }

}

3. 抽象工厂

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式与工厂方法模式最大的区别在于：：工厂方法模式针对的是一个产品等级结构；

而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，可采用抽象工厂模式

抽象工厂模式包含四个角色：抽象工厂用于声明生成抽象产品的方法；具体工厂实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；具体产品定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。
在这里插入图片描述

代码示例


using System;
using System.Threading;

namespace Pattern03
{

    class Program
    {

        static void Main(string[] args)
        {
            

            ///创建海尔的产品系列
            AbFactory haierfac = new HaierFactory();
            ClientR clientr = new ClientR(haierfac);
            clientr.Run();

            Console.WriteLine("-----------------");

            //创建美的的产品系列
            AbFactory meidafa = new MeidaFactory();
            ClientR client3 = new ClientR(meidafa);
            client3.Run();


            Console.ReadKey();

        }

    }

    public class ClientR
    {
        public TV _tv;
        public Fridge _firdge;
        public ClientR(AbFactory factory)
        {
            _tv = factory.CreateTV();
            _firdge = factory.CreateFridge();
        }
        public void Run()
        {
            _tv.Named();
            Console.WriteLine(_firdge.GetType().ToString());
           
        }

    }
  
    public abstract class TV
    {
        public abstract void Named();
    }
    public abstract class Fridge { }

    public class HaierFridge : Fridge
    {
       
    }
    public class HaierTV : TV
    {
        public override void Named()
        {
            Console.WriteLine("this is a TV of Haier");
        }
    }


    public class MeidaFridge : Fridge { }
    public class MeidaTV : TV
    {
        public override void Named()
        {
            Console.WriteLine("this is a TV of Media");
        }
    }

  
    public abstract class AbFactory
    {
        public abstract TV CreateTV();
        public abstract Fridge CreateFridge();
    }
    public class HaierFactory : AbFactory
    {
        public override TV CreateTV()
        {
            return new HaierTV();
        }
        public override Fridge CreateFridge()
        {
            return new HaierFridge();
        }

    }
    /// <summary>
    /// 产品族
    /// </summary>
    public class MeidaFactory : AbFactory
    {
        public override TV CreateTV()
        {
            return new MeidaTV();
        }
        public override Fridge CreateFridge()
        {
            return new MeidaFridge();
        }
    }
   


}