精华内容
下载资源
问答
  • 耦合度就是某模块(类)与其它模块(类)之间的关联、感知和依赖的程度,是衡量代码独立性的一个指标,也是软件工程设计及编码质量评价的一个标准
  • C# 低耦合高质量迷宫

    2019-01-18 19:24:49
    整合传统三种迷宫,加以调优,
  • 一个低耦合、可重用的WEB应用平台设计与实现,陈国富,邓芳,WEB应用开发过程中,一些类似的功能模块经常重复出现,传统方式使用大量拷贝的方式来实现代码的复用。这样,系统出现了大量的重复
  • 随着项目的不断更新迭代,应用的架构也...通过设计使程序模块化,做到模块内部的高聚合和模块之间的低耦合。这样做的好处是使得程序在开发的过程中,开发人员只需要专注于一点,提高程序开发的效率,便于项目的后期维护
  • 高内聚低耦合详解

    2021-02-25 17:43:59
    内聚关注模块内部的元素结合程度,耦合关注模块之间的依赖程度。 内聚性: 又称块内联系。指模块的功能强度的度量,即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素(语名之间、程序段之间)...

    概念

    内聚关注模块内部的元素结合程度,耦合关注模块之间的依赖程度。
    内聚性:
    又称块内联系。指模块的功能强度的度量,即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素(语名之间、程序段之间)联系的越紧密,则它的内聚性就越高。
    所谓高内聚是指一个软件模块是由相关性很强的代码组成,只负责一项任务,也就是常说的单一责任原则。
    耦合性:
    也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密,其耦合性就越强,模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。
    对于低耦合,粗浅的理解是:一个完整的系统,模块与模块之间,尽可能的使其独立存在。也就是说,让每个模块,尽可能的独立完成某个特定的子功能。模块与模块之间的接口,尽量的少而简单。如果某两个模块间的关系比较复杂的话,最好首先考虑进一步的模块划分。这样有利于修改和组合。

    内聚

    内聚有如下的种类,它们之间的内聚度由弱到强排列如下:
    一、偶然内聚:一个模块内的各处理元素之间没有任何联系,只是偶然地被凑到一起。这种模块也称为巧合内聚,内聚程度最低。
    二、逻辑内聚:这种模块把几种相关的功能组合在一起, 每次被调用时,由传送给模块参数来确定该模块应完成哪一种功能 。
    三、时间内聚:把需要同时执行的动作组合在一起形成的模块称为时间内聚模块。
    四、过程内聚:构件或者操作的组合方式是,允许在调用前面的构件或操作之后,马上调用后面的构件或操作,即使两者之间没有数据进行传递。简单的说就是如果一个模块内的处理元素是相关的,而且必须以特定次序执行则称为过程内聚。
    例如某要完成登录的功能,前一个功能判断网络状态,后一个执行登录操作,显然是按照特定次序执行的。
    五、通信内聚:指模块内所有处理元素都在同一个数据结构上操作或所有处理功能都通过公用数据而发生关联(有时称之为信息内聚)。即指模块内各个组成部分都使用相同的数据结构或产生相同的数据结构。
    六、顺序内聚:一个模块中各个处理元素和同一个功能密切相关,而且这些处理必须顺序执行,通常前一个处理元素的输出时后一个处理元素的输入。
    例如某要完成获取订单信息的功能,前一个功能获取用户信息,后一个执行计算均价操作,显然该模块内两部分紧密关联。
    顺序内聚的内聚度比较高,但缺点是不如功能内聚易于维护。
    七、功能内聚:模块内所有元素的各个组成部分全部都为完成同一个功能而存在,共同完成一个单一的功能,模块已不可再分。即模块仅包括为完成某个功能所必须的所有成分,这些成分紧密联系、缺一不可。
    功能内聚是最强的内聚,其优点是它的功能明确。判断一个模块是否功能内聚,一般从模块名称就能看出。如果模块名称只有一个动词和一个特定的目标(单数名词),一般来说就是功能内聚,如:“计算水费”、“计算产值”等模块。功能内聚一般出现在软件结构图的较低层次上。
    功能内聚模块的一个重要特点是:他是一个“暗盒”,对于该模块的调用者来说,只需要知道这个模块能做什么,而不需要知道这个模块是如何做的。

    耦合

    耦合可以分为以下几种,它们之间的耦合度由高到低排列如下:
    一、 内容耦合:一个模块直接访问另一模块的内容,则称这两个模块为内容耦合。
    若在程序中出现下列情况之一,则说明两个模块之间发生了内容耦合:

    1. 一个模块直接访问另一个模块的内部数据。
    2. 一个模块不通过正常入口而直接转入到另一个模块的内部。
    3. 两个模块有一部分代码重叠(该部分代码具有一定的独立功能)。
    4. 一个模块有多个入口。
      内容耦合可能在汇编语言中出现。大多数高级语言都已设计成不允许出现内容耦合。这种耦合的耦合性最强,模块独立性最弱。

    二、公共耦合:一组模块都访问同一个全局数据结构,则称之为公共耦合。公共数据环境可以是全局数据结构、共享的通信区、内存的公共覆盖区等。如果模块只是向公共数据环境输入数据,或是只从公共数据环境取出数据,这属于比较松散的公共耦合;如果模块既向公共数据环境输入数据又从公共数据环境取出数据,这属于较紧密的公共耦合。
    公共耦合会引起以下问题:

    1. 无法控制各个模块对公共数据的存取,严重影响了软件模块的可靠性和适应性。
    2. 使软件的可维护性变差。若一个模块修改了公共数据,则会影响相关模块。
    3. 降低了软件的可理解性。不容易清楚知道哪些数据被哪些模块所共享,排错困难。
      一般地,仅当模块间共享的数据很多且通过参数传递很不方便时,才使用公共耦合。

    三、外部耦合:一组模块都访问同一全局简单变量,而且不通过参数表传递该全局变量的信息,则称之为外部耦合。
    四、控制耦合:模块之间传递的不是数据信息,而是控制信息例如标志、开关量等,一个模块控制了另一个模块的功能。
    五、标记耦合:调用模块和被调用模块之间传递数据结构而不是简单数据,同时也称作特征耦合。表就和的模块间传递的不是简单变量,而是像高级语言中的数据名、记录名和文件名等数据结果,这些名字即为标记,其实传递的是地址。
    六、数据耦合:调用模块和被调用模块之间只传递简单的数据项参数。相当于高级语言中的值传递。
    七、非直接耦合:两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实现的。耦合度最弱,模块独立性最强。

    分析

    高内聚,低耦合的系统有什么好处呢?
    事实上,短期来看,并没有很明显的好处,甚至短期内会影响系统的开发进度,因为高内聚,低耦合的系统对开发设计人员提出了更高的要求。高内聚,低耦合的好处体现在系统持续发展的过程中,高内聚,低耦合的系统具有更好的重用性,维护性,扩展性,可以更高效的完成系统的维护开发,持续的支持业务的发展,而不会成为业务发展的障碍。
    高内聚低耦合是否意味着内聚越高越好,耦合越低越好?
    并不是内聚越高越好,耦合越低越好,真正好的设计是在高内聚和低耦合间进行平衡,也就是说高内聚和低耦合是冲突的。
    最强的内聚莫过于一个类只写一个函数,这样内聚性绝对是最高的。但这会带来一个
    明显的问题:类的数量急剧增多,这样就导致了其它类的耦合特别多,于是整个设计就变成了“高内聚高耦合”了。由于高耦合,整个系统变动同样非常频繁。
    对于耦合来说,最弱的耦合是一个类将所有的函数都包含了,这样类完全不依赖其它类,耦合性是最低的。但这样会带来一个明显的问题:内聚性很低,于是整个设计就变成了“低耦合低内聚”了。由于低内聚,整个类的变动同样非常频繁。
    真正做到高内聚、低耦合是很难的,很多时候未必一定要这样,更多的时候“最适合”的才是最好的,不过、审时度势、融会贯通、人尽其才、物尽其用,才是设计的王道。
    软件设计时,如何做好高内聚低耦合?
    在模块划分时,要遵循“一个模块,一个功能”的原则,尽可能使模块达到功能内聚。
    耦合是影响软件复杂程度和设计质量的一个重要因素,为提高模块的独立性,应建立模块间尽可能松散的系统,在设计上我们应采用以下原则:若模块间必须存在耦合,应尽量使用数据耦合,少用控制耦合,慎用或有控制地使用公共耦合,并限制公共耦合的范围,尽量避免内容耦合。

    展开全文
  • 高内聚低耦合

    2012-08-01 16:44:00
    该文档主要讲解了高内聚低耦合的相关知识,希望能给你带来帮助!
  • 摘要:做好高内聚低耦合,思路也很简单:定职责、做归类、划边界。 下面的这个场景你可能会觉得很熟悉(Z哥我又要出演了): Z哥:@All 兄弟姐妹们,这次我这边有个需求需要给「商品上架」增加一道审核,会影响到...
    摘要:做好高内聚低耦合,思路也很简单:定职责、做归类、划边界。

    下面的这个场景你可能会觉得很熟悉(Z哥我又要出演了):

    Z哥:@All 兄弟姐妹们,这次我这边有个需求需要给「商品上架」增加一道审核,会影响到大家和我交互的接口。大家抽空配合改一下,明天一起更新个版本。

    小Y:哥,我这几天很忙啊,昨天刚配合老王改过促销!

    小X:行~当一切已成习惯。

    作为被通知人,如果在你的现实工作中也发生了类似事件,我相信哪怕嘴上不说,心里也会有不少想法和抱怨:“md,改的是你,我也要发布,好冤啊!”。

    这个问题的根本原因就是多个项目之间的耦合度过于严重。

    越大型的项目越容易陷入到这个昭潭中,难以自拔。

    而解决问题的方式就是进行更合理的分层,并且持续保证分层的合理性。

    一提到分层,必然离不开6个字「高内聚」和「低耦合」。

    什么是高内聚低耦合

    在z哥之前的文章中有多次提到,分布式系统的本质就是「分治」和「冗余」

    其中,分治就是“分解 -> 治理 -> 归并”的三部曲。「高内聚」、「低耦合」的概念就来源于此。

    需要注意的是,当你在做「分解」这个操作的时候,务必要关注每一次的「分解」是否满足一个最重要的条件:不同分支上的子问题,不能相互依赖,需要各自独立

    因为一旦包含了依赖关系,子问题和父问题之间就失去了可以被「归并」的意义。

    比如,一个「问题Z」被分解成了两个子问题,「子问题A」和「子问题B」。但是,解问题A依赖于问题B的答案,解问题B又依赖于问题A的答案。这不就等于没有分解吗?

    题外话:这里的“如何更合理的分解问题”这个思路也可以用到你的生活和工作中的任何问题上。

    所以,当你在做「分解」的时候,需要有一些很好的着力点去切入。

    这个着力点就是前面提到的「耦合度」和「内聚度」,两者是一个此消彼长的关系。

    越符合高内聚低耦合这个标准,程序的维护成本就越低。为什么呢?因为依赖越小,各自的变更对其他关联方的影响就越小。

    所以,「高内聚」和「低耦合」是我们应当持续不断追求的目标。

    题外话:耦合度,指的是软件模块之间相互依赖的程度。比如,每次调用方法 A 之后都需要同步调用方法 B,那么此时方法 A 和 B 间的耦合度是高的。

    内聚度,指的是模块内的元素具有的共同点的相似程度。比如,一个类中的多个方法有很多的共同之处,都是做支付相关的处理,那么这个类的内聚度是高的。

    怎么做好高内聚低耦合

    做好高内聚低耦合,思路也很简单:定职责、做归类、划边界

    首先,定职责就是定义每一个子系统、每一个模块、甚至每一个class和每一个function的职责。

    比如,在子系统或者模块层面可以这样。

    又比如,在class或者function层面可以这样。

    我想这点大家平时都会有意识的去做。

    做好了职责定义后,内聚性就会有很大的提升,同时也提高了代码/程序的复用程度。

    至此,我们才谈得上「单一职责(SRP)」这种设计原则的运用。

    其次,做归类。梳理不同模块之间的依赖关系。

    像上面提到的案例1可以归类为3层:

    1. 基础层:商品基础服务、会员基础服务、促销基础服务
    2. 聚合层:购物车服务、商品详情服务、登陆服务
    3. 接入层:快闪店API、综合商城API

    案例2也可以归类为3层:

    1. 数据访问层:访问会员表数据、访问会员积分表数据、访问会员等级表数据
    2. 业务逻辑层:会员登陆逻辑、会员使用积分逻辑、会员升级逻辑
    3. 应用层:接收用户输入的账户密码、接收用户输入的使用积分数、接收用户的付款信息

    最后就是划边界。好不容易梳理清楚,为了避免轻易被再次破坏,所以需要设立好合理清晰的边界。

    否则你想的是这样整齐。

    实际会慢慢变成这样混乱。

    那么应该怎么划边界呢?

    class和function级别。这个层面可以通过codereview或者静态代码检测工具来进行,可以关注的点比如:

    1.调用某些class必须通过interface而不是implement

    2.访问会员表数据的class中不能存在访问商品数据的function

    模块级别。可以选择以下方案:

    1.给每一种类型的class分配不同project,打包到各自的dll(jar)中

    2.每次代码push上来的时候检测其中的依赖是否有超出规定的依赖。例如,不能逆向依赖(检测dal是否包含bll);不能在基础层做聚合业务(检测商品基础服务是否包含其他基础服务的dll(jar))。

    系统级别。及时识别子系统之间的调用是否符合预期,可以通过接入一个调用链跟踪系统(如,zipkin)来分析请求链路是否合法。

    让边界更清晰、稳定的最佳实践

    很多时候不同的模块或者子系统会被分配到不同的小组中负责,所以z哥再分享几个最佳实践给你。它可以让系统之间的沟通更稳定。

    首先是:模块对外暴露的接口部分,数据类型的选择上尽量做到宽进严出。比如,使用long代替byte之类的数据类型;使用弱类型代替强类型等等。

    举个「宽进严出」的例子:

    //使用long代替byte之类的数据类型。
    void Add(long param1, long param2){
        if(param1 <1000&& param2 < 1000){  //先接收进来,到里面再做逻辑校验。
            //do something...
        }
        else{
            //do something...
        }
    }

    其次是:写操作接口,接收参数尽可能少;读操作接口,返回参数尽可能多

    为什么呢?因为很多时候,写操作的背后会存在一个潜在预期,是「准确」。

    准确度和可信度有着很大的联系,只有更多的逻辑处理在自己掌控范围内进行才能越具备「可信度」(当然是职责范围内的逻辑,而不是让商品服务去计算促销的逻辑)。反之,上游系统一个bug就会牵连到你的系统中。

    而读操作背后的潜在预期是:「满足」。你得提供给我满足我当前需要的数据,否则我的工作无法开展。

    但是呢,在不同时期,客户端所需要的数据可能会发生变化,你无法预测。所以呢,不要吝啬,返回参数尽可能多,用哪些,用不用是客户端的事。

    还可以做的更好的一些,就是,在可以满足的基础上支持按需获取。客户端需要返回哪些字段自己通过参数传过来,如此一来还能避免浪费资源做无用的数据传输。

    题外话:对外露出的接口设计,可以使用http + json 这种跨平台 + 弱类型的技术组合,可具备更好的灵活性。

    实际上,一个程序大多数情况下,在某些时刻是客户端,又在某些时刻是服务端。站在一个完整程序的角度来提炼参数设计的思路就是:“吃”的要少,“产出”的要多

    题外话:有一些设计原则可以扩展阅读一下。

    单一职责原则SRP(Single Responsibility Principle)

    开放封闭原则OCP(Open-Close Principle)

    里式替换原则LSP(the Liskov Substitution Principle LSP)

    依赖倒置原则DIP(the Dependency Inversion Principle DIP)

    接口分离原则ISP(the Interface Segregation Principle ISP)

    总结

    本文z哥带你梳理了一下「高内聚低耦合」的本质(来自于哪,意义是什么),并且分享了一些该怎么做的思路。

    可以看到「高内聚」、「低耦合」其实没有这个名字那么高端。哪怕你现在正在工作的项目是一个单体应用,也可以在class和function的设计中体会到「高内聚」、「低耦合」的奥妙。

    来来来,接下去马上开始在项目中「刻意练习」起来吧~

     

    点击关注,第一时间了解华为云新鲜技术~

    展开全文
  • 低耦合: 耦合就是元素与元素之间的连接,感知和依赖量度。这里说的元素即是功能,对象,系统,子系统。模块。 例如:现在有方法A和方法B 我们在A元素去调用B元素,当B元素有问题或者不存在的时候,A元素就不能...

    低耦合:
    耦合就是元素与元素之间的连接,感知和依赖量度。这里说的元素即是功能,对象,系统,子系统。模块。

    例如:现在有方法A和方法B

    我们在A元素去调用B元素,当B元素有问题或者不存在的时候,A元素就不能正常的工作,那么就说元素A和元素B耦合。

    --耦合带来的问题:
    当元素B变更或者不存在时,都将影响元素A的正常运作,影响系统的可维护性和易变更性。同时元素A只能运行在元素B中,这也大大的降低了A元素的可复用性。正因为耦合的种种弊端,我们才需要在软件设计上追求低耦合。

    --低耦合如何做:
    ①元素A不能过度依赖元素B

    ②合理的职责划分:让系统中的对象各司其职,不仅是提高内聚的要求,同时也可以有效地降低耦合

    ③使用接口而不是继承:我们不难发现。继承就是一种耦合,假如子类A继承了父类B,不论是直接继承或者间接继承,一但父类B不存在或者发生任何变更,都将导致子类A不得不修改或者重写。假如父类B的子类数十上百的,这就是灾难性的变更。

    高内聚:
    高内聚是另外一个评判软件设计质量的标准。内聚更为专业的说法叫做功能内聚,是对系统中元素职责的相关性和集中度的量度。如果元素有高度的相关职责,除了这些职责在没有其他的工作,那么该元素就有高内聚。

    例如:这就好像,如果我是一个项目经理,我的职责是监控和协调我的项目各个阶段的工作。当我的项目进入需求分析阶段,我会请求需求分析员来完成;当我的项目进入开发阶段,我会请求软件开发人员来完成;当我的项目需要测试的时候,我会请求测试人员。。。如果我参与了开发,我就不是一个高内聚的元素,因为开发不是我的职责。

    --为什么要高内聚: 可读性、复用性、可维护性和易变更性。

    简单的理解高内聚低耦合:耦合和内聚的的评判标准是强度,耦合越弱越好,内聚越强越好

    --耦合指模块与模块之间的关系,最弱的耦合就是通过一个主控模快来协调n哥模块进行运作。

    例如:。还是举一个我举过的例子:客户要求在界面上增加一个字段,你的项目要修改几个地方呢?如果你只要修改项目文档,那么你的开发构架就是最低强度的耦合,而这种设计 成熟的开发团队都已经做到了,他们使用开发工具通过项目模型驱动数据库和各层次的代码,而不是直接修改那些代码;

    --内聚指的是模块内部的功能,最强的就是功能不能拆分,也就是原子化。


    再简单的说: 高内聚、低耦合讲的是程序单位协作的问题,  你可以这样理解,一个企业的管理,  最理想的情况就是各个部门各司其职,井然有序,互不干涉,  但是需要沟通交流的时候呢,  各个部门都可以找到接口人专门负责部门沟通以及对外沟通。 在软件里呢, 就是说各个模块要智能明确, 一个功能尽量由一个模块实现,  同样,一个模块最好只实行一个功能。这个是所谓的“内聚”;  模块与模块之间、系统与系统之间的交互,是不可避免的, 但是我们要尽量减少由于交互引起的单个模块无法独立使用或者无法移植的情况发生,  尽可能多的单独提供接口用于对外操作, 这个就是所谓的“低耦合”。 但是实际的设计开发过程中,总会发生这样那样的问题与情况, 真正做到高内聚、低耦合是很难的,很多时候未必一定要这样, 更多的时候“最适合”的才是最好的, 不过,理解思想,审时度势地使用, 融会贯通,灵活运用,才是设计的王道。

    展开全文
  • 用C语言编写低耦合程序

    千次阅读 2020-11-01 09:26:02
    耦合,是对模块间关联程度的度量。 模块间的耦合度是指模块之间的依赖关系,其耦合性越强,同时表明其独立性越差。   降低模块间的耦合度能减少模块间的影响,防止对某一模块修改所引起的“牵一发动全身”的水波...

    耦合的定义

      耦合,是对模块间关联程度的度量。 模块间的耦合度是指模块之间的依赖关系,其耦合性越强,同时表明其独立性越差。

    低耦合的优点

      降低模块间的耦合度能减少模块间的影响,防止对某一模块修改所引起的“牵一发动全身”的水波效应,保证系统设计顺利进行。

    实现例子

    实现两个功能:
    1、统计字符串的单词总数。
    2、统计字符串中长度大于n的个数。
    在这两个功能中,都需要将字符串中的每个单词分离单独处理。
    功能结构图

    普通的实现方式

    typedef enum _parse_words_mode_t {
      MODE_SUM = 0,  /* 模式:统计单词总数 */
      MODE_SUM_GT,   /* 模式:统计长度大于n单词数 */
    } parse_words_mode_t;
    
    int count_words(const char* str, parse_words_mode_t mode, int len) {
      int ret = 0;
      if (NULL == str || len < 0) {
        return FALSE;
      }
      bool ret = TRUE;
      for (const char* iter = str; '\0' != *iter; iter++) {
        /** 获取单词word和单词长度word_len(省略) **/
        if (MODE_SUM == mode) {
          ret++;
        } else if (MODE_SUM_GT == mode) {
           if (word_len > len) {
             ret++;
           }
        }
      }
      return ret;
    }
    
    #include <stdio.h>
    
    int main() {
      char str[64] = "Read Text, demo.kun abcdefg abcdefg";
    
      int sum_word = count_words(str, MODE_SUM, 0);
      if (sum_word >= 0) {
        printf("\nword num:%d\n", sum_word);
      } else {
        printf("\nword sum error!\n");
      }
      int gt6_word = count_words(str, MODE_SUM_GT, 6);
      if (gt6_word >= 0) {
        printf("\ngreat 6 letter : word num:%d\n", gt6_word);
      } else {
        printf("\nword sum gt error!\n");
      }
      return 0;
    }
    

      这个方法看上去好像没什么问题,但如果功能增加了十多个,那么count_words函数的选择结构就会越来越庞大,修改就会变得麻烦。

    低耦合的实现方式

      使用函数指针调用功能函数来代替使用选择结构(if else; switch case)调用函数。
      函数指针类型参数使用void*类型的ctx变量作为功能函数的上下文,即功能函数的返回值或一些参数。
      函数指针类型返回值用于判断函数执行是否成功。

    typedef int bool;
    #define TRUE 1
    #define FALSE 0
    
    /* 定义函数指针类型名 */
    typedef bool (*on_word_t)(void* ctx, const char* word, unsigned int size);
    
    /**
     * @method parse_words
     * 解析字符串中的单词
     * @param {const char*} str 需要解析单词的字符串。
     * @param {on_word_t} word_func 单词处理函数指针。
     * @param {void*} ctx 单词处理函数指针的上下文。
     *
     * @return {bool} 解析成功则返回TRUE。
     */
    bool parse_words(const char* str, on_word_t word_func, void* ctx) {
      if (NULL == str || NULL == word_func) {
        return FALSE;
      }
      bool ret = TRUE;
      for (const char* iter = str; '\0' != *iter; iter++) {
        /** 获取单词word和单词长度len(省略) **/
        ret = word_func(ctx, word, len + 1); /* 通过函数指针调用功能函数 */
      }
      return ret;
    }
    
    /* 统计单词总数 */
    static bool words_sum(void* ctx, const char* word, unsigned int size) {
      if (NULL == ctx) {
        return FALSE;
      }
      int* p_count = ctx;
      (*p_count)++;  /* 单词数+1 */
      return TRUE;
    }
    
    /**
     * @method count_word_sum
     * 计算单词总数。
     * @param {const char*} str 需要计算单词总数的字符串。
     *
     * @return {int} 单词总数(若计算的字符串为空指针,返回值为-1)。
     */
    int count_words_sum(const char* str) {
      int ret = 0;
      return (TRUE == parse_words(str, words_sum, &ret)) ? ret : -1;
    }
    
    /* 统计长度大于n的单词数 */
    /* count_word_sum_gt()函数内部使用的相关参数 */
    typedef struct _ctx_word_sum_gt {
      int count;  /* 单词数 */
      const unsigned int word_len;  /* 单词长度 */
    } ctx_word_sum_gt;
    
    static bool words_sum_gt(void* ctx, const char* word, unsigned int size) {
      if (NULL == ctx) {
        return FALSE;
      }
      ctx_word_sum_gt* sum_gt_ctx = ctx;
      if ((size - 1) > sum_gt_ctx->word_len) {  /* 长度是否大于word_len */
        sum_gt_ctx->count++;  /* 单词数+1 */
      }
      return TRUE;
    }
    
    /**
     * @method count_word_sum_gt
     * 计算单词长度大于word_len的数量。(word_len为0时为单词总数)
     * @param {const char*} str 需要计算单词数量的字符串。
     * @param {int} word_len 单词长度。
     *
     * @return {int} 单词数量(若计算的字符串为空指针或单词长度小于0,返回值为-1)。
     */
    int count_words_sum_gt(const char* str, int word_len) {
      if (word_len < 0) {
        return -1;
      }
      ctx_word_sum_gt ret = {
        .count = 0,
        .word_len = word_len,
      };
      return (TRUE == parse_words(str, words_sum_gt, &ret)) ? ret.count : -1;
    }
    
    #include <stdio.h>
    
    int main() {
      char str[64] = "Read Text, demo.kun abcdefg abcdefg";
    
      int sum_word = count_word_sum(str);
      if (sum_word >= 0) {
        printf("\nword num:%d\n", sum_word);
      } else {
        printf("\nword sum error!\n");
      }
      int gt6_word = count_word_sum_gt(str, 6);
      if (gt6_word >= 0) {
        printf("\ngreat 6 letter : word num:%d\n", gt6_word);
      } else {
        printf("\nword sum gt error!\n");
      }
      return 0;
    }
    

      使用低耦合的实现方式将不变的代码和易变的代码隔离,在添加新功能时,无需再改动原有的函数,更加安全和高效。

    展开全文
  • 什么是高内聚低耦合

    千次阅读 2019-09-04 10:05:36
    低耦合: 耦合就是元素与元素之间的连接,感知和依赖量度。这里说的元素即是功能,对象,系统,子系统。模块。 例如:现在有方法A和方法B 我们在A元素去调用B元素,当B元素有问题或者不存在的时候,A元素就不能...
  • 什么是高耦合低内聚,低耦合高内聚 耦合:不就是耦合系数高与低吗,就是关联性强不强 内聚:内聚是指是不是具有很强的功能性,一个模块或方法是不是只干一件事。 用面向对象举例: 一个对象中有很多方法,每个 ...
  • 高内聚与低耦合

    2018-08-20 14:53:56
    这是一个简单的低耦合的设计,电器与插座之间是低耦合的关系,就算我替换了不同的插座,电器依然可以正常的工作。因此简单的描述如下,就是A模块与B模块存在依赖关系,那么当B发生改变时,A模块仍然可以正常工作,...
  • Java编程思想之高内聚低耦合

    千次阅读 2020-05-18 22:56:16
    文章目录1 前言2 低耦合耦合性定义耦合性分类3 高内聚高内聚定义耦合性分类4 示例5 总结 1 前言 编程的时候,经常要使得系统高内聚、低耦合,那么,我们口中的这些概念到底是什么?什么是高内聚低耦合呢? 2 低耦合 ...
  • 耦合和解耦的理解 vue高耦合和低耦合的理解耦合解耦低耦合高耦合 耦合 耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 在软件工程中,对象之间的耦合度就是对象之间...
  • 低耦合高内聚 原则的应用

    千次阅读 2017-08-25 23:59:53
    这次主要是分享对软件设计中的“低耦合、高内聚”原则的一些个人体会,通过lorawan代码等实例分析,让大家对这个设计思想有更具象的理解。
  • 彻底弄懂高内聚与低耦合

    千次阅读 2019-05-20 14:58:28
    作者:大道方圆 ... 源码分享:Javaweb练手项目下载 ...耦合主要描述模块之间的关系, 内聚主要描述模块内部。 模块的粒度可大可小, 可以是函数, 类, 功能块等等。 耦合 模块之间存在依赖, 导致改动可能会互相...
  • Java 高内聚,低耦合

    2020-07-19 16:36:43
    一、定义 1. 内聚 1.1. 内聚,一个模块内各元素间,结合的紧密程度。 2. 耦合 2.1. 耦合,各个代码块间联系紧密程度的度量(模块之间联系越紧密,其耦合性就越强,模块的独立性则越差。模块间耦合的高低取决于...4.
  • 从踏入编程世界开始,无论是在学习理论知识的课本上,还是在进行项目过程中,我们经常听到大家一次次的念叨“代码模块尽量做到低耦合、高内聚“”,那么什么是耦合?怎样做到低耦合?怎么进行解耦合实现低耦合,下面...
  • 最简单理解高内聚低耦合

    千次阅读 2019-09-07 08:49:15
    低耦合: 耦合就是元素与元素之间的连接,感知和依赖量度。这里说的元素即是功能,对象,系统,子系统。模块。 例如:现在有方法A和方法B 我们在A元素去调用B元素,当B元素有问题或者不存在的时候,A元素就不能正常...
  • 面向对象原则:高内聚、低耦合。多聚合、少继承

    万次阅读 多人点赞 2017-12-18 19:28:38
    面向对象原则:高内聚、低耦合。多聚合、少继承要点概括【高内聚、低耦合】 内聚:每个模块尽可能独立完成自己的功能,不依赖于模块外部的代码。 耦合:模块与模块之间接口的复杂程度,模块之间联系越复杂耦合度越...
  • 一旦你理解了它,你编写概要设计的时候设计类或者模块自然会考虑到“高内聚,低耦合”。 高内聚是指一个软件模块是由相关性很强的代码组成,只负责一项任务,也就是常说的单一责任原则。低耦合是指让每个模块尽可能...
  • 前言:emmm最近都在赶进度,已经好久没输出了,接下来都使用MakeDown文档写文,推荐大家使用VsCode编译工具,加入Markdown Preview Enhanced插件,创建一个MD文件,...耦合性 定义 1/块间联系 2/模块间依赖程...
  • 相信平时在开发中(代码重构,或者软件设计过程中),经常会听到要遵循高内聚,低耦合的原则,那么什么时候高内聚,低耦合呢? 2.什么是高内聚? 我们常说的高内聚,一般都是功能内聚,高内聚是指一个软件模块是由...
  • UniAdmin是一套渐进式模块化开源后台,采用前后端分离技术,数据交互采用json格式,功能低耦合高内聚;核心模块支持系统设置、权限管理、用户管理、菜单管理、API管理等功能,后期上线模块商城将打造类似composer、...
  • 浅谈高内聚低耦合

    万次阅读 多人点赞 2017-06-15 13:18:01
    高内聚低耦合,是软件工程中的概念,是判断设计好坏的标准,主要是面向对象的设计,看类的内聚性是否高,耦合度是否低
  • 如何实现代码的高内聚低耦合

    千次阅读 2020-01-25 14:24:26
    之前在参加宋宝华老师的培训时,宋老师经常说写代码要做到高内聚低耦合,当时并不太理解其意义,只是感觉这句话是正确的,但是不知道具体如何操作,后来代码写的看的多了,才初窥门径,下面就是自己的一点经验总结。...
  • 低耦合,高内聚的详解(绝对全面)

    千次阅读 多人点赞 2018-03-17 17:01:48
    转载请注意出处:这几天又回顾了下java基础,突然看见松耦合这个字眼,很是疑惑,于是通过上网阅读多篇博客并结合翻阅的资料写下了这篇博客。希望大家可以从中有所收获。一、耦合,内聚的了解(看懂就行,不用强背)...
  • 高内聚低耦合,是软件工程中的概念,是判断软件设计好坏的标准,主要用于程序的面向对象的设计,主要看类的内聚性是否高,耦合度是否低。目的是使程序模块的可重用性、移植性大大增强。通常程序结构中各模块的内聚...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 194,842
精华内容 77,936
关键字:

低耦合