初识策略模式

最新推荐文章于 2022-04-27 22:10:40 发布
最新推荐文章于 2022-04-27 22:10:40 发布
阅读量172 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzw752890913/article/details/106091053
版权

从一个例子开始吧。

function Duck(type){
    this.type = type;
}
Duck.prototype.swim = function(){
    console.log("I'm swimming");
}
Duck.prototype.display = function(){
    var type = this.type;
    if(type === "mallard"){
        console.log("I'm a mallard duck");
    }else if(type === "redhead"){
        console.log("I'm a redhead duck");
    }else if(type === "rubber"){
        console.log("I'm a rubber duck");
    }else if(type === "decoy"){
        console.log("I'm a decoy duck");
    }else{
        console.log("I'm a duck");
    }
}
Duck.prototype.quack = function(){
    switch(this.type){
        case "mallard":
        case "redhead":console.log("I can quack");break;
        case "rubber":console.log("I can squeak");break;
        case "decoy":console.log("I am a mute");break;
        default:console.log("I can quack");
    }
}
Duck.prototype.fly = function(){
    switch(this.type){
        case "mallard":
        case "redhead":console.log("I'm flying");break;
        case "rubber":
        case "decoy":console.log("I cannot fly");break;
        default:console.log("I'm flying");
    }
}

//测试代码
const duck = new Duck();
duck.display();
duck.swim();
duck.quack();
duck.fly();
console.log("-----------------分割线-----------------");

const mallardDuck = new Duck("mallard");
mallardDuck.display();
mallardDuck.swim();
mallardDuck.quack();
mallardDuck.fly();
console.log("-----------------分割线-----------------");

const redheadDuck = new Duck("redhead");
redheadDuck.display();
redheadDuck.swim();
redheadDuck.quack();
redheadDuck.fly();
console.log("-----------------分割线-----------------");

const rubberDuck = new Duck("rubber");
rubberDuck.display();
rubberDuck.swim();
rubberDuck.quack();
rubberDuck.fly();
console.log("-----------------分割线-----------------");

const decoyDuck = new Duck("decoy");
decoyDuck.display();
decoyDuck.swim();
decoyDuck.quack();
decoyDuck.fly();

在这里插入图片描述

  • display()，用了if...else，除了普通鸭(Duck)之外，还有绿头鸭(mallardDuck)、红头鸭(redheadDuck)，橡皮鸭(rubberDuck)和诱饵鸭(decoyDuck)。
  • swim()还好，不论啥鸭，不怕水淹就算会游泳了，所以正享受着呢，“I’m swimming”。
  • quack()，用了个switch，活鸭能嘎嘎叫(quack)，捏着橡皮鸭(rubberDuck)能发出吱吱叫(squeak)，而诱饵鸭(decoyDuck)根本不会叫，所以时刻保持沉默(mute)。
  • fly()，也用了个 switch，橡皮鸭(rubberDuck)和诱饵鸭(decoyDuck)不是活鸭，当然不会飞。

鸭子们swim()一样，display()、quack()和fly()却各有各的表现，这其实很容易让我们想到另一种实现方式：继承。
超类拥有统一的swim()、display()、quack()和fly()，子类如果具有自己独特的表现，覆盖掉就好了。
那就试试吧。

继承

class Duck{
    display(){
        console.log("I'm a duck");
    }
    swim(){
        console.log("I'm swimming");
    }
    quack(){
        console.log("I can quack");
    }
    fly(){
        console.log("I'm flying");
    }
}

class MallardDuck extends Duck{
    display(){
        console.log("I'm a mallard duck");
    }
}
class RedHeadDuck extends Duck{
    display(){
        console.log("I'm a redhead duck");
    }
}
class RubberDuck extends Duck{
    display(){
        console.log("I'm a rubber duck");
    }
    quack(){
        console.log("I can squeak");
    }
    fly(){
        console.log("I cannot fly");
    }
}
class DecoyDuck extends Duck{
    display(){
        console.log("I'm a decoy duck");
    }
    quack(){
        console.log("I am a mute");
    }
    fly(){
        console.log("I cannot fly");
    }
}

//测试代码
const duck = new Duck();
duck.display();
duck.swim();
duck.quack();
duck.fly();
console.log("-----------------分割线-----------------");

const mallardDuck = new MallardDuck();
mallardDuck.display();
mallardDuck.swim();
mallardDuck.quack();
mallardDuck.fly();
console.log("-----------------分割线-----------------");

const redheadDuck = new RedHeadDuck();
redheadDuck.display();
redheadDuck.swim();
redheadDuck.quack();
redheadDuck.fly();
console.log("-----------------分割线-----------------");

