-
本版专家分：23结帖率 100% -
现有class A, B, C 三个类，其中 A是管理类， 调用 B类和 C类，其中C类要到B类中的某些参数，那么如何处理才能降低A、B
、C三个类的耦合度呢？
简单的情况
class B
{
public:
B()
{
b_1 = 100;
}
vitual ~B()
{
}
private:
int b_1;
public:
int GetParam1()
{
return b_1;
}
}
class C
{
private:
int c_1；
public:
void SetParam1(int value)
{
c_1 = value;
}
}
classA
{
prviate:
B b;
C c;
public:
void Exapmpe1()
{
c.SetParam1(b.GetParam1());
}
}
复杂的情况，B类不定时的会修改 b_1 的值，而C类需要使用 实施的 b_1 的值，如何处理能够更好的降低 B、C类的耦合度呢？
-
版主本版专家分：17534
-
-
优秀版主
2016年10月优秀小版主
优秀小版主
-
-
1、接口隔离+工厂
2、通过ipc
-
本版专家分：961 -
任何解决不了的问题，都可以通过增加一个中间层的方式来解决，如果不行，那就两层
-
本版专家分：240 -
subject-observer 观察者模式
-
本版专家分：12909
-
classA
{
prviate:
B* b; //改成指针
C *c;
public:
void Exapmpe1()
{
c.SetParam1(b.GetParam1());
}
}
-
本版专家分：23
-
是的，观察者模式即可解决该问题;
-
本版专家分：23
-
是的，通过观察者模式，可以即时的更新该参数;
-
本版专家分：23
-
ipc 方式我大概知道。 请问接口隔离 + 工厂 如何理解呢？有范例么？
-
本版专家分：841
-
第一，改变直接引用成员变量的方式来操作其他类对象，使用接口调用方式
第二，将接口函数的声明和实现分在.h和.cpp中编写
-
本版专家分：10
-
https://gitee.com/giveda/giveda_gobject_cpp11
楼主，以上开源代码，供你参考，100%解耦合，使用最简单，没有之一。
-
本版专家分：419
-
- 如何降低类之间的耦合
- 最近在写人员信息管理的程序，用Java实现，第一次CC完，我就写了一个类和一个test类Tmis.java，只是实现了功能，却没有用OO的思想，代码重用几乎不可能，第二次CC完，类分为了Tmis.java,Employee.java,BasicInfo.java,DetailInfo.java,但是<em>耦合性</em>很强，如何<em>降低</em><em>耦合性</em>，是我接下去几天的任务。大家有秘籍的可要交流一下啊。下面是网上的一篇文章，
- 如何降低一个程序的耦合性
- 英文 ： coupling <em>耦合性</em>是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间接口的复杂程度、<em>调用</em>模块的方式以及哪些信息通过接口。 一般模块之间可能的连接方式有七种，构成<em>耦合性</em>的七种类型。它们之间的关系为（由弱到强） (1)非直接耦合(Nondirect coupling) 如果两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和<em>调用</em>来实现的，这就是非直接耦合。这种耦合
- JAVA中为什么接口能降低耦合性？举例子
- 因为多态的特性，父类或者接口的引用是可以接受子类对象的。 比如： interface Test{} class Test1 implements Test{} class Test2 implements Test{} 上面声明一个Test接口，两个类Test1和Test2，分别实现Test接口。 表现耦合低的意思是说，删除<em>调用</em>层与接受层无关，比如：有这样一个方法可以这样设置参数类型 void s
- 使用Spring降低类之间的耦合
- 在Spring入门的文章中提到了可以使用xml文件来对类的属性进行配置，从而不用修改源代码，而改变打招呼的方式。这在一定程度上体现了依赖注入的优越性，在本文中将讲述如何利用依赖注入特性来<em>降低</em>两个类之间的耦合，从而提高代码的质量。例子我们将沿用本博客中设计模式部分的策略模式Duck的例子，但是做了一些改动。 首先定义Duck接口： public interface Duck { public...
- 如何减少程序间的耦合度？_DI与接口
- spring 开发提倡接口编程，配合DI技术可以更好的减少层(程序)与层(程序)之间的解耦合例子说明： 任务：要求： 1.打印机依赖纸张和墨盒 2.纸张有A4和B5两种 3.墨盒有彩色和黑色2种 4.使用A4纸张和彩色墨盒打印指定内容 5.使用B5纸张和黑色墨盒打印指定内容 7.要求使用接口代码：package ...
- 简单的说一下 软件的 内聚性 和 耦合性
- 内聚性，又称块内联系。指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。内聚性是对一个模块内部各个组成元素之间相互结合的紧密程度的度量指标。模块中组成元素结合的越紧密，模块的内聚性就越高，模块的独立性也就越高。理想的内聚性要求模块的功能应明确、单一，即一个模块只做一件事情。模块的内聚性和<em>耦合性</em>是两个相互对立且又密切相关的概念。<em>耦合性</em>也叫块间联系。指软件系统结构中各模块间相互联系
- 模块之耦合性
- 概念： 耦合是模块之间的相互独立性（互相链接的紧密程度）的度量。它取决于各个模块之间接口的复杂度、<em>调用</em>模块的方式以及哪些信息通过接口，构成<em>耦合性</em>的七种类型 耦合类型 描述 定义 对修改的敏感度 可重用性 可修改性 可理解性 非直接耦合 没有直接联系，互相不依赖对方
- 程序解耦的必要性
- https://mp.weixin.qq.com/s/6pCJFrNOk4HJYlS5qu4K4A? 架构设计中，大家都不喜欢耦合，但有哪些典型的耦合是我们系统架构设计中经常出现的，又该如何优化？这里列举了6个点：IP、jar包、数据库、服务、消息、扩容。这些点，如果设计不慎，都会导致系统一些耦合，这些点基本都是大家实际遇到的痛点，今天我将跟大家分享如何用常见的方案去解除这些耦合。 ...
- C++进阶 降低文件间的编译依存关系（接口与实现解耦合）
- <em>问题</em>背景 有时候会发现仅仅改动了某个类的一点实现（仅仅是几句代码），在编译时却发现要编译整个工程！特别是工程有点大时，编译要等很久很久。。。只为修改一个<em>问题</em>，时间都浪费在等待上了。为了避免这一<em>问题</em>，其实是可以通过巧妙的设计来避开文件间的依赖。 形成依赖的主要缘由： 头文件依赖，A类依赖B类,B类依赖C类,结果只改动C类的任何一个数据成员，A,B都得重编译。C++在编译期间，编译器需要知道
- 什么是耦合？解耦合的方法有哪几种？
- 在项目的开发过程中，我们经常强调项目的代码模块尽量做到低耦合高内聚，但是什么是耦合？怎样做到低耦合？可能有很多人感到疑惑，下面我来跟大家讲解什么是耦合，怎么进行解耦合实现低耦合。一、什么是耦合？ 耦合指的就是两个类之间的联系的紧密程度，看下面这段代码： public class A{ public int i; } public class B{
- 如何编写耦合性比较低的代码
- 这里不从设计模式上去讲，只是对日常编码经常使用的方法与经验的一个总结。 本次使用的更多的是spring文件配置上来做文章
- spring的依赖注入如何降低了耦合
- 刚看spring，对依赖注入DI产生了迷惘，通过查看一些资料总结了一下，希望对此理解深入的人能再指点迷津 依赖注入：程序运行过程中，如需另一个对象协作(<em>调用</em>它的方法、访问他的属性时），无须在代码中创建被<em>调用</em>者，而是依赖于外部容器的注入 看过一些比较好的回答 1.一个人(Java实例，<em>调用</em>者)需要一把斧子(Java实例，被<em>调用</em>者) 在原始社会里，几乎没有社会分工；需要斧子的人(<em>调用</em>者)只能自
- 不知不觉提高了代码的耦合性
- 在实际开发过程中，代码的<em>耦合性</em>越低越好，因为这样各个模块之间的相互关联性会更少，在改动一个模块的时候影响到的范围也才会越小，在实际开发中没有人会想去提高代码的<em>耦合性</em>，肯定是在开始的时候把代码的<em>耦合性</em>降到最低，但是在实际开发过程中，代码的<em>耦合性</em>还是会不知不觉的上升，特别是代码量越大，越容易将代码的<em>耦合性</em>提高。比如说前面写好的一个模块， 在后面开发过程中需要增加一个新的feature， 其中有些参数如果重新写代码获得比较麻烦，因为可能写好长的代码只为一个参数，但是在以后的一些模块里面只要加
- Android开发之耦合性
- <em>耦合性</em>：在android开发过程中，主要注意的是activity间关联程度。耦合的强弱取决与activity <em>耦合性</em>：在android开发过程中，主要注意的是activity间关联程度。耦合的强弱取决与activity间意图的复杂性、<em>调用</em>的方式以及通过界面传送数据的多少。耦合度是指模块之间的依赖关系，包括控制关系、<em>调用</em>关系、数据传递关系。联系越多，其<em>耦合性</em>越强，同时表明其独立性越
- 降低代码耦合度的方法 -依赖注入
- <em>降低</em>代码耦合度的方法 -依赖注入 什么是依赖注入 为什么要使用依赖注入 Laravel中的依赖注入 什么是依赖注入 什么是依赖注入，就要先了解什么是依赖。 在面向对象语言中，A类需要引用B类中Y方法的，则称A类和B类就构成了以依赖关系，A依赖于B。在对象中也存在依赖关系，如A类的X对象依赖于B类的对象Y。 在项目的开发流程中，虽然代码这样写看起来没什么，但是到了需...
- 低耦合的重要性
- 今天调试修复一个bug时，发现一个变量在两个功能模块中起着同样的作用，又因为每次完成任务后并没重置，在初始化时，不够严谨造成的<em>问题</em>，<em>问题</em>没有多难，只是调试时候特纠结两个地方都有代码需要去看，了解，改了会不会有<em>问题</em>，比较费时，然后猛然意识到耦合的这个<em>问题</em>，确实很重要，站在巨人的肩上，之前不懂这么说的到底什么意义，然后今天突然有所发现，谨记谨记！！！ 耦合 简单地说，软件工程中对象之间的耦合度就是
- 浅谈高内聚低耦合
- 高内聚低耦合，是软件工程中的概念，是判断设计好坏的标准，主要是面向对象的设计，看类的内聚性是否高，耦合度是否低
- 不良代码展示-高耦合度代码的例子
- 原创文章，如有转载，请注明出处：http://blog.csdn.net/yihui823/article/details/6833131 前段时间，看到别人的一段代码，其实没什么逻辑，却做的丰富异常。 代码运行极其不稳定，却无从下手去改动。后来下定决心重写了。 昨晚有空，把原来不良代码抽取出来，供大家参考。 package testpj; import java.util.
- 解耦合
- 耦合是一个宽泛的概念。两个程序模块有关联就叫做耦合。 某些模块必然要关联起来才能工作，这是由业务逻辑决定的，不能否认。所以解耦并不是字面意义上的把关联拆掉，而是把模块之间的关联放松到必要的程度。一些建议： 模块只对外暴露最小限度的接口，形成最低的依赖关系。只要对外接口不变，模块内部的修改，就不得影响其他模块；删除一个模块，应当只影响有依赖关系的其他模块，而不应该影响其他无关部分；
- 提高代码质量(定义接口，降低耦合)
- 我对定义接口的理解： 面向对象的程序设计在实际编写的过程中是一种面向接口的编程。以我的理解，定义接口就好比交代任务，当一个类接入了一个接口，可以说成他接受了一项任务。在符合规范的的前提下，接任务的人们有各自完成这个任务的途径和方法，结果也会不同，但我们需要的只是这些人上交的结果，而并非这些人本身，或许有些冷淡没有一点人性，但却能有效地减少“人”与“人”之间的依赖，更好地服从于任务本身，从而整...
- 码农小汪-SPringMVC-基本的理解MVC 降低耦合性~依赖性
- 标准 MVC 模型概述MVC模型：是一种架构型的模式，本身不引入新功能，只是帮助我们将开发的结构组织的更加合理，使展示与模型分离、流程控制逻辑、业务逻辑<em>调用</em>与展示逻辑分离 Model（模型）： 数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或 JavaBean 组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据） 和 服务层（行为）。也就是模型提供了
- PHP的耦合设计模式
- 一个软件，它具有许多类，类与类之间需要互相<em>调用</em>，一旦某个类与另一个类具有紧密耦合关系的时候，这个软件的重用性就会大大<em>降低</em>。所以一个软件的重用性的高低就取决于它的耦合程度的高低。 耦合度：程序模块之间的关联、依赖程度。 在设计过程中提出：当设计这个软件的体系结构的时候，就发现了这个软件的逻辑运行部分（SimpleRouter类）和输出部分（SimpleRouterFrame类）不能很
- Java学习记录：降低耦合度
- <em>降低</em>耦合度 监听器设计
- spring框架中依赖注入的理解，目的就是为降低耦合性
- 举个例子，组件A中有类ClassA，组件B中有接口IB和其对应的实现类B1和B2。 那么，现在ClassA需要利用IB接口来做一些事情，例如： public class ClassA { public void DoSomething() { IB b = ??? b.DoWork(); } } 现在的<em>问题</em>来了，IB b = ?
- 关于MVC设计模式耦合度与解耦相关技术点总结
- 一 摘要在深入探究MVC设计模式之前,首先要弄清这样几个<em>问题</em>1.什么是MVC设计模2.为什么要使用MVC设计模3.MVC设计模存在的<em>问题</em>4.什么是<em>耦合性</em>5.如何去解耦针对这些<em>问题</em>,我们来一一分析,解释.1.什么是MVC设计模首先我们来看一下MVC设计模式的整个架构图 这个图,应该都不陌生了,现在简单的介绍下各个模块的职能.MVC－－－－－Model－View-Controller MVVM –>
- 耦合性
- 耦合表示类及其对象与其它类及其之间的相互联系。耦合强度可以通过类中对象之间传送的信息的数量和复杂程度来度量。在面向对象设计中，主要存在两种耦合，交互耦合和继承耦合。1)交互耦合交互耦合是指类之间的联系是通过消息关联实现的，这种耦合应尽量减少。一般说来，消息关联中参数不要多于<em>三个</em>，否则就应考虑简化，当然，这种限定也不是绝对的。另外，在<em>降低</em>单个消息关联的复杂性的同时，也应该简化所发送
- 减少前端代码耦合的几个方法
- 1、 避免全局耦合 这应该是比较常见的耦合。全局耦合就是几个类、模块共用了全局变量或者全局数据结构，特别是一个变量跨了几个文件 2、js/css/html的耦合 不推荐直接在js里面更改样式属性，而应该通过增删类来控制样式，这样子样式还是回归到css文件里面 3、减少重复代码 整一个的思路是这样的：出现了重复代码 -> 封装成一个函数 -> 封装成一个模块 -> 封装成一
- 减少前端代码耦合
- 网上之前看的文章，很受用啊，就分享给大家看看。什么是代码耦合？代码耦合的表现是改了一点毛发而牵动了全身，或者是想要改点东西，需要在一堆代码里面找半天。由于前端需要组织js/css/html，耦合的<em>问题</em>可能会更加明显，下面按照耦合的情况分别说明：1. 避免全局耦合这应该是比较常见的耦合。全局耦合就是几个类、模块共用了全局变量或者全局数据结构，特别是一个变量跨了几个文件。例如下面，在html里面定义了一
- 代码耦合性
- 代码耦合：一个软件结构内不同模块之间互连程度的度量(<em>耦合性</em>也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其<em>耦合性</em>就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，<em>调用</em>的方式以及传递的信息。) 软件工程规定写代码的原则是“高内聚，低耦合”。内聚是代码块间的独立性，耦合是各个代码块间的联系。 对于低耦合，粗浅的理解是：一个完整的系统，模...
- Spring中的注解如何实现降低耦合度
- （1）首先我觉得你在耦合度的<em>降低</em>上的理解有点偏差，在spring中，<em>降低</em>耦合度的关键在于将bean的依赖关系抽取出来的环节，而不在于将bean的依赖关系放在哪里的环节（配置文件？或注解？）（2）spring之ioc 1 将基于实现类的耦合变成基于接口的耦合，可以避免硬编码所造成的过度程序耦合，而接下来需要解决的<em>问题</em>就是，如何确定该接口的实现类。2 ioc控制反转，就是将某一接口的具体实现类的控制从
- 减少代码模块之间的纠葛——解耦
- 谈谈如何代码解耦
- 理解Spring IOC概念及如何降低代码耦合度
- 什么是IOC IOC(Inversion of Control) 控制反转，是spring中一个重要的特性，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。那么控制什么的的权利被反转了呢，我们知道在写代码的过程中，经常会出现两个对象之间出现依赖关系，当A对象依赖B对象时，我们通常在A对象中通过new的方式来创建它的依赖对象B，而控制反转之后，对于对象的创建权被托付给IOC容器了...
- 谈代码耦合—知乎回答（转）
- 写在前面：耦合，谁之错？业务耦合，架构耦合，代码耦合，依次产生，前者是后者的催化剂，最终结果是系统严重耦合，无法适应任何变化。本篇来源：https://www.zhihu.com/question/21386172?sort=created以前，我写代码时，我考虑模块（本文中的模块就是指单个源文件）的单向依赖关系，考虑接口的正交性和紧凑性。我觉得我在做低耦合的好设计。 然而，我发现其他程序员写的代
- Java程序设计之——代码耦合性与包的结构
- <em>问题</em>和分析： 如下，一种 常见的 包结构： |--x.y.service -------存放service接口（interface） |--x.y.service.impl -------存放service接口的实现类 这种设计，从代码结构上来说，是下层（impl层）的代码 依赖于上层（service层）的代码，这样有个好处：代码耦
- 怎样降低iOS代码耦合性
- 综述 凡是维护过中型项目的iOS工程师都应该有过类似的体验：ViewController代码繁重、功能复杂、维护困难，整个工程寥寥几个ViewController就完成了整个项目的开发。每个控制器中都囊括了所有的页面布局、委托代理、网络请求、数据库操作和核心功能，这样的代码往往<em>问题</em>重重，修改起来牵一发而动全身，着实令人头疼。 为了应对这一系列的<em>问题</em>，苹果公司的工程师给我们提供了很多选择去更好的
- MVC的高耦合问题
- JDBC主要功能在于提供了用户和底层数据的接口，相当于一个桥梁，将两者连接起来，这个接口的实现，通常采用经典的MVC三层架构模式来解决： MVC（Model、View、Controller）三层架构作为一种常用的设计模式，已经经典到了不能再经典的地步，自身的优点不明而喻，MVC三层结构都作为一个独立的单位而存在，彼此之间有依赖性较小，每个单位部分都有自己的关注点和职责……
- 接口与耦合
- 开发人员经常提到2个词，“依赖”和“耦合”。最近的工作是一个系统的重构，在这方面想得比较多，在此总结一下 一、对模块的理解 模块可以在逻辑和物理2个层面上进行划分 对于比较小的工程，可能会把所有的模块都放在一个工程里。这样的话，不同的模块仅仅是在逻辑上有区别，在物理上还是一致的，因此也就不存在由于依赖而无法编译的<em>问题</em> 对于比较大的工程，除了在逻辑上划分之外，不同的模
- Java框架与低耦合
- s1. 低耦合（Low Coupling） “低耦合”这个词相信大家已经耳熟能详，我们在看spring的书籍、MVC的数据、设计模 式的书籍，无处不提到“低耦合、高内聚”，它已经成为软件设计质量的标准之一。那么什么是低耦合？耦合就是对某元素与其它元素之间的连接、感知和依赖的量 度。这里所说的元素，即可以是功能、对象（类），也可以指系统、子系统、模块。假如一个元素A去连接元素B，或者通过自己的
- 【设计模式】外观模式降低系统耦合（一）
- 一、摘要 外观模式（Facade）是一个使用频率非常高的设计模式之一。 它通过为子系统中的一组接口提供一个一致的界面，定义一个高层接口，这个接口使得这一子系统更加容易使用。 二、外观模式概述 现在越来越多的人喜欢到外面的餐馆吃饭，不知道大家有没有留意在家里自己做饭和去外面吃有什么区别？ 如果是自己做饭就要买菜、洗菜、做菜、吃菜。而在餐馆吃饭只需要对服务员说，我要什么什么菜。正
- Spring：使用动态工厂降低耦合度
- 创建接口：public interface ISomeInterface {void doSome();}创建接口实现类：public class SomeServiceIm implements ISomeInterface {@Overridepublic void doSome() {// TODO Auto-generated method stubSystem.out.println("...
- 关于“耦合”在Java中具体指什么的问题
- 以前一直不知道“耦合”在Java中具体指的是什么，最近在看《图解设计模式》中Factory Method的时候发现了一段关于“耦合”的解释，觉得很有道理，故摘抄下来便于分享和自己日后查阅。原文： 请回忆一下，在framework包中我们并没有引入idcard包（注：frameword包是abstract类组成的框架包，idcard包是concrete类的包）。在Product类和Factory类（
- Android 程序工程的高内聚，低耦合
- https://baike.baidu.com/item/%E9%AB%98%E5%86%85%E8%81%9A%E4%BD%8E%E8%80%A6%E5%90%88/5227009?fr=aladd 原创网址
- unity3d 使用委托+事件 完成低耦合发送消息
- 最近在自学unity3d,看了网上的一些教学视频和小游戏按钮，感觉gameobject与gameobject 的消息传递，代码<em>耦合性</em>很强，因为我是开发as3的用的是面向对象的MVC思想，所以看到<em>耦合性</em>强的代码就有点强迫症去修改它，以下是用委托+事件做的一个低耦合的消息传递；不说废话，进入主题； 首先创建一个简单的场景，一个plane，放在上面的两个cube，其中一个cube（称为A）移动
- c# 解耦合
- 工厂:顾名思义即为可以以加工的形式生成类的对象。需要工厂类、加工方法、产品的模型。 工厂的作用在于解决耦合。 耦合的不良影响:通俗的讲 模块一的实现依赖于模块二，更改模块二后，模块一也得更改，那么二者就有耦合。 大型的程序必然不能出现这种情况,以本人相当匮乏的经验来看,耦合的类设计<em>降低</em>了代码的维护性。 //接口:接口是一种契约 public interface IShowM
- boost::any在降低模块之间耦合性的应用
- 在开发大型系统中，遵循这样一个原则：模块之间低耦合，模块内高内聚。比如系统中模块有界面模块和算法模块两种，一般是界面模块<em>调用</em>算法模块，这样的话界面模块依赖于算法模块。现在我要实现这样界面和算法分离，即界面模块不依赖于算法模块。除了界面模块不依赖于算法模块，我要应对的另一个挑战是算法参数是不确定的，就是说要容纳任意的参数类型。为此我找到了boost::any。boost::any的好处是它能容纳任意类型的数据。它可以很方便的进行模块间函数之间不确定参数传递。具体做法是这样的：
- 控制反转（IoC）促进了低耦合，耦合是什么意思？
- 耦合是一个宽泛的概念。两个程序模块有关联就叫做耦合。 我们知道，模块之间必然要关联起来才能工作，这是有业务逻辑决定的。所以解耦并不是字面意义上的把关联拆掉，而是把模块之间的关联放松到必要的程度。<em>降低</em>耦合度的建议： 模块只对外暴露最小限度的接口，形成最低的依赖关系。 只要对外接口不变，模块内部的修改，就不得影响其他模块。 删除一个模块，应当只影响有依赖关系的其他模块，而不是影响其他无关部分。
- 如何降低代码的耦合
- <em>降低</em>代码的耦合，通常需要暴露一个接口，提供一个回调函数。 例如短信备份时，短信备份的代码（序列化短信到xml文件，保存为xml是因为xml具有跨平台的好处，android备份的短信也可以在ios系统中还原）是由A程序员写的， 界面的ui是由B程序员写的，这时客户要求加一个进度条对话框，a程序员提供一个普通方法，b把ProgressDialog对象传进去，由a给进度条设置最大值，以及备份过程的进
- 低耦合，简单易懂
- 低耦合 1. 低耦合（Low Coupling） “低耦合”这个词相信大家已经耳熟能详，我们在看spring的书籍、MVC的数据、设计模 式的书籍，无处不提到“低耦合、高内聚”，它已经成为软件设计质量的标准之一。那么什么是低耦合？耦合就是对某元素与其它元素之间的连接、感知和依赖的量 度。这里所说的元素，即可以是功能、对象（类），也可以指系统、子系统、模块。假如一个元素A去连接元素
- 降低程序耦合性的方法
- 转载dadalan的<em>降低</em>C程序<em>耦合性</em>方法 源文档地址：http://blog.csdn.net/dadalan/article/details/3861616 英文 ： coupling <em>耦合性</em>是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间接口的复杂程度、<em>调用</em>模块的方式以及哪些信息通过接口。 一般模块之间可能的连接方式有七种，构成<em>耦合性</em>的七种类型。它们之间的关系为（由弱到
- 函数中的耦合问题
- 递归函数是一个函数通过名字<em>调用</em>自身的情况下构成的，例如：function factorial(num){ if(num<1){ return 1; }else{ return num*factorial(num1); } }这是一个经典的递归阶乘函数，虽然表面上看没有什么<em>问题</em>，但下面的代码可能导致它出错。var anothorFactoria
- vue耦合程度是什么意思
- 被这个新词吓唬的一愣一愣的。。。。 通俗的讲 就是写一个组件 在任何复杂的项目 任何复杂的场景下 都可以即拿 即用 这就是低耦合 高耦合的意思 通俗讲 就是 你老大让你写一个项目内的组件 有很多场景 要用 你开发好的结果就是 只有一个场景 好用 其他场景 都是很难用 耦合度越高 越说明组件的抽象程度和你对项目业务的理解 越烂
- java程序的耦合度是什么
- 程序的耦合度是 你的子程序之间的相关联性,也就是说你的多个类的联系 是否太紧密，打个比方，你房子里边有窗子 ，那房子 和窗子 就有了关联 耦合度 是松还是紧 就看你的 关联 是强还是弱，也就是修改的代价，比如 你窗子是扣死在墙里的 那么你修改窗子 就必须修改墙 这就比较紧密了，但是如果你窗子是按照某种规格的 可以自由拆装的 那么修改的代价就小，耦合度也就低了 我们写程序的目标就是 高内聚
- Python中的函数：大量封装函数可降低代码耦合度
- 先聊聊java中的函数吧java函数位于 类 文件内部，以权限修饰词开头（当然也可以不写，默认为default权限），然后是返回值声明，接下来是函数的名字，再然后就是形参了class User{ private String name; public String getName(){ return name; } public void setName
- 耦合性简单解释
- 解耦的目的就是达到, A模块<em>调用</em>B时, 不需要知道B的内部实现 耦合等级: 高耦合->低耦合 红色为常见的耦合,->后面基本就是这篇文章的3条总结.如果能明白就不需要继续看了 内容耦合 共用耦合common coupling->尽量不要全局变量, ->各个模块不依赖全局变量 外部耦合 控制耦合control coupling ->不要用A模块的flag去控制B模块. ->A不需要知道B的结构 特征耦合stamp coupling or data struct coupling->(如果模块只用到
- 关于JAVA 封装性 以及高内聚，低耦合的理解
- 1.封装性 封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含两个含义： ◇ 把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位（即对象）。 ◇信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界〔或者说形成一道屏障〕，只保留有限的对外接口使之与外部发生联系。 封装的原则在软件上的反映是：要求使对象以外的部分不能随意存取对
- 内聚性和耦合性的类型
- 内聚性 功能内聚。主要通过操作来体现。一个模块只完成一组特定操作并返回结果。分层内聚。由包、构件、类来体现。高层能够访问低层的服务，但低层不能访问高层的服务。通信内聚。访问相同数据的所有操作被定义在一个类中。一般来说，这些类只着眼于数据的查询、访问和存储。 <em>耦合性</em> 内容耦合。一个构件“暗中修改其他构件的内部数据”。共用耦合。大量的构件都要使用同一个全局变量时。控制耦合。当操作A<em>调用</em>操
- 耦合度&如何降低耦合度
- 一、什么是耦合度 耦合度就是某模块（类）与其它模块（类）之间的关联、感知和依赖的程度，是衡量代码独立性的一个指标，也是软件工程设计及编码质量评价的一个标准。耦合的强度依赖于以下几个因素：（1）一个模块对另一个模块的<em>调用</em>；（2）一个模块向另一个模块传递的数据量；（3）一个模块施加到另一个模块的控制的多少；（4）模块之间接口的复杂程度。 耦合按从强到弱的顺序可分为以下几种类型： （1）内容耦合。...
- 软件设计之耦合性与内聚性的区别
- <em>耦合性</em> <em>耦合性</em>也叫块间联系，指软件系统结构中各模块间相互联系紧密程度的一种度量。 模块之间联系越紧密，其<em>耦合性</em>就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，<em>调用</em>的方式以及传递的信息。 内聚性 内聚性也叫块内联系，指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。内聚性是对一个模块内部各个组成元素之间相互结合的紧密程度的度量指标。 模块中组成元...
- MVP+Dagger2.5注入构造方法
- MVP+Dagger2.5注入构造方法，Dagger2.5是一个依赖注入的框架。 依赖注入是一种面向对象的编程模式，它的出现是为了<em>降低</em><em>耦合性</em>，所谓耦合就是类之间依赖关系，所谓<em>降低</em>耦合就是<em>降低</em>类和类之间依赖关系。
- php设计模式及耦合性和多形性
- 什么是设计模式： 设计模式就是一个教你如何利用真实可靠的设计来组织你的代码的模板。 所有的设计模式都有一些常用的特性：一个标识（a name），一个<em>问题</em>陈述（a problem statement）和一个解决方案(a solution)。 1、一个设计模式的标识是重要的，因为它会让其他的程序员不用进行太深入的学习就能立刻理解你的代码的目的（至少通过这个标
- 关于解耦合的一个现实例子
- 关于解耦合的一个现实例子： “跟大部分餐饮企业一样，星巴克也主要致力于将订单处理的吞吐量最大化。顾客订单越多，收入就越多。为此，他们采取了异步处理的办法。你在点单时，收银员取出一只咖啡杯，在上面作上记号表明你点的是什么，然后把这个杯子放到队列里去。这里的队列指的是在咖啡机前排成一列的咖啡杯。正是这个队列将收银员与咖啡师解耦开，从而，即便在咖啡师一时忙不过来的时候，收银员仍然可以为顾客点单。他们...
- 面对对象原则：高内聚、低耦合
- 软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分摸块的一个准则就是高内聚低耦合。 这是软件工程中的概念,是判断设计好坏的标准，主要是面向OO的设计，主要是看类的内聚性是否高，偶合度是否低.每一个类完成特定的独立的功能，这个就是高内聚。耦合就是类之间的互相<em>调用</em>关系，如果耦合很强，互相牵扯<em>调用</em>很多，那么会牵一发而动全身，不利于维护和扩展。 类之间的设置应该要低耦合,但是每个类应该要高内聚.
- 利用工厂模式降低代码耦合性
- 1、工厂模式可以分为三类：1）简单工厂模式（Simple Factory）2）工厂方法模式（Factory Method）3）抽象工厂模式（Abstract Factory）2、抽象工厂模式与工厂方法模式的区别：工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。一个抽象工厂类，可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。抽象...
- 数据库耦合-解耦
- 随着业务越来越复杂，数据量越来越大，并发量越来越大，数据库的性能越来越低。好不容易找运维申请了两台机器，让DBA部署了几个实例，想把一些业务库拆分出来，却发现拆不出来，扩不了容，尴尬！ 因为数据库强关联在一起，无法通过增加数据库实例扩容，就是一个耦合的典型案例。 场景还原 有一个公共用户数据库DB_USER，里面table_user存放了通用的用户数据：
- java web 项目实现 耦合-解耦 解决方案----工厂模式入门级别
- 1.主要思想就是使用工厂设计模式，将service层和dao层进行解耦 控制反转就是（inversion of control）将控制权交个自定的一个工厂来实现，我们要做的就是，通过自定义beanfactory 得到需要的serviceiml 和 daoiml对应的类 说白了，不用serviceiml依赖dao层 这里使用ServletContextListener 监听器来
- 数据库的高内聚、低耦合？
- 起因：模块独立性指每个模块只完成系统要求的独立子功能，并且与其他模块的联系最少且接口简单，两个定性的度量标准――<em>耦合性</em>和内聚性。 <em>耦合性</em>也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其<em>耦合性</em>就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、<em>调用</em>的方式及传递的信息。 <em>耦合性</em>分类(低――高): 无直接耦合;数...
- 耦合性、内聚度的介绍
- 软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。 一、<em>耦合性</em>(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决与模块间接口的复杂性、<em>调用</em>模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、<em>调用</em>关系、数据传递关系。模块间联系越多，其<em>耦合性</em>越强，同时表明其独立性越差。
- 全局变量造成的耦合
- 今天在修改一个前人的程序时，碰到这么一个<em>问题</em>。由于去掉了某个功能，我需要注释掉一个函数A，在运行中报了一个莫名其妙的错误，令我百思不得其解，万般无奈下，只好调试程序，最终发现<em>问题</em>出在一个全局变量上，这个值只有在那个被注释掉的函数内赋了一个合法值后，另外一个函数B才能顺利进行。在这里，两个函数通过这个全局变量耦合在了一起，我只考虑到注释掉函数A，却没有想到它的变化引起了全局变量的变化
- 菜鸟搞懂设计模式之一：依赖与耦合
- 谈及依赖与耦合，其实是指的在面向对象的设计模式中，类与类之间有以下六种耦合关系： 依赖、关联、聚合、组合、继承、实现。这六种耦合关系的强度依次增强。其实没有必要分那么多种类，可以统一称为依赖与耦合关系。依赖与耦合如果说A依赖B，那么没有B，A有些事儿就干不了了。比如我想出去旅游，那么一定要选择出行工具，因为靠自己的腿是走不了多远的。这里B就是出行工具，可以是汽车、火车、飞机等。因此我出去旅游这事儿
- Java web项目的解耦合
- 以前的项目大多数都是java程序猿又当爹又当妈，又搞前端（ajax/jquery/js/html/css等等），又搞后端（java/mysql/oracle等等）。 随着时代的发展，渐渐的许多大中小公司开始把前后端的界限分的越来越明确，前端工程师只管前端的事情，后端工程师只管后端的事情，正所谓术业有专攻，一个人如果什么都会，那么他毕竟什么都不精。 大中型公司需要专业人才，小公司需要全才，
- 关于Android模块化、低耦合、高扩展性的架构设计
- 上个月接到项目重构的任务，让设计一种高扩展性，模块耦合更低的轻量级的架构。于是我根据app的业务和模块划分最终设计出了如下架构，该架构适合模块较多，模块中联系较低的app。根据近一个月的实战验证，确定了该架构的可信性和很高的扩展性、代码复用性，另外该架构使得代码结构更加清晰，更容易维护。该架构符合android组件化、模块化开发的思想。 1、该架构看起来比较重比较繁琐，但是对于团队开发来说却
- Unity MVC框架代码详解（适合中小项目开发，解耦合，事件发送消息监听机制）
- 一、首先介绍模型类Model 从上图中可以看出，Model发出的线只有一条虚线，所以Model层只是负责发送事件（消息）通知视图层改变UI的显示，而指向Model的另外两个线的是意思是视图层和控制层可以获取到Model数据，简明之意就是View和Controller可以访问到Model。Model层代码如下： /// &lt;summary&gt; /// 模型数据 /...
- 【iOS学习】UITableView占位图的低耦合性设计
- 缘由基于面向对象的开发原则中的迪米特法则:一个软件实体应当尽可能少的与其他实体发生相互作用;为了<em>降低</em>列表无数据占位图的使用成本及代码<em>耦合性</em>,对网上现用的一些解决方案加以优化;核心针对基于runtime替换reloadData方法的相关,这里就不做多阐述了,本文主要讨论以下几个<em>问题</em>:1.需要显示占位图的情况;2.tableView初次系统<em>调用</em>reloadData方法的干扰排除最优方案;3.网络因服务...
- java的耦合与解耦
- java 里面耦合和解耦 百度解释： 耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 解耦就是用数学方法将两种运动分离开来处理<em>问题</em>。 这是形象搞笑的比喻： 完全可以这么想像嘛，有一对热恋中的男女，水深火热的，谁离开谁都不行了，离开就得死，要是对方有一点风吹草动，这一方就得地动山摇。 可以按照琼瑶阿姨的路子继续想象，想成什么样都不过分，他们之间的...
- 降低项目耦合性之服务器返回码的封装
- 废话没有直接代码 &lt;pre&gt; import Foundation class Toast: NSObject{ static func show( ti: NSTimeInterval,rescode :String! ){ let msg = self. getMsg(rescode) let alert = UIAlertView() a...
- 一例看懂C语言程序中的内聚和耦合
- （一）原理篇 （清楚相关原理的读者，请直接看第二部分示例篇） 在软件工程中，模块的内聚和耦合是度量模块化质量的标准之一。内聚是指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。耦合是程序中各模块之间相互联系紧密程度的一种度量。各模块之间联系越紧密，其<em>耦合性</em>就越强。模块间耦合高低取决于模块间...
- 耦合与聚合
- 耦合可以分为以下几种，它们之间的耦合度由高到低排列如下：（1） 内容耦合：一个模块直接访问另一模块的内容，则称这两个模块为内容耦合。若在程序中出现下列情况之一，则说明两个模块之间发生了内容耦合：1. 一个模块直接访问另一个模块的内部数据。2. 一个模块不通过正常入口而直接转入到另一个模块的内部。3. 两个模块有一部分代码重叠（该部分代码具有一定的独立功能）。4. 一个模块有多个入口。内容耦合可能在...
- 关于开发中耦合度的强弱顺序
- 之前在做题的时候碰到过要判断开发设计中耦合度强弱<em>问题</em>，在网上查了些资料，这个比较全。 耦合按从强到弱的顺序可分为以下几种类型： a)非直接耦合：两模块间没有直接关系，之间的联系完全是通过主模块的控制和<em>调用</em>来实现的 b)数据耦合：一个模块访问另一模块，彼此间通过简单数据参数来交换输入、输出信息。这里的简单数据参数不同于控制参数、公共数据结构或外部变量。 c)标记耦合：如一组模块通
- 变换循环变量，降低复杂度
- 在一些<em>问题</em>中，如果适当选择循环变量，将会<em>降低</em>程序的复杂度，例如判断子串的<em>问题</em>： 判断字符串 s 是不是 t的子串，有两种方案 方案一 思路：对s中的元素遍历，根据贪心的思想，搜索t中第一个该元素，若不存在，则说明s不是t的子串。注意，s中的元素在t中的相对位置必须保持不变，所以每一次搜索时，应该从上一次搜索到的位置处搜索。 实现：搜索可以用 cstring 中的strchr函数。 复杂...
- 耦合与耦合性概念解释（一）
- 耦合是指两个或两个以上的电路元件或电网络的输入与输出之间存在紧密配合与相互影响，并通过相互作用从一侧向另一侧传输能量的现象。 耦合作为名词在通信工程、软件工程、机械工程等工程中都有相关名词术语。 耦合主要分为以下几种： 多场耦合 现实工程中，物理场是许多的 ，温度场，引力场，湿度场等等均属于物理场，而我们要解决的许多<em>问题</em>是这些物理场的叠加<em>问题</em>，因为这些物理场直接是相互影响的。比如炼钢
- MyBatis 基于注解的增删改查示例(Spring IOC注入)
- MyBatis 基于注解的增删改查示例程序,使用Spring的IOC机制注入,<em>降低</em>程序间的<em>耦合性</em>
- 函数设计应做到低耦合，高内聚
- 最近，同项目组的一位师姐请产假了，由我接手她之前的部分版本的开发工作。在开发的过程中，我阅读了某个很古老的版本的程序代码，心生感触，想在这里啰嗦几句。 该版本中很多函数的<em>调用</em>关系都错综复杂，让人读起来非常的费劲。我用如下的图来形象化地表示这种函数之间的<em>调用</em>关系。 箭头的指向为<em>调用</em>关系，如“函数A”<em>调用</em>了“函数B”、“函数C”、“函数D”、“函数E”、“函数F”，以此类推
我们是很有底线的