设计模式—策略模式

最近在看设计模式，就将自己看的一些心得写下来，做学习笔记。该篇看的是head first 设计模式的一些体会和总结。

策略模式
定义算法族，分别封装起来，让它们之间可以相互替换，使算法的变化独立于使用算法的客户。
这定义好像很晦涩难懂呀，简单点说，就是将行为变化部分分别封装成接口，然后使用组合接口的方式来实现一个对象的全部行为。（在下面的例子看我之后再回头看定义，我想你会明白的）

设计原则（一）：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

其实就是把变化的部分封装起来，不要让其他不变的部分受到影响

设计原则（二）：针对接口编程，而不是针对实现编程

针对接口编程的本质是：针对超类型（super）编程

书中对这个原则有详细的解释（感觉这段解释很好）：这里所谓的“接口”有多个含义，接口是一个“概念”，也是一直java的interface构造。利用多态，程序可以针对超类型编程，执行时会根据实际状况执行到真正的行为，不会绑死在超类型的行为上。“针对超类型编程”这句话，可以更明确的说成“变量的声明类型应该是超类型，通常是一个抽象类或者是一个接口”，如此，只要是具体实现此超类型的类所产生的对象，都可以指定给这个变量。这也意味着，声明类时不用理会以后执行时的真正对象类型！

下面是简单多态的例子：
a.针对“实现编程”
声明变量“d”为Dog类型（Animal的具体实现），会造成我们必须针对具体实现编程。

Dog d = new Dog;
d.bark();

b.但是针对“接口/超类型编程”的做法如下(正确做法)：
我们知道对象是狗，但是现在利用annimal进行多态调用。

Animal animal = new Dog();
animal.makeSound();

设计原则（三）：多用组合，少用继承

本质就是：通过多个接口（interface），将行为分类（比如鸭子叫和飞属于2个不同的属性），并实现该接口。这里所说的组合就是不使用继承来实现鸭子的叫和飞属性，而是通过定义接口。然后通过接口将这两个行为组合成鸭子的属性（叫和飞）。
在head first 里面是通过定义FlyBehavior 和 QuckBehavior.每个鸭子都有一个FlyBehavior 和 QuckBehavior，好将飞行和呱呱叫委托给他们代为处理。

代码示例（源自head first 设计模式）

/**
 * 鸭子抽象超类
 * Created by nana on 2017/11/5.
 */

public abstract class Duck {
    public FlyBehavior flyBehavior;//这里声明接口类型的引用变量
    public QuackBehavior quackBehavior;

    public Duck(){
    }

    public abstract void display();

    public void performFly(){
        flyBehavior.fly();//委托给飞行行为类
    }

    public void performQuck(){
        quackBehavior.quack();//委托给呱呱叫行为类
    }
    
    //游泳方法是所有鸭子都能实现的行为（且表现相同）
    public void swim(){
        Log.i("nana","All duck float,even decoys");
    }
    public void setFlyBehavior(FlyBehavior flyBehavior){
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior){
        this.quackBehavior = quackBehavior;
    }
}

鸭子有2个属性（飞行和呱呱叫）下面是2个属性定义接口

/**
 * 飞行行为接口
 * Created by nana on 2017/11/5.
 */

public interface FlyBehavior {
    void fly();
}

/**
 * 叫声接口
 * Created by nana on 2017/11/5.
 */

public interface QuackBehavior {
   void quack();
}

FlyNoWay 和 FlyWithWings 是对飞行接口 FlyBehavior 的具体实现

/**
 * 不会飞的鸭子的飞行行为实现类
 */

public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        Log.i("nana","FlyNoWay!!!");}
}

/**
 * 鸭子用翅膀飞行的飞行实现类
 */

public class FlyWithWings implements FlyBehavior{
    @Override
    public void fly() {
        Log.i("nana","FlyWithWings!!!");
    }
}

Quck是对鸭子叫行为的具体实现

public class Quck implements QuackBehavior{

    @Override
    public void quack() {
        Log.i("nana","quack!!!");
    }
}

这个MallardDuck是鸭子抽象超类的子类实现

public class MallardDuck extends Duck{


    public MallardDuck(){
        quackBehavior = new Quck();
        flyBehavior = new FlyWithWings();
    }

    @Override
    public void display() {
        Log.i("nana","I am a Mallard duck ~~~~~");
    }
}

测试类：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Duck mallard = new MallardDuck();//这里针对接口编程，多态
        mallard.performFly();
        mallard.setFlyBehavior(new FlyWithWings());
        mallard.performFly();
        mallard.performQuck();
        mallard.display();
        mallard.swim();
    }
}

看完代码，我们再来总结一下。使用原则一，将鸭子的行为呱呱叫和飞行行为分离出来。使用原则二和原则三,我们针对超类型编程，鸭子有抽象超类（且超类里持有飞行和叫的引用，并在超类里面使用这个应用进行行为的处理），那么子类鸭子就可以继承超类实现飞行和叫的行为。且可以根据自己实际情况选择会飞或者用翅膀飞的飞行行为，叫的行为也可以有多个，这里没有具体写。

不知道你理解了吗？看一下UML图可能更直观。

这里写图片描述

上述图片是应用网友的博客中图片，发现该网友对书中例子更全面。可以参考链接： https://www.cnblogs.com/wolf-sun/p/3534573.html
以上是读书笔记，如果有问题。欢迎交流。