码迷,mamicode.com
首页 > 其他好文 > 详细

设计模式:HelloWorld之策略模式

时间:2018-04-27 12:07:37      阅读:177      评论:0      收藏:0      [点我收藏+]

标签:根据   his   []   面向接口编程   display   变化   管理   引用   head   

一.概述

策略模式 定义了算法族,分别封装起来,让他们可以互相替换,此模式让算法的变化独立于使用算法的客户。

策略模式的三要素:

抽象策略角色: 策略类,通常由一个接口或者抽象类实现。

具体策略角色:包装了相关的算法和行为。

环境角色:持有一个策略类的引用,最终给客户端调用。

二.案例驱动

提出问题:要求做出一套模拟鸭子的游戏,游戏中会出现各种鸭子,它们一边游泳,一边呱呱叫。

分析:根据OO设计思想,无非就是使各种鸭子实现自己相应的功能即可,如鸭子游泳,鸭子呱呱叫。

解决方案1.0:设计一个接口(Duck),然后根据需要完成不同的实现,如红头鸭,绿头鸭。。。。

public interface Duck {
    public abstract void quack();
    public abstract void swim();
    public abstract void display();
}
public MallardDuck implements Duck{
    public abstract void quack(){
        System.out.println("呱呱~~");
    }
    public abstract void swim(){
        System.out.println("欢快的游泳~~");
    }
    public abstract void display(){
        System.out.println("绿头鸭~~");
    }
}
public RedHeadDuck implements Duck{
    public abstract void quack(){
        System.out.println("呱呱~~");
    }
    public abstract void swim(){
        System.out.println("欢快的游泳~~");
    }
    public abstract void display(){
        System.out.println("红头鸭~~");
    }
}

突然增加一个新的需求,要求有野鸭,除了具有这两个功能外,还会飞(fly),同时还有一种橡皮鸭,叫声时吱吱。。

此时该方案便暴露了一下缺点。。。。

缺点:牵一发而动全身,我们很难知道所有鸭子的行为,当针对有些实现需要添加新的功能时

解决方案1.1

为了更加灵活,面向接口编程。

public interface Flyable {
    public abstract void fly();
}
public interface Swimable {
    public abstract void swim();
}
public interface Quackable {
    public abstract void quack();
}
public RedHeadDuck implements Quackable implements Swimable {...}
public WildDuck implements Quackable implements Swimable implements Flyable {...}

如果有一万种鸭子,这种方式简直不敢想象,重复代码太多!

解决方案2.0

采用策咯模式解决此问题。

step1:把会变化的部分取出来,并封装起来,好让其他代码不受影响。

技术分享图片

step2:封装行为的大局观

技术分享图片

step3:代码实现

抽象策略角色

// 飞行行为
public interface FlyBehavior {
    public abstract void fly();
}
// 叫声行为
public interface QuackBehavior {
    public abstract void quack();
}

具体策略对象

// 橡皮鸭叫
public RubberDuckBehavior implements QuackBehavior {
    public abstract void quack(){
        System.out.println("吱吱~~");
    }
}
// 野鸭叫
public WildDuckBehavior implements QuackBehavior {
    public void quack(){
        System.out.println("嘎嘎~~");
    }
}
// 大黄鸭叫
public YellowDuckBehavior implements QuackBehavior {
    public void quack(){
        System.out.println("呱呱~~");
    }
}
// 不会飞
public FlyNoWay implements FlyBehavior {
    public void fly(){
        System.out.println("不会飞~~");
    }
}
// 用翅膀飞
public FlyWithWings implements FlyBehavior {
    public void fly(){
        System.out.println("用翅膀飞~~");
    }
}
// 螺旋桨飞
public FlyLikePlane implements FlyBehavior {
    public void fly(){
        System.out.println("用螺旋桨~~");
    }
}

环境角色

抽象类

public abstract class Duck {
     FlyBehavior flyBehavior;
     QuackBehavior quackBehavior;
    // 动态设定行为
    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }
    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
    public void performFly() {
        flyBehavior.fly();
    }
    public void performQuack() {
        quackBehavior.quack();
    }
    public abstract display() {}
    public void swim() {
        System.out.println("鸭子天生会游泳!");
    }
}

实现

public class WildDuck implements Duck {
     FlyBehavior flyBehavior;
     QuackBehavior quackBehavior;
    public WildDuck() {
        // 默认会飞,野鸭叫嘎嘎
        this.flyBehavior = new FlyWithWings();
        this.quackBehavior = new WildDuckBehavior();
    }
    // 动态设定行为
    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }
    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
    public void performFly() {
        flyBehavior.fly();
    }
    public void performQuack() {
        quackBehavior.quack();
    }
    public void display() {
        System.out.println("这是一只野鸭!");
    }
    public void swim() {
        System.out.println("鸭子天生会游泳!");
    }
}

需求改变:野鸭的翅膀受伤,不会飞了

    public static void main(String[] args) {
        Duck duck = new WildDuck();
        duck.setFlyBehavior(new FlyNoWay());
        duck.performFly();// 输出:不会飞~~
    }

需改改变:新增一只火箭鸭,能飞到太空,不会游泳,外形像火箭一样,叫嘎嘎

public RocketDuckFlyBehavior implements FlyBehavior {
    public  void fly(){
        System.out.println("飞到太空~~");
    }
}
public class RocketDuck implements Duck {
     FlyBehavior flyBehavior;
     QuackBehavior quackBehavior;
    public WildDuck() {
        // 默认会飞,野鸭叫嘎嘎
        this.flyBehavior = new RocketDuckFlyBehavior();
        this.quackBehavior = new WildDuckQuackBehavior();
    }
    // 动态设定行为
    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }
    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
    public void performFly() {
        flyBehavior.fly();
    }
    public void performQuack() {
        quackBehavior.quack();
    }
    public abstract display() {
        System.out.println("外形像火箭~~");
    }
    public void swim() {
        System.out.println("不会游泳");
    }
}

三.策略模式的优缺点

优点:

1.策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把代码转移到符类,从而避免重复代码 。

2.在策略模式中利用组合和委托来让环境角色拥有执行算法的能力,这也是继承的一种更轻便的替代方案。

3.提供了对开放—封闭原则的完美支持,将算法封装在独立的strategy中,使得它们易于切换,易于理解,易于扩展

4.利用组合、委托和多态等技术和思想,可以有效地避免多重条件选择语句

缺点:

 1.客户端必须知道所有的策略类,区分他们之间的区别,并自行决定使用哪一个策略类。

 2.针对每一种行为情况需要创建一个策略类,造成很多的策略类。
个人站点地址:www.mycookies.cn(适合java初学者的个人博客项目) github:https://github.com/liqianggh/blog

设计模式:HelloWorld之策略模式

标签:根据   his   []   面向接口编程   display   变化   管理   引用   head   

原文地址:https://www.cnblogs.com/liqiangchn/p/8960677.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!