const rubberDuck = new RubberDuck();
rubberDuck.display();
rubberDuck.swim();
rubberDuck.quack();
rubberDuck.fly();
console.log("-----------------分割线-----------------");

const decoyDuck = new DecoyDuck();
decoyDuck.display();
decoyDuck.swim();
decoyDuck.quack();
decoyDuck.fly();

在这里插入图片描述
可以看到，继承能够避免部分重复代码。嗯，继承能帮我们实现代码复用。
呀！还得知道小鸭子喜欢吃什么，那就给超类Duck添加eat()方法吧。

class Duck{
//新增eat方法
	eat(){
		console.log("I eat fish and shrimps");
	}
}

呃，绿头鸭和红头鸭喜欢吃小鱼小虾，橡皮鸭和诱饵鸭什么也不吃。所以，绿头鸭和红头鸭直接继承超类的eat()就好，橡皮鸭和诱饵鸭就得覆写超类的eat()了。

class RubberDuck extends Duck{
//覆写Duck的eat
    eat(){
        console.log("I eat nothing");
    }
}
class DecoyDuck extends Duck{
//覆写Duck的eat
    eat(){
        console.log("I eat nothing");
    }
}

如果再给超类Duck添加一个sleep()呢？哦，我们又得想了：啊，红头鸭绿头鸭会睡，但橡皮鸭和诱饵鸭不用睡。
是不是发现一点问题了？每给超类Duck添加一个行为，我们都必须考虑下子类们是不是也具备同样的行为，如果一样是最好了，如果不一样，就得一个个覆写。好在本例只有4个子类，如果有40个呢？是不是每天都可以领加班夜宵了。
所以，继承不是最好的选择。
用接口试试？试试就试试。

接口

swim()大家都有，且一样，可以称作是不变的部分。
display()大家都必须有，只是不同而已。
quack()有“嘎嘎叫”，有“吱吱叫”，还有根本不会出声的。所以quack()时有时无。
fly()，要么能飞，要么不能飞，所以fly()时有时无。
eat()，要么吃小鱼小虾，要么根本不用吃，所以eat()时有时无。
“大家必须有”的放在超类Duck中，“时有时无”的用接口。“有”的话，子类就需要去实现接口。像这样：

//TypeScript
class Duck{
    display(){
        console.log("I'm a duck");
    }
    swim(){
        console.log("I'm swimming");
    }
}
interface Flyable{
    fly();
}
interface Quackable{
    quack();
}
interface Eatable{
    eat();
}
class MallardDuck extends Duck implements Flyable,Quackable,Eatable{
    display(){
        console.log("I'm a mallard duck");
    }
    quack(){
        console.log("I can quack");
    }
    fly(){
        console.log("I can fly");
    }
    eat(){
        console.log("I eat fish and shrimps");
    }
}
class RedHeadDuck extends Duck implements Flyable,Quackable,Eatable{
    display(){
        console.log("I'm a redhead duck");
    }
    quack(){
        console.log("I can quack");
    }
    fly(){
        console.log("I can fly");
    }
    eat(){
        console.log("I eat fish and shrimps");
    }
}
class RubberDuck extends Duck implements Quackable{
    display(){
        console.log("I'm a rubber duck");
    }
    quack(){
        console.log("I can squeak");
    }
}
class DecoyDuck extends Duck{
    display(){
        console.log("I'm a decoy duck");
    }
}

在这里插入图片描述
有没有感觉代码变多了？
在这里插入图片描述
使用继承时，继承超类Duck的子类拥有了Duck的所有方法，display()、swim()、quack()和fly()，我们更关注子类要覆盖的方法：quack()和fly()。
现在，将quack()和fly()从超类Duck中剥离而成为独立接口：Quackable和Flyable，子类无法通过继承来享有这些方法，要想有，可以，实现接口Quackable和Flyable吧。此时，不但没有解决上面遇到的问题，反而失去了继承达到的代码复用的优势。
怎么办呢？记住下面的原则吧。

  • 把不变的部分和变化的部分分开，并封装变化的部分
  • 少用继承，多用组合
  • 不要针对实现编程，要针对接口编程
策略模式

为了避免意大利面条，分块放代码。

interface FlyBehavior{
    fly();
}
class FlyWithWings implements FlyBehavior{
    fly(){
        console.log("I'm flying");
    }
}
class FlyNoWay implements FlyBehavior{
    fly(){
        console.log("I cannot fly");
    }
}

