java项目技术方案参考 java方案设计

一，什么是策略者模式

定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法
原则：

1，把变化的代码从不变的代码中分离出来
2，针对接口编程而不是具体类，定义策略接口
3，多用组合/聚合

二，以鸭子为例子，介绍什么是策略者模式

定义一个鸭子类

public abstract class Duck {
    public void fly(){
        System.out.println("我会飞");
    }
    public void swim(){
        System.out.println("我会游泳");
    }
    public void quack(){
        System.out.println("我会叫");
    }
}

并不是所有的鸭子都会叫，飞，游泳的，而duck作为父类，其子类在继承父类时，需要继承父类的所有的方法。但是如果是一只玩具鸭呢？假设只会飞，或者不会飞，那么其他的继承过来的方法就显得多余了

public class ToyDuck extends Duck {
    @Override
    public void fly() {
        System.out.println("我只会飞");
    }

    @Override
    public void swim() {
        super.swim();
    }

    @Override
    public void quack() {
        super.quack();
    }
}

是不是发现以上代码不仅仅要重写，还有了多余的空的重写方法。因此需要就进行改进，这就可以使用到策略者模式了。就是对鸭子的飞，叫，以及游泳作具体的接口配置，然后以组合的形式将这些行为作具体的分类

如图所示，虽然不太好看。。。mspaint 画的，就是画图工具画的

接口：flyBehavior

public interface FlyBehavior {
    public void fly();
}

具体的实现类,当然在实际应用中我们不仅仅只是会不会飞，还有如飞的好不好之类的，这里就只是简单的举个例子
BadFlyBehavior

public class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("我不会飞");
    }
}

GoodFlyBehavior

public class GoodFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("我会飞");
    }
}

接口和实现类写好以后呢，就将该接口组合到Duck类中

public abstract class Duck {
    FlyBehavior flyBehavior;
    public void fly(){
        if(flyBehavior != null) {
            flyBehavior.fly();
        }
    }
    public void swim(){
        System.out.println("我会游泳");
    }
    public void quack(){
        System.out.println("我会叫");
    }
}

由于接口中已经实现了fly的方法，因此在duck类中的的 fly 方法中就完全交给接口去控制了。而且不在本身操作，交给接口，再增加更多的功能时，在接口中增加就行了，如以上的飞的好，飞的慢等，有利于代码的复用性以及代码的横向扩展。
再来看子类，子类需要做的就是在实现具体的接口了,如下。当然只是对飞进行了描述，其他的行为的思路都是一样的

public  class ToyDuck extends Duck {
    /**
     * 实现了鸭子飞的状态的具体的接口
     * 该接口用于操控鸭子飞的状态
     * 而不需要对原先的方法进行重写
     */
    public ToyDuck(){
        flyBehavior = new BadFlyBehavior();
    }
}

接下来进行测试，编写一个测试类、TestDuck.java

public class TestDuck {
    public static void main(String[] args) {
        ToyDuck toyDuck = new ToyDuck();
        toyDuck.fly();
    }
}

运行结果：

由于子类实现接口的是 BadFlyBehavior 类，因此自然就输出我不会飞了 。

当然我们也能以一样的思路去进行设计叫，游泳等，以相同的思路去理解。

策略者模式打破了以前的继承以及重写模式，高效的实现代码的复用，以及继承抽象类或者接口的全部抽象方法的复杂性。

三，注意事项和细节

1，策略模式的关键是分析项目中变化部分与不变部分
2，策略部分的核心思想是：多用聚合组合,少用继承。行为类组合，飞行为类继承
3，提现了 “对修改关闭，对扩展开放” 原则。客户端增加行为不用修改原有的代码
只需要添加一种策略即可，避免了多重转移语句（if…else…ifelse）
4，提供了可以替换继承的方法：策略模式将算法封装在独立的策略类中，使得可以
可以独立于模块去改变它，是它易于切换，理解和扩展
5，需要注意的是：没添加一个策略就得增加一个类，当策略过多时，会导致类的数目庞大