设计模式～策略模式

最新推荐文章于 2025-07-03 08:28:58 发布

原创最新推荐文章于 2025-07-03 08:28:58 发布 · 486 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

13 篇文章

订阅专栏

策略模式：

1、找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；
2、找出应用中可能需要变化之处，把它们独立出来形成接口，不要和那些不需要变化的代码混在一起，让子类去实现它们。

设计模式～设计原则：(重要)

1、逻辑代码独立到单独的方法中，注重封装性--易读，易复用。不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。

2、写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！是否可以拿到其它同类事物中应该？是否可以拿到其它系统中应该？

//这句话才是真正什么时候使用继承，什么时候使用接口的真理，我懂了吗？我真的懂了吗？抽象类，封装不变的；接口，独立出变化的。

3、熟练运用继承的思想：找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；继承的思想，也方便将自己的逻辑建立于别人的成果之上。熟练运用接口的思想：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

把很简单的东西搞得那么复杂，一次性代码，设计模式优势的实例说明：（策略模式）
说明：
模拟鸭子游戏的应用程序，要求：游戏中会出现各种颜色外形的鸭子，一边游泳戏水，一边呱呱叫。

第一种方法：（一次性代码）
直接编写出各种鸭子的类：MallardDuck//野鸭，RedheadDuck//红头鸭，各类有三个方法：
quack()：叫的方法
swim()：游水的方法
display()：外形的方法

第二种方法：运用继承的特性，将其中共同的部分提升出来，避免重复编程。
即：设计一个鸭子的超类（Superclass）,并让各种鸭子继承这个超类。

public class Duck{
     public void quack(){  //呱呱叫
              System.out.println("呱呱叫");
      }
     public void swim(){   //游泳
            System.out.println(" 游泳");
      }    
     public  abstratact void display(); /*因为外观不一样，让子类自己去决定了。*/
}

对于它的子类只需简单的继承就可以了，并实现自己的display()方法。

//野鸭
 public class MallardDuck extends Duck{
     public void display(){
          System.out.println("野鸭的颜色...");
   }
 }
//红头鸭
 public class RedheadDuck extends Duck{
     public void display(){
          System.out.println("红头鸭的颜色...");
   }
}

不幸的是，现在客户又提出了新的需求，想让鸭子飞起来。这个对于我们OO程序员，在简单不过了，在超类中在加一

个方法就可以了。

public class Duck{
     public void quack(){  //呱呱叫
              System.out.println("呱呱叫");
      }
     public void swim(){   //游泳
            System.out.println(" 游泳");
    }    
    public  abstract void display(); /*因为外观不一样，让子类自己去决定了。*/
    public void fly(){
        System.out.println("飞吧！鸭子"); 
  }
}

对于不能飞的鸭子，在子类中只需简单的覆盖。

<pre code_snippet_id="1924813" snippet_file_name="blog_20161012_4_8527653" name="code" class="java" style="font-size: 14px;"><span style="font-family: "Helvetica Neue", Helvetica, Verdana, Arial, sans-serif;">//残废鸭</span>

