策略模式2

我们再看一个策略模式的代码，深度理解下

//对象父类，鸭子
public abstract class Duck {
    IQuackBehavior quackBehavior;    //行为的引用

    public abstract void display();

    public void performQuack() {
        quackBehavior.quack();
    }
    public void setQuackBehavior(IQuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
}
//具体的子类，绿头鸭
public class DuckMallard extends Duck {
    @Override
    public void display() {
        System.out.println("我是 绿头鸭");
    }
}

//行为的接口，叫喊接口
public interface IQuackBehavior {
    void quack();
}
//行为实现1
public class MuteQuack implements IQuackBehavior{
    @Override
    public void quack() {
        System.out.println("不会发出声音");
    }
}
//行为实现2
public class SqueckQuack implements IQuackBehavior {
    @Override
    public void quack() {
        System.out.println("发出吱吱的声音");
    }
}
//场景验证
public class TestSimulator {
    public static void main(String[] args) {
        Duck duck = new DuckMallard();
        duck.setQuackBehavior(new SqueckQuack());
        duck.display();
        duck.performQuack();
    }
}

image.png

上面是headFirst里关于策略的用例。我们可以一起来看看代码为什么这样写。

1、找出可能的变化之处，把他们独立出来，不要和不变的放在一起。

所以我们可以看出，把display()方法我们放在了父类里，但是却把叫喊的行为单独抽象出来作为行为类。
因为display是所有子类都有的；而叫喊如果放在父类里会导致子类都要去重写，有些子类没有也要重写一个。

这一步我们将行为单独出来了

2、针对接口编程，不要针对实现编程

什么意思呢？以前我们的做法是在父类里定义抽象接口，子类去实现，但是这种方式，我们就被实现绑的死死的，没办法更改行为。我们为什么不将行为在运行的时候再给他，还可以让子类可以改变自己的行为。

这一步我们确定行为使用接口而不是采用继承和实现

3、尽可能采用组合，将行为委托到其他类

我们在父类里引用了行为的接口引用，并定义了方法，在方法里通过引用去调用对应的行为。
这块是策略模式变行最多的地方，我们可以有多种方式进行引用。第一种通过构造函数，第二种通过set赋值（同上），第三者可以直接在方法上入参引用

//通过构造函数
public class DuckMallard extends Duck {
    public DuckMallard(IQuackBehavior quackBehavior){
        this.quackBehavior=quackBehavior;
    }
    @Override
    public void display() {
        System.out.println("我是 绿头鸭");
    }
}
  public static void main(String[] args) {
        Duck duck = new DuckMallard(new SqueckQuack());
        duck.display();
        duck.performQuack();
    }

//通过方法引用
public abstract class Duck {
    public abstract void display();
    public void performQuack(IQuackBehavior quackBehavior) {
        quackBehavior.quack();
    }
}
    public static void main(String[] args) {
        Duck duck = new DuckMallard();
        duck.display();
        duck.performQuack(new SqueckQuack());
    }

在java里很多时候策略模式都是这样用的，直接创建一个新的策略赋值进去

    public static void main(String[] args) {
        Duck duck = new DuckMallard();
        duck.setQuackBehavior(new IQuackBehavior() {
            @Override
            public void quack() {
                System.out.println("我就是这样叫的");
            }
        });
        duck.display();
        duck.performQuack();
    }

在策略模式(Strategy Pattern)中，一个类的行为或其算法可以在运行时更改。这种类型的[设计模式]属于行为型模式。简单理解就是一组算法，可以互换，再简单点策略就是封装算法。

模式结构的主要特征

1、有一个行为接口，同时还有很多策略实现
2、持有了抽象接口的引用

策略模式的优点和缺点

优点：算法可以随时切换，扩展性好
缺点：策略类会很多