策略设计模式 Strategy Design Pattern

1. 策略设计模式初衷

减少代码冗余，降低代码之间的耦合度。同时保证代码的可维护性。
Positive:
- Often reduces long lists of conditions
- Avoid duplicate code
- Keep class changes from other class changes
- Can hide complicated/ secret code from the user
Negative:
Increased number of Objects/Classes

2. 策略实际模式应用场景

1. 当我们想要定义一组算法，而且这些算法所要表现的的内容很相似时。如果在每个父类定义该算法的普适版本，然后在子类中覆盖override该方法这样一方面增加了代码的冗余度，另一方面违背了子类方法应该相互之间不同这一设计原则。
2. 但我们想要动态改变对象的某种行为，且该行为有几种可供选择项时。

3. 具体UML图及解释

这里的Animal作为一个base class, derived class–包括Dog和Bird可以直接继承该父类，完成相应的功能，但这不是好的设计准则。因为这样引入了大量冗余代码，且违背了OOD的封装特性。

4. 一个具体的demo

package com.fqyuan.strategy;public interface Flys {    public String fly();}class FlyFast implements Flys {    @Override    public String fly() {        return "Flying fast!";    }}class FlySlow implements Flys {    @Override    public String fly() {        return "Flying slowly!";    }}class NotFly implements Flys {    @Override    public String fly() {        return "Unable to fly!";    }}package com.fqyuan.strategy;public class Animal {    private String name;    public Flys flyType;    public void setName(String name) {        this.name = name;    }    public String getName() {        return name;    }    // The super class pushes off the responsibility for flying to flyType, an    // interface instance    public String tryToFly() {        return flyType.fly();    }    // We can add the method to change the Flys type dynamically    public void setFlyType(Flys newFlyType) {        flyType = newFlyType;    }    @Override    public String toString() {        return name;    }    /*     * Bad, you don't want to add methods to the super class. You need to     * separate what is different from subclass and the super class.     */    // public void fly(){    // System.out.println("I'm flying!");    // }}package com.fqyuan.strategy;public class Dog extends Animal {    public Dog(String name) {        this.setName(name);        /*         * We set the interface polymorphically. Here we set the dog disability         * to fly.         */        flyType = new NotFly();    }    /*     * Bad! You can override the fly() method, but we're breaking the rule that     * we need to abstract what is different to the subclasses.     * 即：子类的方法尽量保持一般是和其他子类方法不同，这样可以减少代码的冗余度。     */    // public void fly() {    // System.out.println("I can't fly!");    // }}package com.fqyuan.strategy;public class Cat extends Animal {    public Cat(String name) {        setName(name);        this.flyType = new FlyFast();    }}package com.fqyuan.strategy;/* * 设计模式出现的缘由？ * 代码的可读性，可维护性，减少代码的冗余度. * 2条重要原则： * 1). 能使用composition的尽量不要用inheritance. * 2). 能使用Interface的尽量不要用具体的class. */public class StrategyDemo {    public static void main(String[] args) {        Animal dog = new Dog("Rick");        Cat cat = new Cat("Kitty");        System.out.println(dog + " " + dog.tryToFly());        System.out.println(cat + " " + cat.tryToFly());        dog.setFlyType(new FlySlow());        System.out.println(dog + " " + dog.tryToFly());    }}//Running result:Rick Unable to fly!Kitty Flying fast!Rick Flying slowly!