#yyds干货盘点#设计模式之策略模式

Posted 2021-11-21 汤圆学Java

作者：汤圆

个人博客：javalover.cc

策略模式

解决办法：

传统方式：

• 具体实现：

  • 先定义父类Duck，然后分别定义子类姜母鸭、玩具鸭、唐老鸭
  • 当要增加姜公鸭时，再新建一个子类姜公鸭去继承父类，然后再分别实现对应的行为
  • 尽管姜公鸭和姜母鸭很多行为类似，但是这里却利用不上（即复用），能利用上的只是Ctrl+C/V

• 存在的问题：

  • 子类越多，行为就越混乱，无法清楚的知道所有鸭子的行为（因为父类定义了许多抽象方法，不管子类需不需要这个方法）
  • 无法动态改变鸭子的行为，因为行为都和具体的对象绑定在一起（也可以实现，就是代码会变得更多）
  • 比如：因为姜公鸭和姜母鸭类似，所以后来扩展的姜公鸭相当于重新复制了一份姜母鸭，以后如果要修改姜母鸭和姜公鸭的某个共同行为，则需要同时修改两处

策略模式：

• 具体实现：

  • 定义一个策略接口类，然后实现多个对应的策略类，将变化的部分（比如飞翔技术）存放到这些策略实现类
  • 然后不变的部分不去动它（比如游泳swim())，然后Duck父类通过组合策略类来完成对应的行为
  • 具体的策略实现类可以在子类的构造器中，也可以在父类的setter方法中（通过setter可以动态修改策略的实现类，从而修改子类的行为）

• 优点：

  • 行为清晰，清楚的知道所有鸭子的行为（通过判断鸭子的策略类）

  • 可以动态改变鸭子的行为，通过Duck的setter方法实现

  • 可扩展性

    • 对象的横向扩展，比如现在是Duck类，还可以有E类；因为策略类是独立于鸭子类的，所以如果再来一个天鹅类，也是可以组合策略类来实现相应的行为的
    • 对象的纵向扩展，比如新增加的姜公鸭，可以很方便的通过添加构造函数实现相应的行为
    • 行为的扩展，比如现在是Fly行为，那还可以扩展Quack行为等

UML图

传统方式

策略模式

代码

传统方式：

package pattern.strategy.strategy1;
​
public class StrategyDemo1 {
    public static void main(String[] args) {
        Duck duck = new DuckJiangMu();
        duck.fly();
        duck = new DuckTangLao();
        duck.fly();
        duck = new DuckToy();
        duck.fly();
    }
}
abstract class Duck{
    public String name;
    public void swim(){
        System.out.println("我们都会水");
    };
    abstract public void fly();
}
class DuckJiangMu extends Duck {
    public DuckJiangMu(){
        this.name = "姜母鸭";
    }
    public void fly(){
        System.out.println(this.name + " 飞的一般");
    }
}
class DuckTangLao extends Duck {
    public DuckTangLao(){
        this.name = "唐老鸭";
    }
    public void fly(){
        System.out.println(this.name + " 飞的很高");
    }
}
class DuckToy extends Duck {
    public DuckToy(){
        this.name = "玩具鸭";
    }
    public void fly(){
        System.out.println(this.name + " 不会飞");
    }
}

策略模式：

package pattern.strategy.strategy2;
​
public class StrategyDemo2 {
    public static void main(String[] args) {
        Duck duck = new DuckJiangMu();
        duck.runFly();
        // 这里可以动态修改姜母鸭的行为
        duck.setStrategyFly(new StrategyFlyNo());
        duck.runFly();
    }
}
interface StrategyFly{
    public void fly();
}
class StrategyFlyHigh implements StrategyFly{
​
    @Override
    public void fly() {
        System.out.println("飞的高");
    }
}
class StrategyFlyLow implements StrategyFly{
​
    @Override
    public void fly() {
        System.out.println("飞的低");
    }
}
class StrategyFlyNo implements StrategyFly{
​
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}
​
abstract class Duck{
    public StrategyFly strategyFly;
    public String name;
​
    public void swim(){
        System.out.println("我们都会水");
    };
    public void runFly(){
        System.out.println(this.name);
        strategyFly.fly();
    }
    public void setStrategyFly(StrategyFly strategyFly){
        this.strategyFly = strategyFly;
    }
}
​
class DuckJiangMu extends Duck{
    public DuckJiangMu(){
        this.strategyFly = new StrategyFlyLow();
        this.name = "姜母鸭";
    }
​
}
​
class DuckTangLao extends Duck{
    public DuckTangLao(){
        this.strategyFly = new StrategyFlyHigh();
        this.name = "唐老鸭";
    }
​
}
​
class DuckToy extends Duck{
    public DuckToy(){
        this.strategyFly = new StrategyFlyNo();
        this.name = "玩具鸭";
    }
}