Java面向对象--策略设计模式



策略模式将可变的部分从程序中抽象分离成算法接口，在该接口下分别封装一系列算法实现，并使他们可以相互替换，从而导致客户端程序独立于算法的改变

【策略模式的适用场景】

1. 许多相关的类仅仅是行为差异

2. 运行时选取不同的算法变体

3. 如果发现代码中有很多if else语句，可通过条件语句在多

              个分支中选取一

     【思考】

    1.如果使用继承：

         优点：简单易用，缺点：不具有灵活性，需要复写父类的方法，这会容易忘

         2.如果使用抽象方法：（在父类中提供抽象方法，强迫子类实现自己的飞行行为）

                 优点：足够灵活，缺点：(1)每个子类都要实现一遍代码，即使是相同的行为也不会例外(2)代码重复，没有复用代码

         3.使用组合:比较好的方法   优点：足够灵活，复用代码，更易于维护，富有弹性，可以较好的应对变化（开闭原则）

    【组合】composition在类中增加一个私有域，引用另一个已有的类的实例，通过调用引用实例的方法从而获得新的功能，这种设计被称为组合（复合）

public class StrategyDesignModelOfInterface {
 public static void main(String[] args) {
  Duck black = new BlackDuck();
        black.display();
  black.fly();
  
//  Duck green = new GreenDuck();
//  green.display();
//  green.fly();
  
  Duck green = new GreenDuck();
  green.display();
  green.setfw(new FlayHigh());
  green.fly();

 }

}

// 定义一个接口 代表飞的方式;在父类中持有该接口，并由该接口代理飞行行为【组合】

interface FlyWay {
 public void fly();
}

// 会飞
class CanFly implements FlyWay {

 public void fly() {
  System.out.println("我会飞");
 }

}

// 不会飞
class CanNotFly implements FlyWay {

 public void fly() {
  System.out.println("但是我不会飞");
 }

}
class FlayHigh implements FlyWay {

 public void fly() {
       System.out.println("我飞的很高很高");  
 }
 
}
class GreenDuck extends Duck {
 /*public GreenDuck(){
  super.setfw(new FlayHigh());
 }*/

 @Override
 public void display() {
      System.out.println("我是绿鸭子，我飞的很高很高");
 }
 
}

// 白鸭子不会飞
class WhiteDuck extends Duck {

 public WhiteDuck() {
  super.setfw(new CanNotFly());
 }

 public void display() {
  System.out.println("我是白鸭子，我喜欢跳舞");
 }
}

// 黑鸭子会飞
class BlackDuck extends Duck {

 public BlackDuck() {
  super.setfw(new CanFly());
 }

 public void display() {
  System.out.println("我是黑鸭子，我喜欢唱歌");
 }

}

abstract class Duck {
 private FlyWay fw;// 多用组合，少用继承 意思就是将接口作为属性

 public Duck() {
 }

 public abstract void display();

 public void setfw(FlyWay fw) {
  this.fw = fw;
 }

 public void fly() {
  fw.fly();
 }
}