[设计模式]

写在前面的话：

        一个类或对象中往往会包含别的对象。在创建这种成员对象时，你可能习惯使用常规的方法，即用new关键字和构造函数创建实例。但这样问题在于会导致两个类之间产生依赖性。消除这两个类之间的依赖模式，可以使用一种方法来决定究竟要实现哪个具体类。

用简单工厂模式实现计算器

UML类图：

代码中使用的工具类

var Util = {
    /* subClass继承superClass */
    extend: function(subClass, superClass) {
        var F = function() {};
        F.prototype = superClass.prototype;
        subClass.prototype = new F();           //为子类设置原型对象
        subClass.prototype.constructor = subClass;
        
        subClass.superclass = superClass.prototype;
        if(superClass.prototype.constructor === Object.prototype.constructor) {
            superClass.prototype.constructor = superClass;
        }
    }
};

简单工厂使用一个类(通常是一个单体)来生成实例。

//用单例实现获取运算符的实例
var OperationFactory = {
    //根据传递的参数创建相应的运算符对象并返回
    createOperation: function(operate) {
        var oper = null;
        switch(operate) {
            case '+':
                oper = new OperationAdd();
                break;
            //...
        }
        return oper;
    }
};

业务的封装

Operation运算类

//超类：运算类
function Operation() {
    //私有属性 参与运算的数字
    var number1, number2;
    
    //公有方法 属性的取值器和赋值器
    this.getNumber1 = function() {
        return number1;
    };
    this.setNumber1 = function(number) {
        number1 = number;
    };
    this.getNumber2 = function() {
        return number2;
    };
    this.setNumber2 = function(number) {
        number2 = number;
    };
}
//公有方法
Operation.prototype = {
    //虚函数 需要子类实现
    getResult: function() {
        var result = 0.0;
        return result;
    }
};

各种运算符类(+ - * /)继承运算类 

function OperationAdd() {           //+
    OperationAdd.superclass.constructor.call(this);     //实现继承第一步
}
Util.extend(OperationAdd, Operation);                   //实现继承第二步
/*
 * 重写超类的方法
 * @override 
 */
OperationAdd.prototype.getResult = function() {         //扩展子类
    var result = this.getNumber1() + this.getNumber2();
    return result;
};   
function OperationSub() {           //'-'
    OperationSub.superclass.constructor.call(this);
}
Util.extend(OperationSub, Operation);
//重写超类的方法
OperationSub.prototype.getResult = function() {
    //...
}
function OperationMul() {           //'*'
    
}
function OperationDiv() {           //'/'
    
}

程序的总体结构：

var calculator = (function(Util){
    //超类：运算类
    function Operation() {
        //...
    }
    //公有方法
    Operation.prototype = {
        //虚函数 需要子类实现
        getResult: function() {}
    };
    //-----------------------------------------------------------------    
    //各种运算符类(+ - * /)继承运算类    
    function OperationAdd() {           //+
        OperationAdd.superclass.constructor.call(this);     //实现继承第一步
    }
    Util.extend(OperationAdd, Operation);                   //实现继承第二步
    /*
     * 重写超类的方法
     * @override 
     */
    OperationAdd.prototype.getResult = function() {         //扩展子类
        var result = this.getNumber1() + this.getNumber2();
        return result;
    };   
    function OperationSub() {           //'-'
        //...
    }
    function OperationMul() {           //'*'
        //...
    }
    function OperationDiv() {           //'/'
        //...
    }
    //------------------------------------------------------
    //用单例实现获取运算符的实例
    var OperationFactory = {
        //...
    };
    return {
         OperationFactory: OperationFactory 
    };
})(Util);

对加法类简单的测试：

(function() {
    var oper = null;
    //根据传递的参数获取运算符对象
    oper = calculator.OperationFactory.createOperation('+');
    oper.setNumber1(1);
    oper.setNumber2(2);
    console.log(oper.getResult());
})();

编程是一门技术，更是一门艺术，应时常考虑如何让代码更加简练，更加容易维护，容易扩展和复用，只有这样才可以真正的提高编程能力。