工厂模式,简单工厂模式,抽象工厂模式三者有什么区别

工厂模式、简单工厂模式和抽象工厂模式都属于创建型设计模式，它们的核心目的都是将对象的创建和使用分离，以提高代码的可维护性和可扩展性，但在实现方式和应用场景上存在一些区别，下面为你详细介绍：

简单工厂模式

 

• 定义与结构：简单工厂模式是工厂模式的基础版本，它定义了一个工厂类，该工厂类负责根据不同的条件创建不同类型的对象。简单来说，它将对象的创建逻辑封装在一个工厂类的一个方法中。
• 示例代码：
  
  

  // 定义产品接口
  public interface IProduct
  {
      void Show();
  }
  
  // 具体产品类 A
  public class ConcreteProductA : IProduct
  {
      public void Show()
      {
          Console.WriteLine("这是产品 A");
      }
  }
  
  // 具体产品类 B
  public class ConcreteProductB : IProduct
  {
      public void Show()
      {
          Console.WriteLine("这是产品 B");
      }
  }
  
  // 简单工厂类
  public class SimpleFactory
  {
      public static IProduct CreateProduct(string type)
      {
          switch (type)
          {
              case "A":
                  return new ConcreteProductA();
              case "B":
                  return new ConcreteProductB();
              default:
                  return null;
          }
      }
  }
  
  // 客户端代码
  class Program
  {
      static void Main()
      {
          IProduct productA = SimpleFactory.CreateProduct("A");
          productA.Show();
  
          IProduct productB = SimpleFactory.CreateProduct("B");
          productB.Show();
      }
  }

   

  • 特点与不足：简单工厂模式的优点是实现简单，将对象的创建和使用分离。但缺点也很明显，工厂类的职责过重，如果需要添加新的产品，就需要修改工厂类的 CreateProduct 方法，这违背了开闭原则（对扩展开放，对修改关闭）。

  工厂模式

  
  
  • 定义与结构：工厂模式也叫工厂方法模式，它定义了一个创建对象的抽象方法，让子类决定实例化哪个具体的产品类。工厂模式将对象的创建延迟到子类中进行，每个具体的工厂子类负责创建一种具体的产品。
  • 示例代码：
    

    // 定义产品接口
    public interface IProduct
    {
        void Show();
    }
    
    // 具体产品类 A
    public class ConcreteProductA : IProduct
    {
        public void Show()
        {
            Console.WriteLine("这是产品 A");
        }
    }
    
    // 具体产品类 B
    public class ConcreteProductB : IProduct
    {
        public void Show()
        {
            Console.WriteLine("这是产品 B");
        }
    }
    
    // 抽象工厂类
    public abstract class Factory
    {
        public abstract IProduct CreateProduct();
    }
    
    // 具体工厂类 A，负责创建产品 A
    public class ConcreteFactoryA : Factory
    {
        public override IProduct CreateProduct()
        {
            return new ConcreteProductA();
        }
    }
    
    // 具体工厂类 B，负责创建产品 B
    public class ConcreteFactoryB : Factory
    {
        public override IProduct CreateProduct()
        {
            return new ConcreteProductB();
        }
    }
    
    // 客户端代码
    class Program
    {
        static void Main()
        {
            Factory factoryA = new ConcreteFactoryA();
            IProduct productA = factoryA.CreateProduct();
            productA.Show();
    
            Factory factoryB = new ConcreteFactoryB();
            IProduct productB = factoryB.CreateProduct();
            productB.Show();
        }
    }

    • 特点与优势：工厂模式遵循了开闭原则，当需要添加新的产品时，只需要创建一个新的具体产品类和对应的具体工厂类，而不需要修改现有的代码。但缺点是随着产品种类的增加，会导致类的数量过多，增加系统的复杂度。

    抽象工厂模式

     

    • 定义与结构：抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它将一组相关的产品族的创建逻辑封装在一个抽象工厂接口中，每个具体的工厂类负责创建一个产品族的所有产品。
    • 示例代码：
    
    

    // 定义产品 A 接口
    public interface IProductA
    {
        void ShowA();
    }
    
    // 具体产品 A1
    public class ConcreteProductA1 : IProductA
    {
        public void ShowA()
        {
            Console.WriteLine("这是产品 A1");
        }
    }
    
    // 具体产品 A2
    public class ConcreteProductA2 : IProductA
    {
        public void ShowA()
        {
            Console.WriteLine("这是产品 A2");
        }
    }
    
    // 定义产品 B 接口
    public interface IProductB
    {
        void ShowB();
    }
    
    // 具体产品 B1
    public class ConcreteProductB1 : IProductB
    {
        public void ShowB()
        {
            Console.WriteLine("这是产品 B1");
        }
    }
    
    // 具体产品 B2
    public class ConcreteProductB2 : IProductB
    {
        public void ShowB()
        {
            Console.WriteLine("这是产品 B2");
        }
    }
    
    // 抽象工厂接口
    public interface IAbstractFactory
    {
        IProductA CreateProductA();
        IProductB CreateProductB();
    }
    
    // 具体工厂类 1，负责创建产品族 1
    public class ConcreteFactory1 : IAbstractFactory
    {
        public IProductA CreateProductA()
        {
            return new ConcreteProductA1();
        }
    
        public IProductB CreateProductB()
        {
            return new ConcreteProductB1();
        }
    }
    
    // 具体工厂类 2，负责创建产品族 2
    public class ConcreteFactory2 : IAbstractFactory
    {
        public IProductA CreateProductA()
        {
            return new ConcreteProductA2();
        }
    
        public IProductB CreateProductB()
        {
            return new ConcreteProductB2();
        }
    }
    
    // 客户端代码
    class Program
    {
        static void Main()
        {
            IAbstractFactory factory1 = new ConcreteFactory1();
            IProductA productA1 = factory1.CreateProductA();
            IProductB productB1 = factory1.CreateProductB();
            productA1.ShowA();
            productB1.ShowB();
    
            IAbstractFactory factory2 = new ConcreteFactory2();
            IProductA productA2 = factory2.CreateProductA();
            IProductB productB2 = factory2.CreateProductB();
            productA2.ShowA();
            productB2.ShowB();
        }
    }

    • 特点与适用场景：抽象工厂模式适用于创建一组相关的产品族的场景，它可以保证创建的产品之间的兼容性。但它的缺点是实现复杂，当需要添加新的产品族时，需要修改抽象工厂接口和所有的具体工厂类，违背了开闭原则；而当需要添加新的产品等级结构（如增加一个新的产品类型）时，只需要添加新的产品接口和具体产品类以及对应的具体工厂类，符合开闭原则。

    三者区别总结

     

    • 创建对象的粒度：简单工厂模式创建对象的粒度最粗，将所有对象的创建逻辑集中在一个工厂类的一个方法中；工厂模式创建对象的粒度适中，每个具体工厂类负责创建一种具体的产品；抽象工厂模式创建对象的粒度最细，每个具体工厂类负责创建一组相关的产品族。
    • 扩展性：简单工厂模式扩展性较差，添加新的产品需要修改工厂类；工厂模式扩展性较好，添加新的产品只需要添加新的具体产品类和对应的具体工厂类；抽象工厂模式在添加新的产品族时扩展性较差，需要修改抽象工厂接口和所有的具体工厂类，但在添加新的产品等级结构时扩展性较好。
    • 应用场景：简单工厂模式适用于产品种类较少且变化不频繁的场景；工厂模式适用于产品种类较多且需要灵活扩展的场景；抽象工厂模式适用于创建一组相关的产品族，并且要求这些产品之间具有一定的兼容性的场景。