策略模式

策略模式，其用意是针对一组算法，将每个算法封装到具有共同接口的独立的类中，从而使得他们可以相互替换，策略模式使得算法可以在不影响到客户端的情况下发生变化。

 

策略模式结构

   策略模式中有三个对象：
（1）       环境对象：该类中实现了对抽象策略中定义的接口或者抽象类的引用。
（2）       抽象策略对象：它可由接口或抽象类来实现。
（3）       具体策略对象：它封装了实现同不功能的不同算法。

 //环境角色 

        public class Context{  

            private Strategy strategy;             

           //策略方法  

1.             public void contextInterface(){  
2.                 strategy.strategyInterface();  
3.             }  
4.         }  
5.           
6.         //抽象策略类  
7.         public abstract class Strategy{  
8.             //策略方法  
9.             public abstract void strategyInterface();  
10.         }   
11.           
12.         //具体策略类  
13.         public class ConcreteStrategy extends Strategy{  
14.             public void strategyInterface(){  
15.                 //............  
16.             }  
17.         }  
18.           
19.     二、一个图书折扣店的例子  
20.         //抽象折扣类  
21.         public abstract class DiscountStrategy{  
22.             private single price = 0;  
23.             private int copies = 0;  
24.               
25.             //策略方法  
26.             public abstract single calculateDiscount();  
27.               
28.             public DiscountStrategy(single price , int copies){  
29.                 this.price = price;  
30.                 this.copies = copies;  
31.             }  
32.         }  
33.           
34.         //具体折扣类(没有折扣)  
35.         public class NoDiscountStrategy extends DiscountStrategy{  
36.             private single price = 0;  
37.             private int copies = 0;  
38.               
39.             public  NoDiscountStrtegy(single price, int copies){  
40.                 this.price = price;  
41.                 this.copies = copies;  
42.             }  
43.               
44.             public single calculateDiscount(){  
45.                 return 0;  
46.             }  
47.         }  
48.           
49.         //  
50.         public class FlatRateStrategy extends DiscountStrategy{  
51.             private single price = 0;  
52.             private int copies = 0;  
53.             private single amount;  
54.               
55.             public FlatRateStrategy(single price , int copies){  
56.                 this.price = price;  
57.                 this.copies = copies;  
58.             }  
59.               
60.             public single getAmount(){  
61.                 return amount;  
62.             }  
63.               
64.             public void setAmount(single amount){  
65.                 this.amount = amount;  
66.             }  
67.               
68.             public single calculateDiscount(){  
69.                 return copies*amount;  
70.             }  
71.         }  
72.           
73.         //  
74.         public class PercentageStrategy extends DiscountStrategy{  
75.             private single percent;  
76.             private single price = 0;  
77.             private int copies = 0;  
78.               
79.             public PercentageStrategy(single price , int copies){  
80.                 this.price = price;  
81.                 this.copies = copies;  
82.             }  
83.               
84.             public single getPercent(){  
85.                 return percent;  
86.             }  
87.               
88.             public void setPercent(single percent){  
89.                 this.percent = percent;  
90.             }  
91.               
92.             public single calculateDiscount(){  
93.                 return copies*price*percent;  
94.             }  
95.         }