当前位置:   article > 正文

设计模式-工厂模式

设计模式-工厂模式

概述

工厂模式是一种创建对象的设计模式主要的是将对象的创建和使用分离的一种方法,可以在不知道实现的情况下创建具体的对象,举个例子,比如一个工厂是做包装的,我不需要知道工厂内部是怎么实现的,我只需要传入产品,返回给我一个包装好的物品就行。工厂模式有三种变体,简单工厂模式,工厂方法模式,抽象工厂模式,如下。以下环境不是unity,是C#的控制台程序

需求:

有一个工厂做包装生意,现有苹果,香蕉,桃子,请将各个水果包装好运出来。


简单工厂模式

  1. internal class Program
  2. {
  3. private static void Main(string[] args)
  4. {
  5. IPack pack = FruitFactory.FactorPack("Peach");
  6. pack.PackFruit();
  7. }
  8. }
  9. public interface IPack//打包接口
  10. {
  11. void PackFruit();
  12. }
  13. public class Apple : IPack//苹果
  14. {
  15. public void PackFruit()
  16. {
  17. Console.WriteLine("Pack Appple!");
  18. }
  19. }
  20. public class Banana : IPack//香蕉
  21. {
  22. public void PackFruit()
  23. {
  24. Console.WriteLine("Pack Banana!");
  25. }
  26. }
  27. public class Peach : IPack//桃子
  28. {
  29. public void PackFruit()
  30. {
  31. Console.WriteLine("Pack Peach!");
  32. }
  33. }
  34. public class FruitFactory//水果工厂
  35. {
  36. public static IPack FactorPack(string type)
  37. {
  38. switch (type)
  39. {
  40. case "Appple":
  41. return new Apple();
  42. case "Banana":
  43. return new Banana();
  44. case "Peach":
  45. return new Peach();
  46. default:
  47. throw new Exception("无效类型");
  48. }
  49. }
  50. }

输出结果:Pack Peach!

简单工厂:简单来说就是通过继承接口,实现各种类型的扩展,然后通过一个统一的工厂方法管理起来,但是修改的话需要修改工厂方法(如上FactorPack),不满足开闭原则

扩展的话需要加入新的类,然后在工厂方法中添加具体的类型。具体的实现可以放在对应的方法类,当然也可以带入参数,具体业务逻辑的扩展,按实际的需求来


工厂方法模式

  1. internal class Program
  2. {
  3. private static void Main(string[] args)
  4. {
  5. CreatorFactor pack = new PeachFactory();
  6. IPack peach = pack.FactoryMethod();
  7. peach.PackFruit();
  8. }
  9. }
  10. public interface IPack//打包接口
  11. {
  12. void PackFruit();
  13. }
  14. public class Apple : IPack//苹果
  15. {
  16. public void PackFruit()
  17. {
  18. Console.WriteLine("Pack Appple!");
  19. }
  20. }
  21. public class Banana : IPack//香蕉
  22. {
  23. public void PackFruit()
  24. {
  25. Console.WriteLine("Pack Banana!");
  26. }
  27. }
  28. public class Peach : IPack//桃子
  29. {
  30. public void PackFruit()
  31. {
  32. Console.WriteLine("Pack Peach!");
  33. }
  34. }
  35. public abstract class CreatorFactor//工厂抽象类
  36. {
  37. public abstract IPack FactoryMethod();
  38. }
  39. public class AppleFactory : CreatorFactor//苹果工厂
  40. {
  41. public override IPack FactoryMethod()
  42. {
  43. return new Apple();
  44. }
  45. }
  46. public class BananaFactory : CreatorFactor//香蕉工厂
  47. {
  48. public override IPack FactoryMethod()
  49. {
  50. return new Banana();
  51. }
  52. }
  53. public class PeachFactory : CreatorFactor//桃子工厂
  54. {
  55. public override IPack FactoryMethod()
  56. {
  57. return new Peach();
  58. }
  59. }

输出结果:Pack Peach!

工厂方法模式:这个办法解决了上述的简单工厂的问题,不满足设计模式原则的开闭原则,工厂方法模式可以在不修改原来代码的情况下扩展新的工厂。简单来说,就是将工厂方法做成了一个抽象类,然后有新的工厂的时候继承自这个抽象类,实现对应的方法