interface QuackBehavior{
    quack();
}
class Quack implements QuackBehavior{
    quack(){
        console.log("I can quack");
    }
}
class Squeak implements QuackBehavior{
    quack(){
        console.log("I can squeak");
    }
}
class Mute implements QuackBehavior{
    quack(){
        console.log("I am a mute");
    }
}

abstract class Duck{
    flyBehavior:FlyBehavior;
    quackBehavior:QuackBehavior;
    constructor(f:FlyBehavior,q:QuackBehavior){
        this.flyBehavior = f;
        this.quackBehavior = q;
    }
    setFlyBehavior(f:FlyBehavior){
        this.flyBehavior = f;
    }
    setQuackBehavior(q:QuackBehavior){
        this.quackBehavior = q;
    }

    performFly(){
        this.flyBehavior.fly();
    }
    performQuack(){
        this.quackBehavior.quack();
    }

    abstract display();

    swim(){
        console.log("I'm swimming");
    }
}

class MallardDuck extends Duck{
    constructor(){
        var f:FlyBehavior = new FlyWithWings();
        var q:QuackBehavior = new Quack();
        super(f,q);
    }
    display(){
        console.log("I'm a mallard duck");
    }
}


class RedHeadDuck extends Duck{
    constructor(){
        var f:FlyBehavior = new FlyWithWings();
        var q:QuackBehavior = new Quack();
        super(f,q);
    }
    display(){
        console.log("I'm a redhead duck");
    }
}


class RubberDuck extends Duck{
    constructor(){
        var f:FlyBehavior = new FlyNoWay();
        var q:QuackBehavior = new Squeak();
        super(f,q);
    }
    display(){
        console.log("I'm a rubber duck");
    }
}


class DecoyDuck extends Duck{
    constructor(){
        var f:FlyBehavior = new FlyNoWay();
        var q:QuackBehavior = new Mute();
        super(f,q);
    }
    display(){
        console.log("I'm a decoy duck");
    }   
}

下面则是测试代码。

var mallardDuck = new MallardDuck();
mallardDuck.display();
mallardDuck.swim();
mallardDuck.performQuack();
mallardDuck.performFly();
console.log("-----------------分割线-----------------");

var redheadDuck = new RedHeadDuck();
redheadDuck.display();
redheadDuck.swim();
redheadDuck.performQuack();
redheadDuck.performFly();
console.log("-----------------分割线-----------------");

var rubberDuck = new RubberDuck();
rubberDuck.display();
rubberDuck.swim();
rubberDuck.performQuack();
rubberDuck.performFly();
console.log("-----------------分割线-----------------");

var decoyDuck = new DecoyDuck();
decoyDuck.display();
decoyDuck.swim();
decoyDuck.performQuack();
decoyDuck.performFly();

补充：举例和主要思想来自<HeadFirst设计模式>

