blocks|key|1250234|text|紧耦合是指一组类彼此高度依赖的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1250235|当一个类承担了太多的责任，或者当一个关注点分散在多个类而不是拥有自己的类时，就会出现这种情况。|1250236|松耦合是通过促进单一责任和关注点分离的设计来实现的。|1250237|松耦合的类可以独立于其他(具体的)类来使用和测试。|1250238|接口是用于解耦的强大工具。类可以通过接口进行通信，而不是通过其他具体的类进行通信，任何类都可以通过实现接口而处于通信的另一端。|1250239|紧耦合示例：|1250240|class+CustomerRepository
{
++++private+readonly+Database+database;

++++public+CustomerRepository(Database+database)
++++{
++++++++this.database+=+database;
++++}

++++public+void+Add(string+CustomerName)
++++{
++++++++database.AddRow("Customer",+CustomerName);
++++}
}

class+Database
{
++++public+void+AddRow(string+Table,+string+Value)
++++{
++++}
}|code-block|syntax|javascript|1250241|松散耦合示例：|1250242|class+CustomerRepository
{
++++private+readonly+IDatabase+database;

++++public+CustomerRepository(IDatabase+database)
++++{
++++++++this.database+=+database;
++++}

++++public+void+Add(string+CustomerName)
++++{
++++++++database.AddRow("Customer",+CustomerName);
++++}
}

interface+IDatabase
{
++++void+AddRow(string+Table,+string+Value);
}

class+Database+implements+IDatabase
{
++++public+void+AddRow(string+Table,+string+Value)
++++{
++++}
}|1250243|另一个例子是here。|offset|length|1250244|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/226977/what-is-loose-coupling-please-provide-examples#227036^0|0|0|0|0|0|0|0|0|0|6|4|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1C|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1E|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1F|8|@]|9|@$W|1G|X|1H|1|1I]]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

Tight coupling is when a group of classes are highly dependent on one another.
This scenario arises when a class assumes too many responsibilities, or when one concern is spread over many classes rather than having its own class.
Loose coupling is achieved by means of a design that promotes single-responsibility and separation of concerns.
A loosely-coupled class can be consumed and tested independently of other (concrete) classes.
Interfaces are a powerful tool to use for decoupling. Classes can communicate through interfaces rather than other concrete classes, and any class can be on the other end of that communication simply by implementing the interface.
Example of tight coupling:
<pre class="lang-java prettyprint-override"><code>class CustomerRepository
{
 private readonly Database database;

 public CustomerRepository(Database database)
 {
 this.database = database;
 }

 public void Add(string CustomerName)
 {
 database.AddRow(&quot;Customer&quot;, CustomerName);
 }
}

class Database
{
 public void AddRow(string Table, string Value)
 {
 }
}
</code></pre>
Example of loose coupling:
<pre class="lang-java prettyprint-override"><code>class CustomerRepository
{
 private readonly IDatabase database;

 public CustomerRepository(IDatabase database)
 {
 this.database = database;
 }

 public void Add(string CustomerName)
 {
 database.AddRow(&quot;Customer&quot;, CustomerName);
 }
}

interface IDatabase
{
 void AddRow(string Table, string Value);
}

class Database implements IDatabase
{
 public void AddRow(string Table, string Value)
 {
 }
}
</code></pre>
Another example <a href="https://stackoverflow.com/questions/226977/what-is-loose-coupling-please-provide-examples#227036">here</a>.

blocks|key|1250280|text|在面向对象设计中，耦合的数量指的是一个类的设计在多大程度上依赖于另一个类的设计。换句话说，A类中的更改多久会强制B类中与更改相关的更改？紧耦合意味着两个类经常一起变化，松耦合意味着它们大多是独立的。通常，推荐使用松散耦合，因为这样更容易测试和维护。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1250281|您可能会发现this+paper+by+Martin+Fowler+(PDF)很有帮助。|offset|length|1250282|entityMap|0|LINK|mutability|MUTABLE|url|http://martinfowler.com/ieeeSoftware/coupling.pdf^0|0|6|X|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

