经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
创建型模式之工厂模式（2.2）
来源：cnblogs　　作者：noneplus　　时间：2019/8/12 9:14:27　　对本文有异议

什么是工厂模式？

工厂模式是创建型模式的一种，工厂是用来生产的，而在Java里，是用来生产对象实例的。


和单例模式相似，工厂模式同样聚焦于在考虑整个软件构建的情况下合理创建对象，从而保证软件的扩展性和稳定性。

工厂模式分为三种：

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

简单工厂模式（实现服务端自扩展）

服务端：提供代码的人（作者）

客户端：使用代码的人（用户）

【对于程序员来说，自己是作者，用户是普通人；那么对于发明语言,框架的人来说，创建者是作者，而普通程序员是用户】

假设没有使用简单工厂模式：

定义一个Coder接口，然后定义JavaCoder和PythonCoder实现Coder接口。客户端通过new来创建对象。（耦合）

  1. //服务端
  2. interface Coder {
  4.     void express();
  5. }
  7. class JavaCoder implements Coder
  8. {
  9.     @Override
  10.     public void express()
  11.     {
  12.         System.out.println("I am a Java Coder");
  14.     }
  15. }
  17. class PythonCoder implements Coder
  18. {
  20.     @Override
  21.     public void express()
  22.     {
  23.         System.out.println("I am a Python Coder");
  25.     }
  26. }
  28. //===============================================================================
  29. public class ProductManager     //客户端
  30. {
  31.     public static void main(String[] args) {
  33.         Coder javaCoder = new JavaCoder();
  34.         javaCoder.express();
  36.         
  37.     }
  41. }

当服务端需要扩展一个类时：需要进行1,2两步

  1. //服务端
  2. interface Coder {
  4.     void express();
  5. }
  7. class JavaCoder implements Coder
  8. {
  9.     @Override
  10.     public void express()
  11.     {
  12.         System.out.println("I am a Java Coder");
  14.     }
  15. }
  17. class PythonCoder implements Coder
  18. {
  20.     @Override
  21.     public void express()
  22.     {
  23.         System.out.println("I am a Python Coder");
  25.     }
  26. }
  29. class GoCoder implements Coder    //1.服务端扩展
  30. {
  32.     @Override
  33.     public void express()
  34.     {
  35.         System.out.println("I am a Go Coder");
  37.     }
  38. }
  39. //===============================================================================
  40. public class ProductManager     //客户端
  41. {
  42.     public static void main(String[] args) {
  44.         Coder javaCoder = new JavaCoder();
  45.         javaCoder.express();
  47.         Coder goCoder = new GoCoder();   //2.客户端跟着修改
  48.         goCoder.express();
  49.     }
  53. }

服务端和客户端处于高度耦合状态。（服务端的变化会引起客户端的变化）

使用简单工厂模式：（如果服务端要扩展一个GoCoder，客户端无需做修改）

  1. //服务端
  2. interface Coder {
  4.     void express();
  5. }
  7. class JavaCoder implements Coder
  8. {
  9.     @Override
  10.     public void express()
  11.     {
  12.         System.out.println("I am a Java Coder");
  14.     }
  15. }
  17. class PythonCoder implements Coder
  18. {
  20.     @Override
  21.     public void express()
  22.     {
  23.         System.out.println("I am a Python Coder");
  25.     }
  26. }
  29. class GoCoder implements Coder    //1.服务端扩展
  30. {
  32.     @Override
  33.     public void express()
  34.     {
  35.         System.out.println("I am a Go Coder");
  37.     }
  38. }
  40. class SimpleFactory
  41. {
  43.     //使用静态内部类实现单例模式
  44.     private static class StaticClassInnerInstance {
  45.         private static final SimpleFactory INSTANCE = new SimpleFactory();
  46.     }
  47.     
  49.     public static SimpleFactory getInstance() {
  50.         return StaticClassInnerInstance.INSTANCE;
  51.     }
  53.     public Coder createCoder(String language)
  54.     {
  55.         Coder coder = null;
  56.         if(language.equals("Java"))
  57.         {
  58.             coder= new JavaCoder();
  60.         }
  61.         else if(language.equals("Python"))
  62.         {
  63.             coder= new PythonCoder();
  64.         }
  65.         else if(language.equals("Go"))  //2.扩展条件
  66.         {
  67.             coder= new GoCoder();
  68.         }
  69.         return coder;
  70.     }
  71. }
  72. //===============================================================================
  73. public class ProductManager     //客户端
  74. {
  76.     public static void main(String[] args) {
  78.         SimpleFactory factory = SimpleFactory.getInstance();
  79.         Coder javaCoder = factory.createCoder("Java");
  80.         javaCoder.express();
  83.     }
  87. }

