初学javascript设计模式(一)工厂模式第一遍阅读

/*
工厂模式
目录:
1、简单工厂模式
2、工厂模式
*/
//允许存在除法的计算类
var PermitDivide = function() {
    return {
        Sum: function() { alert("累加") },
        Subtract: function() { alert("递减") },
        Multiply: function() { alert("累乘") },
        Divide: function() { alert("除法") }
    }
}
//不允许存在除法的计算类
var NoPermitDivide = function() {
    return {
        Sum: function() { alert("累加") },
        Subtract: function() { alert("递减") },
        Multiply: function() { alert("累乘") }
    }
}
//工厂类
var CalculateFactory = {
    Newthis: function() {
        var i = arguments.length;
        var isReturnDivide = true;
        while (i-- && isReturnDivide) {
            if (!arguments[i]) {
                isReturnDivide = false;
            }
        }
        /*简单工厂的核心思想应该就是根据不同的条件实例化不同的对象*/
        if (isReturnDivide) {
            return new PermitDivide();
        }
        else {
            return new NoPermitDivide();
        }
    }
}

/*简单工厂模式*/
//计算类构造函数
var Calculate = function() { }
Calculate.prototype.Newthis = function() {
    return CalculateFactory.Newthis.apply(this, arguments);
}
var a = new Calculate().Newthis(1, 0);
var b = new Calculate().Newthis(1, 2);
//a.Sum(); //累加
//a.Divide(); //异常a.Divide is not a function
//b.Sum(); //累加
//b.Divide(); //累除
/*********************************************/





/*工厂模式*/
/*
计算抽象类
抽象类不允许直接实例化
*/
var CalculateAbs = function() { };
CalculateAbs.prototype.Newthis = function() {

};
CalculateAbs.prototype = {
    Newthis: function() {
        throw Error("派生类未实现构造函数");
        return this;
    },
    each: function() {
        for (var i in this) {
            alert(i);
        }
    }
}
/*
工厂模式与简单工厂模式的核心差别是
简单工厂是函数本身的构造函数通过另外一个方法(工厂)进行不同条件实例化不同类
而工厂模式却是对继承的抽象类的构造函数进行重写,每个继承了抽象类的函数都必须编写各自的构造函数
*/

/*继承抽象类并重写了构造函数*/
var Calculate1 = function() { }
Calculate1.prototype = new CalculateAbs()
Calculate1.prototype.Newthis = function() {
    var i = arguments.length;
    var isReturnDivide = true;
    while (i-- && isReturnDivide) {
        if (!arguments[i]) {
            isReturnDivide = false;
        }
    }
    if (isReturnDivide) {
        return new PermitDivide();
    }
    else {
        return new NoPermitDivide();
    }
}
//var a = new Calculate1().Newthis(1, 0);
//var b = new Calculate1().Newthis(1, 2);
//a.Sum(); //累加
//a.Divide(); //异常a.Divide is not a function
//a.each(); //异常a.eac is not a function //因为这个构造完全是构造了2个新类与继承类无关所以返回的对象未继承到each方法
//b.Sum(); //累加
//b.Divide(); //除法



/*继承抽象类,未重写抽象类*/
var Calculate2 = function() { }
Calculate2.prototype = new CalculateAbs()
//var a = new Calculate2().Newthis(1, 0);
//var b = new Calculate2().Newthis(1, 2);
//a.Sum(); //派生类未实现构造函数
//a.Divide(); //派生类未实现构造函数
//b.Sum(); //派生类未实现构造函数
//b.Divide(); //派生类未实现构造函数


/*继承抽象类并重写抽象类*/
var Calculate3 = function() { }
Calculate3.prototype = new CalculateAbs();
Calculate3.prototype.Newthis = function() {
    this.Divide = function() {
        alert("除法");
    }
    return this;
}
//var a = new Calculate3().Newthis(1, 0);
//var b = new Calculate3().Newthis(1, 2);
//a.Divide(); //除法
//b.Divide(); //除法
//a.each(); //遍历继承抽象

/*********************************************************/