设计模式之抽象工厂模式

最新推荐文章于 2025-11-26 16:40:37 发布

原创最新推荐文章于 2025-11-26 16:40:37 发布 · 190 阅读

0 ·

CC 4.0 BY-SA版权

本文为博主原创文章，未经博主允许不得转载。

文章标签：

#设计模式 #抽象工厂模式 #c#

创建型设计模式专栏收录该内容

4 篇文章

订阅专栏

本文介绍了抽象工厂模式的概念、应用场景及其实现方式，并通过C#代码示例详细展示了如何创建形状和颜色的不同产品族，最后总结了该模式的优点和缺点。

文章目录

一、概念

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂；
个人理解抽象工厂就是来管理工厂的；

二、场景

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
这个系统有多于一个的产品族，而系统只消费其中某一产品族。
同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。
系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

三、实现

新建正方形类，类名： Square 继承 IShape

   using System;
  
  namespace 抽象工厂
  {
      class Square:IShape
      {
        public  void GetShape()
        { 
           System.Console.WriteLine("这是正方形");
        }
      }
  }

新建矩形类，类名：Rectangle 继承 IShape

 using System;

  namespace 抽象工厂
  {
      class Rectangle:IShape
      {
        public  void GetShape()
         {
          System.Console.WriteLine("这是矩形");
         }
      }
  }

新建圆形类，类名：Round 继承 IShape

      using System;
      
      namespace 抽象工厂
      {
          class Round:IShape
          {
             public  void GetShape()
             {
              System.Console.WriteLine("这是圆形");
             }
          }
      }

新建形状接口类，类名：IShape

  using System;
  
  namespace 抽象工厂
  {
      interface IShape
      {
          void GetShape();
      }
  }

新建形状工厂类，类名：ShapeFactory 继承 FactoryAbstract

  using System;
  
  namespace 抽象工厂
  {
      class ShapeFactory:FactoryAbstract
      {
        public override  IShape GetShapeObject(string flage){
          switch (flage)
              {
                case "Rectangle":
                  return  new Rectangle();
                case "Round":
                  return new  Round();
                case "Square":
                  return new Square();
              } 
              return null;
        } 
      }
  }

新建红色类，类名：Red 继承 IColor

  using System;
  
  namespace 抽象工厂
  {
      class Red:IColor
      {
         public  void Fill()
         {
          System.Console.WriteLine("这是红色");
         }
      }
  }

新建蓝色类，类名：Blue 继承 IColor

  using System;
  
  namespace 抽象工厂
  {
      class Blue:IColor
      {
         public  void Fill()
         {
          System.Console.WriteLine("这是蓝色");
         }
      }
  }

新建颜色接口类，类名：IColor

      using System;
      
      namespace 抽象工厂
      {
          interface IColor
          {
              void Fill();
          }
      }

新建颜色工厂类，类名：ColorFactory 继承 FactoryAbstract

      using System;
      
      namespace 抽象工厂
      {
          class ColorFactory:FactoryAbstract
          {
            
           public override  IColor GetColorObject(string flage){
              switch (flage)
                  {
                    case "Red":
                        return  new Red();
                    case "Blue":
                      return new Blue(); 
                  } 
                  return null;
            }  
          }
      }

抽象工厂类，类名：FactoryAbstract

  using System;
  
  namespace 抽象工厂
  {
     abstract  class FactoryAbstract
      {
            public virtual   IColor GetColorObject(string flage){return null;}
            public virtual   IShape GetShapeObject(string flage){return null;}
      }
  }

启动类

  using System;
  
  namespace 抽象工厂
  {
      class Program
      {
          static void Main(string[] args)
          {
               FactoryAbstract fa = new ShapeFactory(); 
               fa.GetShapeObject("Square").GetShape();
  
               FactoryAbstract fa1 = new ShapeFactory(); 
               fa1.GetShapeObject("Round").GetShape();
  
               FactoryAbstract fa2 = new ShapeFactory(); 
               fa2.GetShapeObject("Rectangle").GetShape();
  
               FactoryAbstract fa3 = new ColorFactory(); 
               fa3.GetColorObject("Red").Fill();
  
               FactoryAbstract fa5 = new ColorFactory(); 
               fa5.GetColorObject("Blue").Fill();
          }
      }
  }

四、优缺点

优点
- 分离了具体的类。客户通过抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中。
- 易于交换产品系列。一个具体工厂类只在初始化时出现一次，这使得改变一个应用的具体工厂变得很容易，只需改变具体的工厂即可使用不同的产品配置。
- 有利于产品的一致性。当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要，而抽象工厂很容易实现这一点。
缺点
- 难以支持新种类的产品。因为抽象工厂接口确定了可以被创建的产品集合，所以难以扩展抽象工厂以生产新种类的产品。