扩展的话,只需要扩展新的类型,然后继承CreatorFactor再实现对应的方法,不用修改原来的方法,缺点就是增加了代码的复杂性,要管理很多的工厂。


抽象工厂模式

这里扩展一下复杂度,现在苹果,香蕉,桃子,现在有两种不同的包装,普通和精美

  1. internal class Program
  2. {
  3. private static void Main(string[] args)
  4. {
  5. IFactory factory = new PeachFactory();
  6. IOrdinaryPack ordinaryPack = factory.PackOridinary();
  7. IExquisitePack exquisitePack = factory.PackExquisite();
  8. ordinaryPack.PackOrdinaryFruit();
  9. exquisitePack.PackExquisiteFruit();
  10. }
  11. }
  12. public interface IOrdinaryPack//普通包装接口
  13. {
  14. void PackOrdinaryFruit();//包装普通水果
  15. }
  16. public class OrdinaryApple : IOrdinaryPack//普通包装苹果
  17. {
  18. public void PackOrdinaryFruit()
  19. {
  20. Console.WriteLine("Pack OrdinaryApple!");
  21. }
  22. }
  23. public class OrdinaryBanana : IOrdinaryPack//普通包装香蕉
  24. {
  25. public void PackOrdinaryFruit()
  26. {
  27. Console.WriteLine("Pack OrdinaryBanana!");
  28. }
  29. }
  30. public class OrdinaryPeach : IOrdinaryPack//普通包装桃子
  31. {
  32. public void PackOrdinaryFruit()
  33. {
  34. Console.WriteLine("Pack OrdinaryPeach!");
  35. }
  36. }
  37. //----------------------------------------------------------------------------
  38. public interface IExquisitePack//精美包装接口
  39. {
  40. void PackExquisiteFruit();//包装精美水果
  41. }
  42. public class ExquisiteApple : IExquisitePack//精美包装苹果
  43. {
  44. public void PackExquisiteFruit()
  45. {
  46. Console.WriteLine("Pack ExquisiteApple!");
  47. }
  48. }
  49. public class ExquisiteBanana : IExquisitePack//精美包装香蕉
  50. {
  51. public void PackExquisiteFruit()
  52. {
  53. Console.WriteLine("Pack ExquisiteBanana!");
  54. }
  55. }
  56. public class ExquisitePeach : IExquisitePack//精美包装桃子
  57. {
  58. public void PackExquisiteFruit()
  59. {
  60. Console.WriteLine("Pack ExquisitePeach!");
  61. }
  62. }
  63. //----------------------------------------------------------------------------
  64. public interface IFactory//工厂接口
  65. {
  66. IOrdinaryPack PackOridinary();
  67. IExquisitePack PackExquisite();
  68. }
  69. public class AppleFactory : IFactory//苹果工厂
  70. {
  71. public IExquisitePack PackExquisite()
  72. {
  73. return new ExquisiteApple();
  74. }
  75. public IOrdinaryPack PackOridinary()
  76. {
  77. return new OrdinaryApple();
  78. }
  79. }
  80. public class BananaFactory : IFactory//香蕉工厂
  81. {
  82. public IExquisitePack PackExquisite()
  83. {
  84. return new ExquisiteBanana();
  85. }
  86. public IOrdinaryPack PackOridinary()
  87. {
  88. return new OrdinaryBanana();
  89. }
  90. }
  91. public class PeachFactory : IFactory//桃子工厂
  92. {
  93. public IExquisitePack PackExquisite()
  94. {
  95. return new ExquisitePeach();
  96. }
  97. public IOrdinaryPack PackOridinary()
  98. {
  99. return new OrdinaryPeach();
  100. }
  101. }

输出结果:

Pack OrdinaryPeach!
Pack ExquisitePeach!

抽象工厂模式:抽象工厂模式是工厂方法模式的一种扩展,仔细看两者相识度是很高的,各有各适用的场景,实际适用按照需求来

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小舞很执着/article/detail/967114
推荐阅读
  

闽ICP备14008679号