简单工厂UML类图：

1565531609458

简单工厂的优缺点:

优点：

解决了服务端与客户端的耦合问题，实现了服务端的自扩展。

缺点：

当客户端需要进行功能扩展时，无法在SimpleFactory中添加对应修改代码。

简单工厂可以完成服务端的自扩展，但客户端只能调用，无法扩展。

工厂方法模式（实现客户端自扩展）

  1. //服务端
  2. interface Coder {
  4.     void express();
  5. }
  7. class JavaCoder implements Coder
  8. {
  9.     @Override
  10.     public void express()
  11.     {
  12.         System.out.println("I am a Java Coder");
  14.     }
  15. }
  17. class PythonCoder implements Coder
  18. {
  20.     @Override
  21.     public void express()
  22.     {
  23.         System.out.println("I am a Python Coder");
  25.     }
  26. }
  29. class GoCoder implements Coder    //1.服务端扩展
  30. {
  32.     @Override
  33.     public void express()
  34.     {
  35.         System.out.println("I am a Go Coder");
  37.     }
  38. }
  40. interface CoderFactory   //抽象出CoderFactory
  41. {
  42.     public Coder createCoder(String language);
  43. }
  45. class ServerFactory implements CoderFactory
  46. {
  48.     private static class StaticClassInnerInstance {
  49.         private static final ServerFactory INSTANCE = new ServerFactory();
  50.     }
  52.     public static ServerFactory getInstance() {
  53.         return StaticClassInnerInstance.INSTANCE;
  54.     }
  56.     @Override
  57.     public Coder createCoder(String language)
  58.     {
  59.         Coder coder = null;
  60.         if(language.equals("Java"))
  61.         {
  62.             coder= new JavaCoder();
  64.         }
  65.         else if(language.equals("Python"))
  66.         {
  67.             coder= new PythonCoder();
  68.         }
  69.         else if(language.equals("Go"))  //2.扩展条件
  70.         {
  71.             coder= new GoCoder();
  72.         }
  73.         return coder;
  74.     }
  75. }
  76. //===============================================================================
  78. class RustCoder implements Coder
  79. {
  80.     @Override
  81.     public void express()
  82.     {
  83.         System.out.println("I am a Rust Coder");
  85.     }
  86. }
  88. class ClientFactory implements CoderFactory
  89. {
  90.     private static class StaticClassInnerInstance1 {
  91.         private static final ClientFactory INSTANCE = new ClientFactory();
  92.     }
  94.     public static ClientFactory getInstance() {
  95.         return ClientFactory.StaticClassInnerInstance1.INSTANCE;
  96.     }
  98.     @Override
  99.     public Coder createCoder(String language)
  100.     {
  102.         return new RustCoder();
  103.     }
  104. }
  106. public class ProductManager     //客户端
  107. {
  109.     public static void main(String[] args) {
  111.        ClientFactory clientFactory = ClientFactory.getInstance();
  112.        Coder coder = clientFactory.createCoder("Rust");
  113.        coder.express();
  114.     }
  115. }

工厂方法UML类图：

1565532368140

工厂方法模式的优缺点：

优点：实现了客户端的自扩展。

缺点：无法扩展多个产品。