In object oriented design, the amount of coupling refers to how much the design of one class depends on the design of another class. In other words, how often do changes in class A force related changes in class B? Tight coupling means the two classes often change together, loose coupling means they are mostly independent. In general, loose coupling is recommended because it's easier to test and maintain.

You may find <a href="http://martinfowler.com/ieeeSoftware/coupling.pdf" rel="noreferrer">this paper by Martin Fowler (PDF)</a> helpful.

blocks|key|1035237|text|松散耦合是对旧式硬编码依赖和相关问题的解决方案，这些问题包括频繁的重新编译和代码重用。它强调在组件中实现工作逻辑，并避免特定于解决方案的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035238|松散耦合=+IoC更简单的解释见this。|offset|length|1035239|entityMap|0|LINK|mutability|MUTABLE|url|http://www.martinfowler.com/articles/injection.html|1|http://www.codeproject.com/KB/aspnet/IOCDI.aspx^0|0|6|3|0|G|4|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

Loose coupling is and answer to to old style hardcoded dependencies and related issues issues like frequent recompilation when anything changes and code reuse. It stresses on implementing the worker logic in components and avoiding solution specific wire up code there. 

Loose Coupling = <a href="http://www.martinfowler.com/articles/injection.html" rel="nofollow noreferrer">IoC</a>
See <a href="http://www.codeproject.com/KB/aspnet/IOCDI.aspx" rel="nofollow noreferrer">this</a> for easier explanation.

blocks|key|1035281|text|当两个对象是松散耦合的时，它们可以交互，但对彼此的了解很少。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035282|松耦合的设计允许我们构建灵活的OO系统，可以处理变化。|1035283|观察者设计模式是使类松散耦合的一个很好的例子，你可以在Wikipedia中看看它。|offset|length|1035284|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Observer_pattern^0|0|0|R|9|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

When two objects are loosely coupled, they can interact but have very little knowledge of
each other. 

Loosely coupled designs allow us to build flexible OO systems that can handle change.

Observer design pattern is a good example for making classes loosely coupled, you can have a look on it in <a href="http://en.wikipedia.org/wiki/Observer_pattern">Wikipedia</a>.

blocks|key|1250485|text|有一些工具通过他们的库提供依赖注入，例如在.net中我们有ninject+Library。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1250486|如果你想在java中走得更远，那么spring就提供了这个功能。|1250487|可以通过在代码中引入接口来创建松耦合的对象，这就是这些源代码所做的事情。|1250488|在你的代码中说你正在写|1250489|Myclass+m+=+new+Myclass();|code-block|syntax|javascript|1250490|现在，你的方法中的这条语句表明你依赖于myclass，这被称为紧耦合。现在你提供了一些构造函数注入，或者属性注入和实例化对象，然后它将变得松散耦合。|style|CODE|1250491|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ninject.org/|1|http://www.springsource.org/^0|T|F|0|0|H|6|1|0|0|0|0|J|7|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|F|3|G|5|6|7|1A|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|1B|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1C|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1D|8|@$A|1E|B|1F|Q|R]]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

There are certain tools that provide dependency injection through their library, for example in .net we have <a href="http://www.ninject.org" rel="nofollow">ninject Library</a> .

If you are going further in java then <a href="http://www.springsource.org" rel="nofollow">spring</a> provides this capabilities.

Loosly coupled objects can be made by introducing Interfaces in your code, thats what these sources do.

Say in your code you are writing 

<pre><code>Myclass m = new Myclass();
</code></pre>

now this statement in your method says that you are dependent on <code>myclass</code> this is called a tightly coupled. Now you provide some constructor injection , or property injection and instantiating object then it will become loosly coupled.

