松耦合意味着两个组件之间的依赖程度非常低。 示例:GSM SIM卡

紧密耦合意味着两个组件之间的依赖程度非常高。 例如:CDMA移动通信

我的理解是，与松散耦合的体系结构相比，紧密耦合的体系结构并没有为更改提供很多灵活性。

但是对于松散耦合的体系结构，消息格式或操作平台或修改业务逻辑不会影响另一端。如果系统因改造而关闭，当然另一端在一段时间内不能访问服务，但除此之外，未更改的一端可以恢复消息交换，就像改造之前一样。

在面向对象设计中，耦合量指的是一个类的设计依赖于另一个类的设计的程度。换句话说，A类力的变化与B类力的变化相关的频率是多少?紧耦合意味着两个类经常一起更改，松耦合意味着它们大部分是独立的。一般来说，推荐使用松耦合，因为它更容易测试和维护。

你可能会发现Martin Fowler的这篇论文(PDF)很有帮助。

紧密耦合是指一组类彼此高度依赖。

当一个类承担了太多的责任，或者当一个关注点分散到许多类而不是拥有自己的类时，就会出现这种情况。

松耦合是通过促进单一责任和关注点分离的设计实现的。

松耦合类可以独立于其他(具体的)类使用和测试。

接口是用于解耦的强大工具。类可以通过接口而不是其他具体类进行通信，并且任何类都可以通过实现接口而处于通信的另一端。

紧密耦合的例子:

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)
    {
    }
}

松耦合的例子:

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)
    {
    }
}

另一个例子。

摘自我关于耦合的博客文章:

什么是紧密耦合:-

正如上面定义的那样，紧密耦合对象是一个需要了解其他对象的对象，并且通常高度依赖于彼此的接口。

当我们更改紧耦合应用程序中的一个对象时，通常需要更改许多其他对象。在一个小的应用程序中没有问题，我们可以很容易地识别变化。但在大型应用程序中，这些相互依赖关系并不总是为每个消费者或其他开发人员所了解，或者将来可能会有很多变化。

让我们用购物车演示代码来理解紧耦合:

namespace DNSLooseCoupling
{
    public class ShoppingCart
    {
        public float Price;
        public int Quantity;

        public float GetRowItemTotal()
        {
            return Price * Quantity;
        }
    }

    public class ShoppingCartContents
    {
        public ShoppingCart[] items;

        public float GetCartItemsTotal()
        {
            float cartTotal = 0;
            foreach (ShoppingCart item in items)
            {
                cartTotal += item.GetRowItemTotal();
            }
            return cartTotal;
        }
    }

    public class Order
    {
        private ShoppingCartContents cart;
        private float salesTax;

        public Order(ShoppingCartContents cart, float salesTax)
        {
            this.cart = cart;
            this.salesTax = salesTax;
        }

        public float OrderTotal()
        {
            return cart.GetCartItemsTotal() * (2.0f + salesTax);
        }
    }
}

上面例子中的问题

紧密耦合产生了一些困难。

在这里，OrderTotal()方法为我们提供了购物车当前项目的完整金额。如果我们想在这个购物车系统中添加折扣功能。在上面的代码中很难做到这一点，因为我们必须在每个类中进行更改，因为它是非常紧密耦合的。

紧密耦合意味着一个类依赖于另一个类。 松耦合意味着一个类依赖于接口而不是类。

在紧密耦合中，方法中声明了硬编码的依赖项。 在松耦合中，我们必须在运行时向外部传递依赖项，而不是硬编码。(松散耦合系统使用接口来减少与类的依赖。)

例如，我们有一个系统可以以两种或多种方式发送输出，如JSON输出、CSV输出等。

紧耦合的

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput() {
        // Here Output will be in CSV-Format, because of hard-coded code.
        // This method tightly coupled with CSVOutputGenerator class, if we want another Output, we must change this method.
        // Any method, that calls Class1's generateOutput will return CSVOutput, because Class1 is tight couple with CSVOutputGenerator.
        OutputGenerator outputGenerator = new CSVOutputGenerator();
        output.generateOutput();
    }
}

在上面的例子中，如果我们想要更改JSON中的输出，那么我们需要在整个代码中找到并更改，因为Class1与CSVOutputGenerator类紧密耦合。

松散耦合

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput(OutputGenerator outputGenerator) {
        // if you want to write JSON, pass object of JSONOutputGenerator (Dependency will be passed externally to this method)
        // if you want to write CSV, pass object of CSVOutputGenerator (Dependency will be passed externally to this method)

        // Due to loose couple with class, we don't need to change code of Class1, because Class1 is loose coupled with CSVOutputGenerator or JSONOutputGenerator class
        // Any method, that calls Class1's generateOutput will desired output, because Class1 does not tight couple with CSVOutputGenerator or JSONOutputGenerator class
        OutputGenerator outputGenerator = outputGenerator;
        output.generateOutput();
    }
}