在面向对象范式中，松耦合和紧耦合的区别是什么?

在面向对象范式中，有人能准确地描述松耦合和紧耦合之间的区别吗?

当前回答

松耦合和紧耦合是关于程序组件之间的依赖关系。这意味着不仅依赖于编程类，还依赖于编程系统组件。

例如，如果你只使用简单的原始SQL查询从SQL Server接收数据，这是松耦合。与松耦合和简单原始SQL查询相反的是紧耦合和实体框架核心。在实体框架核心，你必须完整的模型与POCO类在你的代码反映数据库结构，这意味着任何变化在数据库中，你必须反映在代码。

因此，程序代码和数据库结构之间的紧密耦合是实体框架，这种方法的对立面是拒绝使用任何ORM，并拒绝在程序代码中使用完整的镜像数据库结构。

2022-02-04 16:22:26

其他回答

当两个对象松散耦合时，它们可以相互作用，但知之甚少对方。

松散耦合设计允许我们构建能够处理变更的灵活的OO系统。

观察者设计模式是一个让类松散耦合的好例子，你可以在维基百科上看到它。

2012-01-09 04:09:00

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

什么是紧密耦合:-

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

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

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

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

2015-03-21 04:34:03

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

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

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

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

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

紧密耦合的例子:

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

另一个例子。

2010-05-14 05:38:53

有一些工具通过它们的库提供依赖注入，例如在。net中我们有ninject库。

如果在java中更进一步，那么spring提供了这种功能。

松散耦合的对象可以通过在代码中引入接口来实现，这就是这些源代码所做的。

在你正在编写的代码中