抽象工厂模式（实现产品簇）

适应多个产品，加入设计师。

抽象工厂中可以生产多个产品，产品之间存在内在联系。比如说JavaCoder对应JavaDesigner。

而实例化的工厂就是根据这种内在联系来划分的。

同一个工厂的产品属于一个产品簇，不同产品簇之间是不能互相组合的。比如说GoDesigner和PythonCoder是不能组合到一个工厂里的。

  1. //服务端
  2. interface Coder {
  4.     void express();
  5. }
  6. interface Designer {
  8.     void express();
  9. }
  12. class JavaCoder implements Coder
  13. {
  14.     @Override
  15.     public void express()
  16.     {
  17.         System.out.println("I am a Java Coder");
  19.     }
  20. }
  22. class PythonCoder implements Coder
  23. {
  25.     @Override
  26.     public void express()
  27.     {
  28.         System.out.println("I am a Python Coder");
  30.     }
  31. }
  34. class GoCoder implements Coder
  35. {
  37.     @Override
  38.     public void express()
  39.     {
  40.         System.out.println("I am a Go Coder");
  42.     }
  43. }
  45. class JavaDesigner implements Designer
  46. {
  47.     @Override
  48.     public void express()
  49.     {
  50.         System.out.println("I am a Java Designer!");
  52.     }
  53. }
  54. class PythonDesigner implements Designer
  55. {
  56.     @Override
  57.     public void express()
  58.     {
  59.         System.out.println("I am a Python Designer!");
  61.     }
  62. }
  63. class GoDesigner implements Designer
  64. {
  65.     @Override
  66.     public void express()
  67.     {
  68.         System.out.println("I am a Go Designer!");
  70.     }
  71. }
  73. interface ProductFactory
  74. {
  75.     public Coder createCoder();
  76.     public Designer createDesigner();
  78. }
  80. class GoFactory implements ProductFactory
  81. {
  83.     private static class StaticClassInnerInstance {
  84.         private static final GoFactory INSTANCE = new GoFactory();
  85.     }
  87.     public static GoFactory getInstance() {
  88.         return StaticClassInnerInstance.INSTANCE;
  89.     }
  91.     @Override
  92.     public Coder createCoder()
  93.     {
  95.             Coder coder= new GoCoder();
  97.         return coder;
  98.     }
  99.     @Override
  100.     public Designer createDesigner()
  101.     {
  102.         Designer designer= new GoDesigner();
  104.         return designer;
  105.     }
  107. }
  109. class JavaFactory implements ProductFactory
  110. {
  112.     private static class StaticClassInnerInstance {
  113.         private static final JavaFactory INSTANCE = new JavaFactory();
  114.     }
  116.     public static JavaFactory getInstance() {
  117.         return StaticClassInnerInstance.INSTANCE;
  118.     }
  120.     @Override
  121.     public Coder createCoder()
  122.     {
  124.         Coder coder= new JavaCoder();
  126.         return coder;
  127.     }
  128.     @Override
  129.     public Designer createDesigner()
  130.     {
  131.         Designer designer= new JavaDesigner();
  133.         return designer;
  134.     }
  136. }
  137. //===============================================================================
  141. public class ProductManager     //客户端
  142. {
  144.     public static void main(String[] args) {
  145.         JavaFactory javaFactory = JavaFactory.getInstance();
  146.         Coder coder =javaFactory.createCoder();
  147.         Designer designer = javaFactory.createDesigner();
  148.         coder.express();
  149.         designer.express();
  154.     }
  158. }

抽象工厂UML类图：

1565533010264

工厂模式总结

简单工厂模式：适用客户端无需扩展的应用场景

工厂方法模式：适合客户端创建单个产品的应用场景

抽象工厂模式：适合创建多个产品的应用场景（但产品类别需要固定）

-------------------------------------------------------------------------------------------------------------2019.8.11

原文链接：http://www.cnblogs.com/noneplus/p/11337158.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) ·装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号