设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java设计模式编程中简单工厂与抽象工厂模式的使用实例

2016-7-29 15:37| 发布者: zhangjf| 查看: 656| 评论: 0

摘要: 简单工厂模式 类图 通过一个工厂类，以一个条件来创建对应的对象 //业务功能 public interface ICalculation { double getResult(double numA, double numB); } public class CalcAdd implements ICalculation ...

简单工厂模式
类图

201642195447625.jpg (966×712)

通过一个工厂类，以一个条件来创建对应的对象

  2. //业务功能
  3. public interface ICalculation {
  4. double getResult(double numA, double numB);
  5. }
  7. public class CalcAdd implements ICalculation {
  9. @Override
  10. public double getResult(double numA, double numB) {
  11. System.out.println("加法");
  12. return numA + numB;
  13. }
  15. }
  17. public class CalcSubtract implements ICalculation {
  19. @Override
  20. public double getResult(double numA, double numB) {
  21. System.out.println("减法");
  22. return numA - numB;
  23. }
  25. }
  27. /*
  28. * 简单工厂模式 关注：对象的创建
  29. * 建立一个工厂类，对实现了同一接口的或者是存在继承关系的一些类进行实例的创建
  30. */
  31. public class Test4Simple {
  32. public static void main(String[] args) {
  33. // String operation = "/";
  34. String operation = "+";
  35. // String operation = "-";
  36. // String operation = "*";
  37. double numA = 182, numB = 33;
  38. ICalculation createCalc = CalcSimpleFactory.createCalc(operation);
  39. double result = createCalc.getResult(numA, numB);
  40. System.out.println(result);
  41. }
  42. }
复制代码

简单工厂的缺陷： 简单工厂创建产品时需要传递相应的参数，如果传递不正确就取不到对象了。
改进：多方法创建不同产品
类图

201642195519770.jpg (926×736)

  2. public class CalcMultipleFactory {
  4. public static ICalculation produceAdd() {
  5. return new CalcAdd();
  6. }
  8. public static ICalculation produceSubtract() {
  9. return new CalcSubtract();
  10. }
  12. public static ICalculation produceMultiply() {
  13. return new CalcMultiply();
  14. }
  16. public static ICalculation produceDivide() {
  17. return new CalcDivide();
  18. }
  19. }
  21. public class Test4Multiple {
  23. public static void main(String[] args) {
  24. double numA = 182, numB = 33;
  26. ICalculation createCalc = CalcMultipleFactory.produceAdd();
  27. double result = createCalc.getResult(numA, numB);
  28. System.out.println(result);
  30. createCalc = CalcMultipleFactory.produceSubtract();
  31. result = createCalc.getResult(numA, numB);
  32. System.out.println(result);
  34. createCalc = CalcMultipleFactory.produceMultiply();
  35. result = createCalc.getResult(numA, numB);
  36. System.out.println(result);
  38. createCalc = CalcMultipleFactory.produceDivide();
  39. result = createCalc.getResult(numA, numB);
  40. System.out.println(result);
  41. }
  42. }
复制代码

抽象工厂模式
里面有几个概念：抽象工厂、实体工厂、抽象产品、实体产品
抽象工厂：定义创建产品的抽象方法
实体工厂：具体的创建哪种产品
抽象产品：一个接口或基类
实体产品：实现具体功能，或派生
类图

201642195549773.jpg (1396×882)

  2. //抽象产品1
  3. public interface IProduct1 {
  4. public void show();
  5. }
  7. //抽象产品2
  8. public interface IProduct2 {
  9. public void show();
  10. }
  12. //实体产品1
  13. public class Product1 implements IProduct1 {
  14. public void show() {
  15. System.out.println("创建了1型产品");
  16. }
  17. }
  19. //实体产品2
  20. public class Product2 implements IProduct2 {
  21. public void show() {
  22. System.out.println("创建了2型产品");
  23. }
  24. }
  26. /*
  27. * 1A 1B属于Product1 同一产品等级结构中
  28. * 2A 2B属于Product2
  29. */
  30. public class GradeProduct1A extends Product1 {
  32. @Override
  33. public void show() {
  34. super.show();
  35. System.out.println("这是产品1下的:产品A");
  36. }
  38. }
  40. public class GradeProduct1B extends Product1 {
  42. @Override
  43. public void show() {
  44. super.show();
  45. System.out.println("这是产品1下的:产品B");
  46. }
  47. }
  49. public class GradeProduct2A extends Product2 {
  51. @Override
  52. public void show() {
  53. super.show();
  54. System.out.println("这是产品2下的:产品A");
  55. }
  56. }
  58. public class GradeProduct2B extends Product2 {
  60. @Override
  61. public void show() {
  62. super.show();
  63. System.out.println("这是产品2下的:产品B");
  64. }
  65. }
  67. //抽象工厂 创建不同的抽象产品
  68. public interface IFactory {
  69. public IProduct1 createProduct1A();//1类产品 型号A
  70. public IProduct1 createProduct1B();//1类产品 型号B
  71. public IProduct2 createProduct2A();//2类产品 型号A
  72. public IProduct2 createProduct2B();//2类产品 型号B
  73. }
  75. //实体工厂 创建实体产品，返回类型为抽象产品
  76. public class Factory implements IFactory {
  78. public IProduct1 createProduct1A() {
  79. return new GradeProduct1A();
  80. }
  82. public IProduct1 createProduct1B() {
  83. return new GradeProduct1B();
  84. }
  86. public IProduct2 createProduct2A() {
  87. return new GradeProduct2A();
  88. }
  90. public IProduct2 createProduct2B() {
  91. return new GradeProduct2B();
  92. }
  93. }
  95. /*
  96. * 抽象工厂模式：用来创建一组相关或者相互依赖的对象
  97. *
  98. * 流程：抽象工厂，实体工厂 生产产品
  99. * 抽象产品，实体产品 实现产品功能
  100. * 缺点：当需要增加一个产品(由抽象和实体构成)，工厂都需要更改
  101. */
  102. public class Test4Abstract {
  103. public static void main(String[] args) {
  104. IFactory factory = new Factory();
  105. IProduct1 product1a = factory.createProduct1A();
  106. product1a.show();
  107. IProduct1 product1b = factory.createProduct1B();
  108. product1b.show();
  110. IProduct2 product2a = factory.createProduct2A();
  111. product2a.show();
  112. IProduct2 product2b = factory.createProduct2B();
  113. product2b.show();
  114. }
  115. }
复制代码

收藏 邀请
上一篇：Java中的接口知识汇总下一篇：文件路径正确，报java.io.FileNotFoundException异常的原因及解决办法

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-5-6 09:19

Copyright 2015-2025 djqfx

返回顶部