---

• 设计模式概述

  • 定义
    设计模式是一套被反复使用,多数人知晓的,经过分类的,代码设计经验总结

    简单来说：经验复用！

  • 使用语言:

    并不要求一定用某种语言,理论上适合于任何oo语言（面向对象编程语言）(Java,C#等)

  • 意义&目的:

    代码复用,增加可维护性。每种模式在现时中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

---

• 策略模式概述
  • 预备知识：本文以java举例，请先了解 类、复用、继承、多态、接口，抽象类等
  • 策略模式（ Strategy Pattern）：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。
  • （划重点！！！）最主要用法：许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法

---

正文！

用例子理解：

有一个Duck（）类

鸭子会叫

所以有一个Quack()方法

因为红头鸭和绿头鸭会飞，现在，要新加入一种 fly（）方法。

方法一：继承

继承是指一个对象直接使用另一对象的属性和方法。

即直接在Duck类里面加入fly（）方法，再由子类继承。

但是！！！

不是所有的鸭子都会飞

（橡皮鸭问号？？？)

那么，对于每一个Duck子类的实例对象，都必须覆盖fly（）方法（会飞的不会飞的，乃至用不同姿态飞的鸭子）

然而，如果还有一个诱饵鸭：

不会飞也不会叫。。。。。。

那么，又得覆盖Quack（）方法。

代码：

public class StrategyModel1 {
    public static void main(String[] args) {
        Duck1 duck=new Duck1();
        System.out.println("Duck1:");
        duck.fly1();
        duck.Quack1();
        duck.Swim1();
        Duck1 rubberduck=new rubberDuck1();
        System.out.println("RubberDuck1:");
        rubberduck.fly1();
        rubberduck.Quack1();
        rubberduck.Swim1();
        Duck1 Decoyduck=new DecoyDuck1();
        System.out.println("DecoyDuck1:");
        Decoyduck.fly1();
        Decoyduck.Quack1();
        Decoyduck.Swim1();
    }
}
class Duck1{
     public void fly1() {
         System.out.println("I'm flying!");
    }
     public void Quack1() {
         System.out.println("呱呱呱");
     }
     public void Swim1() {
         System.out.println("All the Ducks are swimming!");
     }
}
class rubberDuck1 extends Duck1{
    public void fly1() {
        System.out.println("I can't fly!");//point1
    }
    public void Quack1() {
        System.out.println("吱吱吱");
    }
}
/*看似可行，但是可能不同的类有相同的方法，直接继承会继承不相同不想要的方法。

比如DecoyDuck1想要用RubberDuck1的fly1方法，要么继承Duck1，再重写fly1方法；

要么不继承Duck1而继承RubberDuck1，再重写Quack1方法。

无论哪种继承，都会导致代码在多个子类中重复。*/
class DecoyDuck1 extends Duck1{
    public void fly1() {
        System.out.println("I can't fly!");//point2
    }
    public void Quack1() {
        System.out.println("呱呱呱");
    }
}

结论：

1.利用继承的方法，改动会牵一发而动全身，造成其他不想要的改变

2.代码在多个子类中重复。

简单来说：有新方法子类就要覆盖父类。覆盖其实没有逻辑问题，问题是同样的方法在不同类里面要重写多次，代码繁琐。

方法二：接口

继承不行。因为鸭子会不断更新，这样每当有新的鸭子类出现，就得检查甚至覆盖fly（）和Quack（）方法。

那么
我们可以把fly（）从父类中取出来，放到Flyalbe接口中，这样，只有会飞的鸭子才能实现此接口。Quackable接口同理。

接口：（interface），是一系列方法的声明，是一些方法特征的集合,一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

【注意与抽象类区分！】（抽象类是对一种事物的抽象，即对类抽象{is-a}（全部方法和属性继承）。而接口是对行为的抽象{has-a}。（指定方法继承））

代码：

public class StrategyModel2 {
    public static void main(String[] args) {
        Duck2 duck=new Duck2();
        duck.fly2();
        Duck2 rubberduck=new rubberDuck2();
        rubberduck.fly2();
    }
}
class rubberDuck2 extends Duck2 implements Flyable2 {
    public void fly2() {
        System.out.println("I don't wanna to fly!");
    }
}
class Duck2 implements Flyable2{
    public void fly2() {
        System.out.println("I'm flying!");
    }
}
interface Flyable2{
    public abstract void fly2();
}
//Flyalbe2导致fly2完全不能复用

现在虽然Flyable接口可以解决会飞的橡皮鸭问题，

但是！！！

这是一种更蠢的方法，只有方法声明，没有方法实现！

代码将完全无法复用，无论方法是否一样，每次必须重写。

方法三：策略模式！

继承不能解决问题，因为鸭子的行为在子类里不断改变，而且让所有子类都有这些行为是不恰当的。

接口似乎可行，只有会飞的鸭子继承Flyable接口，但是Java接口不具有实现代码，继承接口无法使代码复用。

有一个设计原则，恰好适用于此：(第一个设计原则！)

找出变化之处，把它独立出来，与无需变化的代码隔离

这个概念很简单，

几乎是每个设计模式背后的精神所在！

哪些可变哪些不可变？

每次新的需求一来，都会使某方面的代码发生变化，那么这部分代码就要被抽出来，区分与其他稳定代码。

Fly（）和Quack（）会随着鸭子的类不同而改变。
我们把它们从Duck类中取出，新建一组类来代表每个行为

第二个设计原则：针对接口编程！而不是针对实现编程

我们利用接口代表每个行为，比方说，FlyBehavior，而行为的每个实现都将实现其中的一个接口。

这样的做法迥异于以往，以前的做法是：行为来自Duck父类的具体实现，或是继承某个接口并由子类自行实现而来。这两种做法都是依赖于“实现”，我们被实现绑得死死的，没办法更改行为（除非写更多代码）。

在我们的新设计中，鸭子的子类将使用接口FlyBehavior所表示的行为，所以实际的“实现”不会被绑死在鸭子的子类中。

换句话说，特定的具体行为编写在实现了FlyBehavior的类中。

这样设计，甚至可以让fly被其他对象复用，因为这个fly动作已经与鸭子类无关了。

代码：

public class StrategyModel3 {
    public static void main(String[] args) {
        Duck3 duck=new Duck3();
        duck.Swim3();
        Duck3 rubberduck=new RubberDuck3();
        rubberduck.Swim3();
        rubberduck.PerformFly();
        Duck3 decoyduck=new DecoyDuck3();
        decoyduck.PerformFly();
    }
}
class Duck3{
    public FlyBehavior flybehavior;
    public void Swim3() {
        System.out.println("All the ducks are swimming!");
    }
    public void PerformFly() {
        flybehavior.fly3();
    }
}
class RubberDuck3 extends Duck3{
    public RubberDuck3() {
    flybehavior=new FlyWithWings();
    }
}
class DecoyDuck3 extends Duck3{
    public DecoyDuck3() {
        flybehavior=new FlyNoWay();
    }
}
interface FlyBehavior{
    public void fly3();
}
class FlyWithWings implements FlyBehavior{
    public void fly3() {
        System.out.println("I'm flying!");
    }
}
class FlyNoWay implements FlyBehavior{
    public void fly3() {
        System.out.println("I can't fly!");
    }
}

（Quack同理）

将两个类结合起来使用，如同本例，就是组合。这种做法和“继承”不同的地方在于，鸭子的行为不是继承来的，而是和适当的行为对象组合来的。

第三个设计原则：多用组合，少用继承！

---

复习：

策略模式：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

概念图示：

---

结束
------By@YYSir