richest_qi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
房地产投资精品实操教程（第二版）.docx
11-06
本部分主要介绍招拍挂项目破局的知识点，包括法拍项目、国企土地处置、自持物业解决渠道、案例：自持物业的凯德模式等内容。这部分内容旨在帮助投资者掌握招拍挂项目破局的技巧和策略，提高投资者的竞争力。 第四...
Head First 设计模式：（一）策略模式
ミ安之偌素
04-09 1063
设计一个名为SimUDuck的鸭子模拟游戏，游戏中会出现各种鸭子，有红头鸭，野鸭，橡皮鸭，分析这些鸭子都会叫，会游泳。 此游戏内部使用标准OO技术，设计一个鸭子超类，并让各种鸭子继承此超类。 简单的实现为： package com.lissdy; public class SimUDuck { public static void main(String[] args)
设计模式系列(二) ——策略模式
羽凌薇的博客
03-22 525
策略模式策略模式概要策略模式定义策略模式结构鸭子模型引入提出需求解决方案之——使用继承解决方案之——使用接口解决方案之——策略模式总结策略模式涉及的设计原则策略模式优缺点 策略模式概要 策略模式定义 什么是策略模式？先看下《 Head First 》一书中的定义: 从定义来看，说的过于抽象，可能会一头雾水，不明白策略模式到底是个啥东西，实际上"策略"二字古已有之，在古代中又称“计策”，“计谋”，简单点说就是指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法，说白了就是解决同一问题的不同解决办法。
Java思维导图xmind文件+导出图片
12-20
初识分布式架构与意义 如何把应用从单机扩展到分布式 大型分布式架构演进过程 分布式架构设计 主流架构模型-SOA架构和微服务架构 领域驱动设计及业务驱动规划 分布式架构的基本理论CAP、BASE以及其应用 什么...
asp.net知识库
06-18
2分法-通用存储过程分页(top max模式)版本(性能相对之前的not in版本极大提高) 分页存储过程：排序反转分页法 优化后的通用分页存储过程 sql语句 一些Select检索高级用法 SQL server 2005中新增的排序函数及应用 ...
Android开发艺术探索.任玉刚(带详细书签).pdf
01-25
4.1 初识ViewRoot和DecorView 174 4.2 理解MeasureSpec 177 4.2.1 MeasureSpec 177 4.2.2 MeasureSpec和LayoutParams的对应关系 178 4.3 View的工作流程 183 4.3.1 measure过程 183 4.3.2 layout过程 193 ...
RBAC权限模型
热门推荐
richest_qi的博客
04-27 1万+
权限 权限，是用户可以访问的资源。包括页面权限、操作权限和数据权限。 页面权限。 页面权限，即用户登录系统可以看到的页面。由菜单控制。菜单包括一级菜单、二级菜单，只有用户有一级菜单、二级菜单的权限，那么用户就可以访问页面。 操作权限。 操作权限，即页面的功能按钮，包括查看、新增、修改和删除等。比如，用户点击删除按钮时，后台会校验用户角色下的所有权限是否包含该删除权限，如果包含，则可进行下一步操作，反之，提示无权操作。 数据权限。 数据权限，即不同用户在同一页面看到的数据是不同的。比如，财务部只能看到财务部
订阅者发布者模式的简单实现
richest_qi的博客
05-04 276
以下是订阅者发布者模式的一个简单实现。 const PubSub = (function(){ const topics = {}; let id = 0; function subscribe(topic,fn){ topics[topic] = topics[topic] || []; if(typeof fn !==...
初识模块方法模式
richest_qi的博客
05-13 204
看看怎么“泡咖啡”和“泡茶”。 //泡咖啡 class Coffee{ prepareRecipe(){ this.boilWater(); this.brewCoffeeGrinds(); this.pourInCup(); this.addLemon(); } boilWater(){ console.log("boil water"); } brewCoffeeGrinds(){
单例模式
richest_qi的博客
09-01 193
const Singleton = function(){ let instance; function init(){ let word = "have a nice day"; let getWord = () => word; return { getWord } } return { getInstance:function(){ if
设计模式之动态代理
richest_qi的博客
07-19 112
Proxy Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理的超类。 接口InvocationHandler 每个代理实例都有一个关联的调用处理程序对象，比如，本例的MyInvocationHandler就是调用处理程序，该处理程序实现了接口InvocationHandler。 new newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 通过调用Proxy
设计模式之静态代理
richest_qi的博客
07-16 103
静态代理包含4种角色，分别是， 抽象角色，使用接口或抽象类实现 真实角色 代理角色，用来代理真实角色，代理真实角色后一般会做一些附加操作 客户，使用代理角色进行一些操作 静态代理的好处在于： 1）真实角色的业务变得更加纯粹，不再需要关注一些公共业务； 2）公共业务交给代理，实现了业务分工； 3）公共业务需要扩展时，只需要在代理角色中作处理，更方便。 当然，静态代理的缺点也很明显，比如需要多写类，增加了代码量。 示例1 com.jepcc.demo.Rent（抽象角色） package com.jepc
tensorflow-2.9.2-cp39-cp39-win-amd64.whl
最新发布
06-01
python爬虫案例
2023年下半年计算机等级考试-公共基础-WPS-PS.zip
06-01
2023年下半年计算机等级一级考试Photoshop考点梳理 2023年下半年计算机等级一级考试WPS office考点汇总 2023年下半年计算机二级考试公共基础知识科目考点汇总 根据实际考试情况进行的总结。
Introduction to Data Science Data With R 英文
06-01
Introduction to Data Science Data Analysis and Prediction Algorithms with R 英文原版，完整带目录，非常好的数据分析资料，有基于R的完整数据分析过程
数电实验三：74LS151逻辑功能测试、74LS153逻辑功能测试、74LS153全加器、三输入多数表决电路
06-01
数电实验三：74LS151逻辑功能测试、74LS153逻辑功能测试、74LS153全加器、三输入多数表决电路
农业机械维修记录（表式）.doc
06-01
农业机械维修记录（表式）.doc
初识 MongoDB
10-19
MongoDB是一种基于分布式文件存储的数据库，它使用C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。与传统的关系型数据库不同，MongoDB采用了文档存储的方式，可以存储各种类型的数据，包括文本、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值