《大话设计模式》——第一、二章 简单工厂模式、策略模式

第一章 简单工厂模式

工厂：用一个单独的类来创造实例的过程。

package{
    import flash.display.Sprite;
    
    public class Main extends Sprite{
        
        public function Main(){
            var numA:Number = 100;
            var numB:Number = 10;
            var operate:String = "/";
            var result:Number;
            var oper:Operation;
            oper = OperationFactoy.createOperate(operate);
            oper.numA = numA;
            oper.numB = numB;
            result = oper.GetResult();
            trace(result);
        }
    }
}

package{
    public class Operation{
        private var _numA:Number = 0;
        private var _numB:Number = 0;
        
        public function get numA():Number{
            return _numA;
        }
        
        public function set numA(value:Number):void{
            _numA = value;
        }
        
        public function get numB():Number{
            return _numB;
        }
        
        public function set numB(value:Number):void{
            _numB = value;
        }
        
        public function GetResult():Number{
            var result:Number = 0;
            return result;
        }
    }
}

package{
    public class OperationAdd extends Operation{
        
        public override function GetResult():Number{
            var result:Number = 0;
            result = numA + numB;
            return result;
        }
    }
}

package{
    public class OperationSub extends Operation{
        
        public override function GetResult():Number{
            var result:Number = 0;
            result = numA - numB;
            return result;
        }
    }
}

package{
    public class OperationMul extends Operation{
        
        public override function GetResult():Number{
            var result:Number = 0;
            result = numA * numB;
            return result;
        }
    }
}

package{
    public class OperationDiv extends Operation{
        
        public override function GetResult():Number{
            var result:Number = 0;
            //as3,若除数为0，商为Infinity；
            if(numB == 0){
//                throw new Error("除数不能为0！");
            }
            result = numA / numB;
            return result;
        }
    }
}

package{
    public class OperationFactoy{
        
        public static function createOperate(operate:String):Operation{
            var oper:Operation = null;
            switch(operate){
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }
}

第二章 策略模式

 策略模式：策略模式是一种定义一系列算法的方法，从概念上来看，所以这些算法完成的都是相同的工作，只是实现不同，它可以以相同方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

优点：减低耦合；简化单元测试，可以通过自己的接口单独测试。

使用：需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

package{
    import flash.display.Sprite;
    
    public class Main extends Sprite{
        public function Main(){
            var total:Number;
            var type:String = "1"
            var money:Number = 500;
            var cc:CashContext = new CashContext(type);
            total = cc.GetResult(money);
            trace("total:" + total);
        }
    }
}

package{
    public class CashContext{
        private var cs:CashSuper;
        public function CashContext(type:String){
            switch(type){
                case "0" :
                    cs = new CashNormal();
                    break;
                case "1":
                    cs = new CashRebate(0.9);
                    break;
                case "2":
                    cs = new CashReturn(400,100);
                    break;
            }
            this.cs = cs;    
        }
        
        public function GetResult(money:Number):Number{
            return cs.acceptCash(money);
        }
    
    }
}

package{
    public class CashSuper{
        public function acceptCash(money:Number):Number{
            return money;            
        }
    }
}

package{
    public class CashNormal extends CashSuper{
        public override function acceptCash(money:Number):Number{
            return money;
        }
    }
}

package{
    public class CashRebate extends CashSuper{
        
        private var moneyRebate:Number = 0.8;
        public function CashRebate(moneyRebate:Number){
            this.moneyRebate = moneyRebate;
        }
        public override function acceptCash(money:Number):Number{
            return money*moneyRebate;
        }
    }
}

package{
    public class CashReturn extends CashSuper{
        private var moneyCondition:Number;
        private var moneyReturn:Number;
        public function CashReturn(moneyCondition:Number, moneyReturn:Number){
            this.moneyCondition = moneyCondition;
            this.moneyReturn = moneyReturn;
        }
        
        public override function acceptCash(money:Number):Number{
            var reulst:Number;
            if(money >= moneyCondition){
                reulst = money - Math.floor(money/moneyCondition) * moneyCondition;
            }
            return reulst;
        }
    }
}