这里有很多使用类比的很好的答案，但是一个工作中的朋友给了我一个例子，比这里提到的所有例子都更让我喜欢……眼睛和眼镜!

紧密耦合

紧密耦合是眼睛。如果我想修复我的视力，做眼部移植手术非常昂贵，而且有相当大的风险。但如果设计师(作为人类)找到了更好的方法呢?添加一个与主体松散耦合的特性，这样就可以轻松地更改它!(是的. .眼镜)

松散耦合

我可以很容易地更换我的眼镜，而不会破坏我的潜在视力。我可以摘下眼镜，我的视力就会恢复到以前的水平(不是更好或更差)。使用不同的眼镜改变了我们通过眼睛看世界的方式，而且风险很小，易于维护。

总结

所以下次有人问你“谁在乎我的代码是否紧密耦合?”答案都是关于努力改变，努力维持和改变的风险。

那么这在c#中是如何实现的呢?接口和依赖注入!

EDIT

这也是Decorator模式的一个很好的例子，其中眼睛是我们通过满足界面需求来装饰的类，但提供了不同的功能(例如太阳镜、老花镜、珠宝商的放大镜等)。

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

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

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

这是关于类对其他类的依赖率，在松散耦合时很低，而在紧密耦合时很高。在面向服务的体系结构中，服务之间是松散耦合的，不同的类之间的依赖是有意的

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

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

例如，我们有一个系统可以以两种或多种方式发送输出，如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();
    }
}

松耦合是老式硬编码依赖关系和相关问题的答案，比如当任何事情发生变化时频繁重新编译和代码重用。它强调在组件中实现工作者逻辑，避免解决方案特定的连接代码。

松耦合= IoC 请看下面的解释。

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

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

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

在你正在编写的代码中

Myclass m = new Myclass();

现在你的方法中的这个语句说你依赖于myclass这被称为紧耦合。现在你提供了一些构造函数注入，或者属性注入实例化对象，然后它就会变得松散耦合。