设计模式 ----- 策略模式

设计模式 —– 策略模式

个人博客，想要搭建个人博客的可以进来看看： http://www.ioqian.top/

---

OOP设计必须具备 可复用 ，可扩充， 可维护

背景
有一个软件要描述好多鸭子，主要包括了游泳，什么外观，飞行的动作，我们该怎么设计。

1使用继承

public class DemoOne {
    //公共父类
    abstract class Duck{
        public void Duck(){}
        //所以鸭子的游泳行为都是一致的，直接实现
        public void swim(){
            System.out.println("All duck can swim");
        }
        //鸭子的飞行动作分为三种,一种是one one one , 一种是two two two（简单模拟），一种不会飞行的
        public void fly(){
            System.out.println("i can fly by one one one");
        }
        //所有鸭子的外观都是不一样的，所以需要子类实现
        public abstract void display();
    }
    //我们写一个大白鸭子，会飞行
    class WhiteDuck extends Duck{
        //飞行行为是two two two ，所以重写父类方法
        @Override
        public void fly() {
            System.out.println("i can fly by two two two");
        }
        //外观是白色的，重写方法
        @Override
        public void display() {
            System.out.println("i am a white duck");
        }
    }
     //不会飞行的白鸭子
    class NoFly extends Duck{
        //不会飞行的鸭子fly（）空实现
        @Override
        public void fly() {
        }
        //外观是白色的，重写方法
        @Override
        public void display() {
            System.out.println("i am a white duck");
        }
    }
}

注意 ， fly()和display()方法是不一样的，所有鸭子的fly()行为只有三种，一种是one one one , 一种是two two two，最后是不会飞的，但是每个鸭子的display()方法是不同的。下面的改进都是基于这个假设案例

看起来我们解决了这个问题，但是在软件开发过程中，唯一不变的就是CHANGE，后来需要加上100多个不同的鸭子种类，我们需要重写100个不同的鸭子类中的fly()和display()方法嘛，这看起来不oop，所有我们要换种方法来进行设计。

2.使用接口

public class Demotwo {
    //定义一个飞行接口，当鸭子会飞就继承这个接口
    interface FlyBehavior{
        public void fly();
    }
    abstract class Duck{
        public void Duck(){}
        //所以鸭子的游泳行为都是一致的
        public void swim(){
            System.out.println("All duck can swim");
        }
        //所有鸭子的外观都是不一样的
        public abstract void display();
    }
    //有飞行行为，继承了飞行动作
    class WhiteDuck extends Duck implements FlyBehavior{
        @Override
        public void display() {
            System.out.println("i am a white duck");
        }
        @Override
        public void fly() {
            System.out.println("i can fly by two two two");
        }
    }
    //不会飞行，不用继承动作
    class NoGreenFlyDuck extends Duck{
        @Override
        public void display() {
            System.out.println("i am a Green duck");
        }
    }
}

这个设计和上面的使用继承的改进之处
- 在于对于不会飞行的鸭子不用重写为空方法了
缺点
- 但是代码屯余还是很多，要写好多重复的飞行行为
- 当FlyBehavior接口改变时，所有继承FlyBehavior接口的类都要变化，这个是很可怕的

3.策略模式

在代码之前先介绍几个感念

策略模式，定义算法族，分别封装起来，让他们之间可以相互替换，此设计模式让算法的变化独立与使用算法的客户；通俗的说话就是，准备一组算法，并将每一个算法封装起来，使得它们可以互换
封装变化设计原则，找到应用中所以可能需要变化的部分，把他们独立出来，不要和那些不需要变化的代码混在一起
针对接口编程设计原则，针对接口编程，而不是针对实现编程
多用组合，少用继承设计原则

//FlyBehavior.java
public interface FlyBehavior {
    public void fly();
}
//FlyNo.java
public class FlyNo implements FlyBehavior {
    @Override
    public void fly() {
    }
}
//FlyOne.java
public class FlyOne implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("i can fly by one one one");
    }
}
//FlyTwo.java
public class FlyTwo implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("i can fly by two two two");
    }
}
//Duck.java
public abstract class Duck {
    FlyBehavior mFlyBehavior;
    public Duck() {
    }
    //每个鸭子子类的外观都不一样，只能让子类自己去实现
    public abstract void display();
    //公共行为
    public void swim(){
        System.out.println("All duck can swim");
    }
    //直接使用接口的方法，针对接口编程
    public void fly(){
       if(mFlyBehavior != null){
           mFlyBehavior.fly();
       }
    }
    //通过该setter方法设置不同的飞行实现类，改变不同的飞行行为
    public void setmFlyBehavior(FlyBehavior mFlyBehavior) {
        this.mFlyBehavior = mFlyBehavior;
    }
}
//测试Main.java    
public class Main {
    //现在鸭子子类只需要从重写外观方法，因为每个鸭子外观不同
    static class FlyWhiteDuck extends Duck{
        @Override
        public void display() {
            System.out.println("i am a white duck");
        }
    }
    public static void main(String[] args) {
        Duck flyOneWhiteDuck = new FlyWhiteDuck();
        //fly()行为通过设置接口的实现类改变
        flyOneWhiteDuck.setmFlyBehavior(new FlyOne());
        flyOneWhiteDuck.fly();
        flyOneWhiteDuck.setmFlyBehavior(new FlyTwo());
        flyOneWhiteDuck.fly();
        flyOneWhiteDuck.setmFlyBehavior(new FlyNo());
        flyOneWhiteDuck.fly();
    }
}

测试结果发现可以改变fly()行为

i can fly by one one one
i can fly by two two two
//我们写的是空实现，所以唯为null
Process finished with exit code 0

总结

针对一个类中的不同行为，可以分为三种
- 所有子类都相同的，直接在父类实现，上述的swim()方法
- 所有子类都不同的，直接写成抽象方法，每个子类自己实现，上述display()方法
- 所有子类只有少数几种选择，针对接口使用策略模式，上述的fly()方法