设计模式(一) - 策略模式

策略模式:
定义了算法族,分别封装起来.让它们之间可以互相替换.此模式让算法的变化独立于使用算法的客户.

小黄鸭 ~ 小木鸭 ~ 机械鸭 ~ 北京烤鸭 ~

都是鸭子的种类,有的会飞,有的不会飞,有的吱吱叫,有的呱呱叫,有的不会叫~
但是他们都是属于鸭科,都有某些相同的行为.

通过简单的代码来模拟实现各种鸭子.

首先抽象出鸭子的父类

public abstract class Duck {
    /**
     * 飞的行为
     */
    Fly fly;
    /**
     * 叫的行为
     */
    QuackBehavior quackBehavior;

    /**
     * 描述
     */
    public abstract void desc();

    public void setFly(Fly fly) {
        this.fly = fly;
    }

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

    /**
     * 通过父类代理,实现某种行为
     */
    public void showFly(){
        fly.fly();
    }

    public void showQuack(){
        quackBehavior.quack();
    }
}

有了父类就有具体的子类,我们写两个小鸭子~

public class XiaoHuangYa extends Duck {

    public XiaoHuangYa() {
        fly = new FlyWithWings();
        quackBehavior = new Quack();
    }

    @Override
    public void desc() {
        System.out.println("我是小黄鸭~ 会叫会飞 ");
    }
}

public class XiaoMuYa extends Duck {


    public XiaoMuYa() {
        fly = new FlyWithWings();
        quackBehavior = new NotQuack();
    }

    @Override
    public void desc() {
        System.out.println("我是小木鸭子~ 会飞不会叫");
    }
}

然后创建行为接口,之前说了鸭子的两个行为. 飞和叫的接口,并创建出具体的子类,来执行具体的飞行操作.

public interface Fly {

    void fly();
}

public class FlyNoWay implements Fly {
    @Override
    public void fly() {
        System.out.println(" 不会飞啊~");
    }
}

public class FlyWithWings implements Fly{
    @Override
    public void fly() {
        System.out.println(" 飞呀飞~");
    }
}

public interface QuackBehavior {

    void quack();
}

public class Quack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println(" 呱呱呱~");
    }
}

public class NotQuack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println(" 不会叫啊~");
    }
}

现在我们根据不同鸭子具有的不同的行为,让父类代理执行.

public static void main(String[] args) {
        // 创建一个小黄鸭
        Duck xiaoHuangYa = new XiaoHuangYa();
        xiaoHuangYa.desc();
        xiaoHuangYa.showFly();
        xiaoHuangYa.showQuack();
        // 创建一个小木鸭
        Duck xiaoMuYa = new XiaoMuYa();
        xiaoMuYa.desc();
        xiaoMuYa.showFly();
        xiaoMuYa.showQuack();
    }

运行结果

当然,小木鸭装了火箭的发动机之后也可以飞了,我们可以在运行后动态设置或改变它的行为

创建火箭式的飞

public class HuoJianFly implements Fly {
    @Override
    public void fly() {
        System.out.println(" 我是小火箭 ~");
    }
}

public static void main(String[] args) {
        // 创建小木鸭
        Duck xiaoMuYa = new XiaoMuYa();
        // 安装火箭发动机
        xiaoMuYa.setFly(new HuoJianFly());
        xiaoMuYa.desc();
        xiaoMuYa.showFly();
        xiaoMuYa.showQuack();
    }

执行结果

设计原则:
1.将不需要变化的行为和经常变化的行为分开,经常变化的单独维护,不要混在一起.
2.针对接口编程,而不是针对实现类编程
3.多用组合,少用继承