一头扎进设计模式-策略模式

定义:策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

用自己的话说：把算法封装好在类里面，通过组合的方式进行算法切换。

代码：
定义一个鸭子接口：

public abstract class Duck {
    //今天开始学习设计模式，策略模式实现鸭子的飞，叫灵活功能
    private Fly flier;
    private Shout shouter;
    public void swim(){
        System.out.println("会游泳");
    }

    public void eat(){
        System.out.println("会吃饭");
    }

    public void performFly(){
        this.getFlier().fly();
    }

    public void performShout(){
        this.getShouter().shout();
    }
    private Fly getFlier() {
        return flier;
    }

    public void setFlier(Fly flier) {
        this.flier = flier;
    }

    private Shout getShouter() {
        return shouter;
    }

    public void setShouter(Shout shouter) {
        this.shouter = shouter;
    }
}

定义一只实体鸭子：

public class DonoDuck extends Duck {
    public DonoDuck(Fly fly,Shout shout){
        this.setFlier(fly);
        this.setShouter(shout);
    }
}

开始定义策略，先定义“飞”的策略
定义一个飞的接口：

public interface Fly {
    void fly();
}

定义两种飞的方式：

public class FlyMethod1 implements Fly {
    /* （非 Javadoc）
     * @see com.jjt.strategy.Fly#fly()
     */
    @Override
    public void fly() {
        // TODO 自动生成的方法存根
        System.out.println("使用了方法一进行飞翔");

    }
}
public class FlyMethod2 implements Fly {
    /* （非 Javadoc）
     * @see com.jjt.strategy.Fly#fly()
     */
    @Override
    public void fly() {
        // TODO 自动生成的方法存根
        System.out.println("使用了方法二进行飞翔");
    }
}

定义叫的策略
定义一个“叫”的接口

public interface Shout {
    void shout();
}

定义两种叫的方法

public class ShoutMethod1 implements Shout {
    /* （非 Javadoc）
     * @see com.jjt.strategy.Shout#shout()
     */
    @Override
    public void shout() {
        // TODO 自动生成的方法存根
        System.out.println("使用了方法1进行大叫");
    }
}
public class ShoutMethod2 implements Shout {
    /* （非 Javadoc）
     * @see com.jjt.strategy.Shout#shout()
     */
    @Override
    public void shout() {
        // TODO 自动生成的方法存根
        System.out.println("使用了方法二进行大叫");
    }
}

测试：

public static void main(String[] args){
        Fly flyM1 = new FlyMethod1();
        Fly flyM2 = new FlyMethod2();
        Shout shoutM1 = new ShoutMethod1();
        Shout shoutM2 = new ShoutMethod2();

        Duck donoDuck = new DonoDuck(flyM1,shoutM1);
        donoDuck.performFly();
        donoDuck.performShout();

        donoDuck.setFlier(flyM2);
        donoDuck.setShouter(shoutM2);

        donoDuck.performFly();
        donoDuck.performShout();

    }

结果：

使用了方法一进行飞翔
使用了方法1进行大叫
使用了方法二进行飞翔
使用了方法二进行大叫