策略设计模式

感受：

   因为是设计模式的小白，第一次认真的去学习设计模式，感受颇深，感受到具有OO基础之后，然后再运用设计模式，就可以让自己的代码达到低耦合，且能非常方便后期的维护与扩展，我之前就想把自己的代码变成低耦合，便于后期的维护和扩展，但是不知道如何去做，我想设计模式现在能帮我解决这个问题吧，好吧现在一起进入策略模式的世界。

问题描述：

   公司让我们生成一种鸭子的玩具，大家都是知道鸭子肯定有很多种，有什么RedDuck，GreenDuck，BlackDuck等等,我们的鸭子都有名字的，而且鸭子都有特定的行为，比如我们大家都知道我们鸭子都会“嘎嘎嘎（大多数）”或者 “支支叫”,同时我们假设所有的鸭子都会游泳，在这里我们不管那种旱鸭子了，同时每个鸭子玩具都会展示他美丽外表，每只鸭子的外表都不同，所以。那么如何设计该类呢，下面是我们第一种设计方案

方案一：

   游泳我相信鸭子都差不多吧，还有因为每只鸭子的外表都不同，所以由子类复写父类的display方法，所以我们的开发人员二傻就得出下面的类图：

图一

   对于上面的设计，对于现在的情况来说已经适应了，当时由于玩具产品的竞争日益激烈，公司的boss想要有些鸭子能飞起来，这不是煮熟的鸭子要飞了么哈哈，不过既然是boss的要求当然要满足，于是我们的二傻就在duck基类里面加了fly()方法，好的问题来了，如果这样下去，我们将会看到所有的鸭子都飞起来，这就不是我们想要的效果了。

图二 所有的鸭子都飞了

方案二：

   可能有人会说，可以复写fly方法，如果是不会飞的鸭子，那方法体里面就什么都不写，这样可是可以，但是有一个问题，那就是，我们每次增加一种鸭子，都要去检查是否要去复写fly()方法，同时注意上面的问题描述 ，大多数的鸭子是”嘎嘎”的叫但是还是有少部分的鸭子是”支支”的叫，所以我们也要进行检查，根据需要是否复写quack方法，这无疑增加了我们二傻的负担，所以又出现了第二种方案:

图三
这种方案解决了上面所说的问题，但是最后又产生了新问题，那就是每种鸭子如果想飞，或者都会发出叫声，那么他们必须实现FlyAble接口或者QuackAbl接口，如果有1000只鸭子都是”嘎嘎“的叫，那么你就要实现一千次，那么很明显就会造成代码冗余，使得代码的复用性不高。
那么再怎么解决这个问题呢？接下来又有另外一种改善的方法：

package javase;
import java.lang.reflect.Array;
interface FlyAble{
    public abstract void fly();
}
interface QuackAble{
    public abstract void quack();
}
class FlyWithWing implements FlyAble{
    public void fly(){
        System.out.println("用翅膀飞");
    }
}
class FlyWithout implements FlyAble{
    public void fly(){
        System.out.println("我不会飞");
    }
}

class QuackWthigaga implements QuackAble{
    public void quack(){
        System.out.println("嘎嘎");
    }
}
class QuackWthiZhiZhi implements QuackAble{
    public void quack(){
        System.out.println("只只");
    }
}

abstract class Duck{
    private FlyAble fly=null;
    private QuackAble quack=null;
    public void swim(){
        System.out.println("swim");
    }
    public void fly(){
        fly.fly();
    }
    public void quack(){
        quack.quack();
    }
    public void setFly(FlyAble fly) {
        this.fly = fly;
    }
    public void setQuack(QuackAble quack) {
        this.quack = quack;
    }
    public abstract void display();//因为每只鸭子的形状都不同，所以由子类实现
}
class RedDuck extends Duck{
    public RedDuck(){
        setFly(new FlyWithWing());//设置一个默认飞的方式
        setQuack(new QuackWthigaga());//设置一个鸭子默认叫的方式
    }
    public void display(){
        System.out.println("I am RedDuck");
    }
}
public class Demo {
    public static void main(String[] args) throws  ClassNotFoundException {
            Duck duck=new RedDuck();
            duck.setFly(new FlyWithout());//后期可以自己设定飞的的方式
            duck.setQuack(new QuackWthigaga());//后期可以自己设定鸭子叫的方式
            duck.fly();
    }
}

好了，我们的鸭子小玩具这样设计就基本差不多了，来我们看下这样设计有哪些优势：

1. 低耦合，因为我们采用了面向接口编程，利用了多态，运行时觉得调用何种方法。
2. 可以提高代码复用率，如果下次又增加一种鸟，还是和以前一样的飞行方式，我们完全可以使用以前的代码
3. 例如我们在飞行能力上，我们很容易就可以进行切换，以及叫声上，而且也基本不影响其他的代码

总结：

1. 在我们进行设计的时候，多使用组合，少使用继承
2. 我们应该把变化的东西和不变的东西进行分离，在进行设计的时候，应该考虑到后期的可维护性和可扩展性。
3. 应当针对接口编程，不要针对实现编程，提高解耦能力。

策略设计模式装逼定义：定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。