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


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

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

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

如果发现代码中有很多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();

 }

}