<span style="font-family: "Helvetica Neue", Helvetica, Verdana, Arial, sans-serif;"></span><pre code_snippet_id="1924813" snippet_file_name="blog_20161012_4_8527653" name="code" class="java" style="font-size: 14px;">public class DisabledDuck extends Duck{

public void display(){ System.out.println("残废鸭的颜色..."); } public void fly(){ //覆盖，变成什么事都不做。 }}

其它会飞的鸭子不用覆盖。

这样所有的继承这个超类的鸭子都会fly了。但是问题又出来了，客户又提出有的鸭子会飞，有的不能飞。

>>>>>>点评:
对于上面的设计，你可能发现一些弊端，如果超类有新的特性，子类都必须变动，这是我们开发最不喜欢看到的，一个类变让另一个类也跟着变，这有点不符合OO设计了。这样很显然的耦合了一起。利用继承-->耦合度太高了.

第三种方法：
用接口改进.
我们把容易引起变化的部分提取出来并封装之，来应付以后的变法。虽然代码量加大了，但可用性提高了，耦合度也降低了。

我们把Duck中的fly方法和quack提取出来。

public interface Flyable{
      public void fly(); 
}
public interface Quackable{
     public void quack();
}

最后Duck的设计成为：

public class Duck{
    public void swim(){   //游泳
            System.out.println(" 游泳");
    }    
    public  abstract void display(); /*因为外观不一样，让子类自 己去决定了。*/
}

而MallardDuck,RedheadDuck,DisabledDuck 就可以写成为：

//野鸭
 public class MallardDuck extends Duck  implements Flyable,Quackable{
     public void display(){
          System.out.println("野鸭的颜色...");
   }
   public void fly(){
    //实现该方法
  }
   public void quack(){
    //实现该方法
  }
 }

//红头鸭
 public class RedheadDuck extends Duck implements Flyable,Quackable{
     public void display(){
          System.out.println("红头鸭的颜色...");
   }
   public void fly(){
    //实现该方法
  }
   public void quack(){
    //实现该方法
  }
}

//残废鸭 只实现Quackable（能叫不能飞）
 public class DisabledDuck extends Duck implements Quackable{
     public void display(){
          System.out.println("残废鸭的颜色...");
   }
   public void quack(){
    //实现该方法
  }
}

>>>>>>点评:
好处:
这样已设计，我们的程序就降低了它们之间的耦合。
不足:
Flyable和 Quackable接口一开始似乎还挺不错的，解决了问题（只有会飞到鸭子才实现 Flyable），但是Java接口不具有实现代码，所以实现接口无法达到代码的复用。

第四种方法：

对上面各方式的总结:
继承的好处:让共同部分,可以复用.避免重复编程.

继承的不好:耦合性高.一旦超类添加一个新方法,子类都继承,拥有此方法,若子类相当部分不实现此方法,则要进行大批量修改.继承时,子类就不可继承其它类了.

接口的好处:解决了继承耦合性高的问题，且可让实现类,继承或实现其它类或接口.

接口的不好:不能真正实现代码的复用.可用以下的策略模式来解决.

------------------------- strategy(策略模式) -------------------------
我们有一个设计原则：
找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；
找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

现在，为了要分开“变化和不变化的部分”，我们准备建立两组类（完全远离Duck类），一个是"fly"相关的，另一个是“quack”相关的，每一组类将实现各自的动作。比方说，我们可能有一个类实现“呱呱叫”，另一个类实现“吱吱叫”，还有一个类实现“安静”。

首先写两个接口。FlyBehavior(飞行行为)和QuackBehavior（叫的行为）.

 public interface FlyBehavior{
     public void fly();     
 }
 public interface QuackBehavior{
     public void quack();
 }

我们在定义一些针对FlyBehavior的具体实现。

 public class FlyWithWings implements FlyBehavior{
    public void  fly(){
     //实现了所有有翅膀的鸭子飞行行为。
   }
 }
public class FlyNoWay implements FlyBehavior{
 
    public void  fly(){
      //什么都不做，不会飞
    }
 }

针对QuackBehavior的几种具体实现。

public class Quack implements QuackBehavior{
    public void quack(){
      //实现呱呱叫的鸭子
  }
}
 
public class Squeak implements QuackBehavior{
    public void quack(){
      //实现吱吱叫的鸭子 
  }
}
 
public class MuteQuack implements QuackBehavior{
    public void quack(){
      //什么都不做，不会叫
  }
}

点评一:
这样的设计，可以让飞行和呱呱叫的动作被其他的对象复用，因为这些行为已经与鸭子类无关了。而我们增加一些新

的行为，不会影响到既有的行为类，也不会影响“使用”到飞行行为的鸭子类。

最后我们看看Duck 如何设计。

 public class Duck{        //在抽象类中,声明各接口,定义各接口对应的方法.
      FlyBehavior flyBehavior;//接口
      QuackBehavior quackBehavior;//接口
       public Duck(){}
       public abstract void display();
       public void swim(){
        //实现游泳的行为
        }
       public void performFly(){
            flyBehavior.fly();  //由于是接口,会根据继承类实现的方式,而调用相应的方法.
     }
     public void performQuack(){
          quackBehavior.quack();();
    }
 }

看看MallardDuck如何实现。
----->通过构造方法,生成'飞','叫'具体实现类的实例,从而指定'飞','叫'的具体属性

public class MallardDuck extends Duck{
       public MallardDuck {       
        flyBehavior = new FlyWithWings ();
        quackBehavior = new Quack(); 
      //因为MallardDuck 继承了Duck，所有具有flyBehavior 与quackBehavior 实例变量}
    public void display(){
     //实现
   }
 }

这样就满足了即可以飞，又可以叫，同时展现自己的颜色了。

这样的设计我们可以看到是把flyBehavior ，quackBehavior 的实例化写在子类了。我们还可以动态的来决定。
我们只需在Duck中加上两个方法。

在构造方法中对属性进行赋值与用属性的setter的区别：

构造方法中对属性进行赋值：固定，不可变；

用属性的setter，可以在实例化对象后，动态的变化，比较灵活。

 public class Duck{
      FlyBehavior flyBehavior;//接口
      QuackBehavior quackBehavior;//接口
      public void setFlyBehavior(FlyBehavior flyBehavior){
            this.flyBehavior = flyBehavior;
     }
    public void setQuackBehavior(QuackBehavior quackBehavior  {
            this.quackBehavior= quackBehavior;
     }
 }

我们学习注重的是思想，但是我居然注重的实例，哎，这也是我发展慢的原因吧：再看一个实例，

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

三者之间的关系可以用下图来表示：

策略模式的实现：

　　1.对策略对象定义一个公共接口。

　　2.编写策略类，该类实现了上面的公共接口。

　　3.在使用策略对象的类中保存一个对策略对象的引用。

　　4.在使用策略对象的类中，实现对策略对象的set和get方法或者使用构造方法完成赋值。

具体代码实现：

定义一个接口( 抽象策略)，定义一个方法用于对两个整数进行运算

public interface Strategy {
     public abstract int calculate(int a,int b);
}

定义具体的算法类，实现两个整数的加减乘除运算，但是外部调用形式需要符合接口的定义

实现加法运算

public class AddStrategy implements Strategy{
     @Override
     public int calculate(int a, int b) {
         return a+b;
     }
}

实现减法运算

public class SubstractStrategy implements Strategy{ 
     @Override
     public int calculate(int a, int b) {         
         return a-b;
     } 
}

实现乘法运算

public class MultiplyStrategy implements Strategy {
     @Override
     public int calculate(int a, int b) {         
         return a*b;
     } 
}

定义具体的环境角色，持有Strategy接口的引用，并且有get和set方法可以完成策略更换。在环境角色中调用接口的方法完成动作。

class Context {
     private Strategy strategy;     
     public Context(Strategy strategy) {
          super();
          this.strategy = strategy;
     } 
     public Strategy getStrategy() {
         return strategy;
     }
 
     public void setStrategy(Strategy strategy) {
         this.strategy = strategy;
     }
     public int calculate(int a,int b){
         return strategy.calculate(a, b);
     }
}

这样在客户端在调用时，只需向环境角色设置相应的算法类，然后就可以得到相应的结果。

public class StrategyTest {

      public static void main(String[] args) {
         //加法
         Context context=new Context(new AddStrategy());
         System.out.println(context.calculate(10, 5));
         //减法
         Context context2=new Context(new SubstractStrategy());
         System.out.println(context2.calculate(3, 2));
         //乘法
         Context context3=new Context(new MultiplyStrategy());
         System.out.println(context3.calculate(6, 8));
      }
}

策略模式的缺点：

1、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。

这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。

换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

2、策略模式造成很多的策略类，每个具体策略类都会产生一个新类。

有时候可以通过把依赖于环境的状态保存到客户端里面，而将策略类设计成可共享的，这样策略类实例可以被不同客户端使用。

换言之，可以使用享元模式来减少对象的数量。