blocks|key|1035529|text|一般来说，紧密耦合是不好的，但在大多数情况下，因为它降低了代码的灵活性和可重用性，它使更改变得更加困难，它阻碍了可测试性等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035530|紧密耦合的对象是一个需要相互了解的对象，并且通常高度依赖于彼此的接口。在紧密耦合的应用程序中更改一个对象通常需要更改许多其他对象，在小型应用程序中，我们可以很容易地识别这些更改，并且很少有机会错过任何东西。但在大型应用程序中，这些相互依赖关系并不是每个程序员都知道的，或者有机会错过更改。但每组松散耦合的对象并不依赖于其他对象。|1035531|简而言之，我们可以说，松散耦合是一个寻求减少系统组件之间的相互依赖性的设计目标，其目标是降低在一个组件中的更改将需要在任何其他组件中更改的风险。松散耦合是一个更通用的概念，旨在增加系统的灵活性，使其更具可维护性，并使整个框架更加“稳定”。|1035532|耦合指的是一个元素对另一个元素的直接了解程度。我们可以说:A和B，只有当A改变它的行为时，B才改变它的行为。松散耦合的系统可以很容易地分解为可定义的元素。|1035533|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

In general Tight Coupling is bad in but most of the time, because it reduces flexibility and re-usability of code, it makes changes much more difficult, it impedes testability etc.

Tightly Coupled Object is an object need to know quite a bit about each other and are usually highly dependent on each other interfaces. Changing one object in a tightly coupled application often requires changes to a number of other objects, In small application we can easily identify the changes and there is less chance to miss anything. But in large applications these inter-dependencies are not always known by every programmer or chance is there to miss changes. But each set of loosely coupled objects are not dependent on others.

In short we can say, loose coupling is a design goal that seeks to reduce the interdependencies between components of a system with the goal of reducing the risk that changes in one component will require changes in any other component. Loose coupling is a much more generic concept intended to increase the flexibility of a system, make it more maintainable, and make the entire framework more 'stable'.

Coupling refers to the degree of direct knowledge that one element has of another. we can say an eg: A and B, only B change its behavior only when A change its behavior. A loosely coupled system can be easily broken down into definable elements.

blocks|key|1035619|text|据我所知，与松散耦合的体系结构相比，紧密耦合的体系结构并不能提供很大的灵活性来进行更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035620|但在架构、消息格式或操作平台松散耦合的情况下，修改业务逻辑不会影响另一端。如果系统关闭以进行改造，当然另一端将在一段时间内无法访问服务，但除此之外，未更改的一端可以恢复改造前的消息交换。|1035621|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The way I understand it is, that tightly coupled architecture does not provide a lot of flexibility for change when compared to loosely coupled architecture. 

But in case of loosely coupled architectures, message formats or operating platforms or revamping the business logic does not impact the other end. If the system is taken down for a revamp, of course the other end will not be able to access the service for a while but other than that, the unchanged end can resume message exchange as it was before the revamp.

blocks|key|1035686|text|松耦合是一个过程，它间接地给出你的类需要的依赖项，而不提供依赖项的所有信息(即在接口的from中)，以防你直接在依赖项中给出紧耦合，这不是好的编码方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1035687|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Loose Coupling is the process of giving the dependency your class needs indirectly without providing all the information of the dependency(i.e in the from of interface) in case tight coupling you directly give in the dependency which is not good way of coding.

blocks|key|1250786|text|松散耦合意味着两个组件之间的依赖程度非常低。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1250787|示例:+GSM+SIM|1250788|紧耦合意味着两个组件之间的依赖程度非常高。|1250789|示例:+CDMA移动|1250790|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Loose coupling means that the degree of dependency between two components is very low. 
Example: GSM SIM

Tight coupling means that the degree of dependency between two components is very high. 
Example: CDMA Mobile

Can any one describe the exact difference between loose coupling and tight coupling in Object oriented paradigm?

What is the difference between loose coupling and tight coupling in the object oriented paradigm?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

在面向对象的范例中，有谁能描述松散耦合和紧密耦合之间的确切区别？

问在面向对象的范例中，松耦合和紧耦合的区别是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在面向对象的范例中，松耦合和紧耦合的区别是什么？EN