java策略模式

Java策略模式

定义：

定义了算法族，分别封装起来，让他们之间可以相互替换，次模式让算法的变化独立于使用算法的客户.

---

使用场景：

1、 多个对象区别在于表现行为不同，在运行时选择具体要执行的行为.
2、 需要在不同情况下使用不同的策略（算法），或者策略还可能在未来用其他方式来实现.
3、 对客户隐藏了具体策略的实现细节，彼此完全独立

---

优点:

1、 提供了一种替代继承的方法，而且还保持了继承的优点（代码复用）还比继承更加灵活（算法独立，可以任意扩展）.
2、 避免多重条件语句和转移语句，使系统更加灵活，并易于扩展.
3、 搞内聚，低耦合.

---

缺点：

1、 每个具体策略都会产生一个新的类，所以会增加系统需要维护的类的数量，可使用享元模式来减少对象的数量.
2、 策略模式必须让客户端理解这些算法的区别，并且要知道这些策略的所有实现类.

---

一般策略模式的实现

HeadFirst 鸭子设计：

---

分析：

鸭子共有属性：
FlyBehavior(飞行行为)，QuackBehavior(叫声行为)，display(长相)，swim(游泳行为).

鸭子中必相同的行为：
swim(每个鸭子都会游泳，因此这个行为是不可变的)。因此在设计鸭子超类的时候把swim行为设置成共有的，每个鸭子共有的行为.

鸭子中必变属性：
display(每个鸭子都有长相，并且每个鸭子的长相都是不一样的)。因此在设计鸭子超类的时候把display属性设计成抽象的，让每个子类去实现这个display方法.

鸭子中存在不同但不同中又存在相同的行为：
FlyBehavior，QuackBehavior。因此把两个变化的行为抽出来设计成一个接口，让每种行为实现对应的接口。在鸭子超类中通过注入的方式来注入变化的行为.

---

设计的Duck：

飞行行为：

FlyBehavior(interface):
public interface FlyBehavior {
    void fly();
}

其实现类:
FlyNoway(不会飞)
FlyWithRocket(火箭动力的鸭子)
FlyWithWing(用翅膀飞行)

叫声行为：

QuackBehavior(interface):
public interface QuackBehavior {
    void quack();
}

其实现类:
QuackNoway(不会叫)
QuackWithGG(呱呱叫)

鸭子超类:

public abstract class Duck {
    //这两个属性是鸭子的行为，并且是变化的，但又不是每个鸭子的行为都是互斥的，他们有共同的地方
    //因此用组合的方式来设置鸭子的行为，使鸭子的行为更有弹性
    FlyBehavior mFlyBehavior;
    QuackBehavior mQuackBehavior;
    public void fly(){
        mFlyBehavior.fly();
    };
    public void quack(){
        mQuackBehavior.quack();
    }
    public void setFlyBehavior(FlyBehavior mFlyBehavior) {
        this.mFlyBehavior = mFlyBehavior;
    }
    public void setQuackBehavior(QuackBehavior mQuackBehavior) {
        this.mQuackBehavior = mQuackBehavior;
    };
    //这个是每个鸭子都不同的属性，就和世界上没有两个人的DNA是一摸一样的意思，
    //因此把这个属性设置为抽象的，每个鸭子都有自己的样子，并且每个鸭子都不一样
    public abstract void display();
    //这个是所有鸭子都共有的属性
    public void swim(){
        System.out.println("所有鸭子都会游泳");
    }
}

鸭子的实现类：
RocketDuck
RubberDuck
WingDuck
其中WingDuck的实现（其他两个类的实现与WingDuck类似）:

//有翅膀的鸭子
public class WingDuck extends Duck{
    public WingDuck(){
        mFlyBehavior = new FlyWithwing();
        mQuackBehavior = new QuackWithGG();
    }
    @Override
    public void display() {
        // TODO Auto-generated method stub
        System.out.println("长有一双翅膀");
    }
}

跑程序：

public class Main {
    public static void main(String[] args) {
        Duck duck = new RocketDuck();
        duck.display();
        duck.fly();
        duck.quack();
        //突然有一天火箭被卸下来了
        duck.setFlyBehavior(new FlyNoway());
        duck.fly();
        //突然有一天鸭子的口腔溃疡说不出话了
        duck.setQuackBehavior(new QuackNoway());
        duck.quack();
    }
}

枚举策略

还是鸭子的例子：

FlyBehaviorEnum(飞行行为)：

public enum FlyBehaviorEnum {
    FLY_NOWAY{
        @Override
        public void fly() {
            System.out.println("我不会飞");
        }
    },FLY_WITH_ROCKET{
        @Override
        public void fly() {
            System.out.println("通过火箭飞行");
        }
    },FLY_WITH_WING{
        @Override
        public void fly() {
            System.out.println("用翅膀飞行");
        }
    };
    public abstract void fly();
}

QuackBehaviorEnum(叫声行为)：

public enum QuackBehaviorEnum {
    QUACK_NO_WAY{
        @Override
        public void quack() {
            System.out.println("我不会叫");
        }
    },QUACK_WITH_GG{
        @Override
        public void quack() {
            System.out.println("咕咕叫");
        }
    };
    public abstract void quack();
}

感觉瞬间少了好多个类！

在学习策略模式中到的原则:

1、 针对接口编程，而不是针对实现编程
2、 找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混合在一起
3、多用组合，少用继承