简单工厂模式

时间：2018-11-19 22:10:08 阅读：161 评论：0 收藏：0 [点我收藏+]

1、代码规范

命名规范
错误检查（输入格式检查、合法性检查）
合理利用分支结构
注重：可维护性、可复用性、可扩展性、灵活性

2、面向对象三大特性：封装、继承、多态

3、合理利用设计模式，能够使程序更加灵活，容易修改、易于复用。

一、通过实例来体现面向对象与工厂设计模式

1、面向过程的方法实现一个简单计算器

 1 package firstSimpleFactory;
 2 public class Calculate  {
 3        public static void main(String[] args) {
 4               System.out.println(123456);
 5                double numA=3;
 6                double numB=8;
 7                double result=0;
 8                String oper="+";
 9                switch(oper){
10                case "+": result=numA+numB; break;
11                case "-": result=numA-numB; break;
12                case "*": result=numA*numB; break;
13                case "/": {
14                       if (numB!=0) {
15                             result=numA/numB;break;
16                      }else{
17                            System.out.println("分母不能为零！");
18                      }
19                       break;
20                }
21                default:System.out.println("未知操作");
22                }
23                System.out.println(numA+oper+numB+"="+result);
24  }
25 }

2、面向对象的思想，结合工厂设计模式实现简单计算器

 1 package firstSimpleFactory;
 2 
 3 // 父类，抽象类
 4 class Operate{
 5     private double numA;
 6     private double numB;
 7     public void setNumA(double numa){
 8         this.numA=numa;
 9     }
10     public double getNumA() {
11         return this.numA;
12     }
13     public void setNumB(double numb){
14         this.numB=numb;
15     }
16     public double getNumB() {
17         return this.numB;
18     }
19     public double getResult() {
20         double result=0;
21         return result;
22         
23     }
24 }
25 
26 // 一群加减乘除子类
27 class AddOper extends Operate{
28     @Override
29     public double getResult(){
30         double result=0;
31         result=super.getNumA()+super.getNumB();
32         return result;
33     }
34 }
35 
36 class SubOper extends Operate{
37     @Override
38     public double getResult(){
39         double result=0;
40         result=super.getNumA()-super.getNumB();
41         return result;
42     }
43 }
44 
45 class MulOper extends Operate{
46     @Override
47     public double getResult(){
48         double result=0;
49         result=super.getNumA()*super.getNumB();
50         return result;
51     }
52 }
53 class DivOper extends Operate{
54     @Override
55     public double getResult(){
56         double result=0;
57         if (super.getNumB()!=0) {
58              result=super.getNumA()/super.getNumB();
59         }else{
60             System.out.println("分母不能为零！");
61         }
62         return result;
63     }
64 }
65 
66 // 简单工厂
67 class OperationFactory{
68     public static Operate createOperate(String operate){
69         Operate oper=null;
70         switch (operate) {
71         case "+":oper=new AddOper();break;
72         case "-":oper=new SubOper();break;
73         case "*":oper=new MulOper();break;
74         case "/":oper=new DivOper();break;
75         default:
76             break;
77         }
78         return oper;
79     }
80 }
81 
82 // 主程序
83 public class Calculate  {
84     public static void main(String[] args) {
85         System.out.println("开始");
86         Operate operate=OperationFactory.createOperate("+");
87         operate.setNumA(3);
88         operate.setNumB(8);
89          System.out.println(operate.getResult());
90  }
91 }