设计模式-策略模式

最近在看设计模式，就将自己看的一些心得写下来，做学习笔记。该篇看的是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

以上是读书笔记，如果有问题。欢迎交流。