简单工程模式

1.注意代码规范

2.面向对象编程:可维护,可复用,可扩展,灵活性好

                              通过封装,继承,多态把程序的耦合度降低

3.紧耦合  松耦合

下面就给一个简单工厂模式的例子:

是一个加减乘除的运算的例子:

(1)Operation.java类

 

  1. public  class Operation {  
  2.     private double _numberA=0;  
  3.     private double _numberB=0;  
  4.     public double get_numberA() {  
  5.         return _numberA;  
  6.     }  
  7.     public void set_numberA(double _numberA) {  
  8.         this._numberA = _numberA;  
  9.     }  
  10.     public double get_numberB() {  
  11.         return _numberB;  
  12.     }  
  13.     public void set_numberB(double _numberB) {  
  14.         this._numberB = _numberB;  
  15.     }  
  16.  
  17.     public  double getResult(){  
  18.         double result=0;  
  19.         return result;  
  20.     }  
()

(2)AddOperation.java

 

  1. //加法  
  2. public class AddOperation extends Operation{  
  3.     public double getResult() {  
  4.         double result=0;  
  5.         resultget_numberA()+get_numberB();  
  6.         return result;  
  7.     }  
  8. }  
  9. //减法  
  10. class SubOperation extends Operation{  
  11.     public double getResult() {  
  12.         double result=0;  
  13.         resultget_numberA()-get_numberB();  
  14.         return result;  
  15.     }  
  16. }  
  17. //乘法  
  18. class MulOperation extends Operation{  
  19.     public double getResult() {  
  20.         double result=0;  
  21.         resultget_numberA()*get_numberB();  
  22.         return result;  
  23.     }  
  24. }  
  25. //除法  
  26. class DivOperation extends Operation{  
  27.     public double getResult() {  
  28.         double result=0;  
  29.         if (get_numberB()==0) {  
  30.             try {  
  31.                 throw new Exception("除数不能为零");  
  32.             } catch (Exception e) {  
  33.                 e.printStackTrace();  
  34.             }  
  35.         }  
  36.         resultget_numberA()/get_numberB();  
  37.         return result;  
  38.     }  
  39.       
  40. }  
  41.       
  42.  
  43.  
  44.  

(3)操作工厂类:OPerationFactory.java

 

  1.  
  2. public class OPerationFactory {  
  3.       
  4.     public static Operation createOperation(String operate) {  
  5.         Operation oper=null;  
  6.         switch (operate) {  
  7.         case "+":  
  8.             oper=new AddOperation();  
  9.             break;  
  10.  
  11.         case "-":  
  12.             oper=new SubOperation();  
  13.             break;  
  14.         case "*":  
  15.             oper=new MulOperation();  
  16.             break;  
  17.         case "/":  
  18.             oper=new DivOperation();  
  19.             break;  
  20.         }  
  21.         return oper;  
  22.     }  

(4)测试类 Main.java

  1.  
  2. public class Main {  
  3.     public static void main(String[] args) throws Exception{  
  4.         Operation oper;  
  5.         oper=OPerationFactory.createOperation("+");  
  6.         oper.set_numberA(9);  
  7.         oper.set_numberB(90);  
  8.         double result=oper.getResult();  
  9.         System.out.print(result);  
  10.     }  
  11. }  

此时一个简单工厂模式已经实现了,不管你是控制台程序,windows程序,web程序,PDA程序,或者手机程序,都可以用这段代码来实现计算器的功能

若将来有一天,需要增加一个其他的运算,只需要改AddOperation.java,然后在工厂类里面增加Switch分支即可、

 

4.下面我们就给出这几个类的结构图

5。UML类图

 

看那个动物矩形框,它代表一个类(Class)。类图分三层:显示类的名称,如为抽象类,用斜体表示。类的属性,通常是字段和属性。类的操作,通过为行为和方法。

注意:前面的符号:+ 表示public  --表示private  # 表示protected

(1)继承关系用 空心三角形+实线  来表示

(2)实现接口用  空心三角形+虚线 来表示

(3)关联(association)关联关系用 实线箭头  来表示

(4)聚合关系用  空心的菱形+实线箭头 来表示。

(5)组合  用实心菱形+实线箭头表示

(6)依赖关系用虚线箭头表示

 

最后总结几句:

  编程是一门技术,更加是一门艺术。

在写代码时,要时常考虑如何让代码更加的简练,更加容易维护,容易扩展,和复用,只有这样才可以得到提高。

此外UML类图,也不可一蹴而就,这些都是一个过程,做得多了,就会了!