Java中的耦合

在面向对象设计中，耦合是指一个元素对另一个元素的直接了解程度。换句话说，A 类中的更改多久会强制 B 类中的相关更改。
有两种类型的耦合：

1. 紧耦合：一般来说，紧耦合意味着两个类经常一起变化。换句话说，如果 A 对 B 的实现方式了解得更多，那么 A 和 B 就是紧密耦合的。
   示例：如果你想改变皮肤，你也必须改变你的身体设计，因为两者是结合在一起的——它们是紧密结合的。紧密耦合的最好例子是 RMI（远程方法调用）。

   // Java program to illustrate
   // tight coupling concept
   class Subject {
       Topic t = new Topic();
       public void startReading()
       {
           t.understand();
       }
   }
   class Topic {
       public void understand()
       {
           System.out.println("Tight coupling concept");
       }
   }
   

   说明：在上述程序中，主题类依赖于主题类。在上面的程序中，主题类与主题类紧密耦合，这意味着如果主题类的任何更改都需要主题类进行更改。例如，如果 Topic 类的 understand() 方法更改为 gotit() 方法，那么您必须更改 startReading() 方法将调用 gotit() 方法而不是调用 understand() 方法。

   // Java program to illustrate
   // tight coupling concept
   class Volume 
   {
        public static void main(String args[]) 
        {
            Box b = new Box(5,5,5);
            System.out.println(b.volume);
        }
   }
   class Box 
   {
        public int volume;
        Box(int length, int width, int height) 
        {
            this.volume = length * width * height;
        }
   }
   

   输出：

   125
   

   解释：在上面的例子中，两个类之间有很强的相互依赖关系。如果 Box 类有任何变化，那么它们会反映在 Class Volume 的结果中。

2. 松散耦合：简单来说，松散耦合意味着它们大多是独立的。如果 A 类对 B 类的唯一了解是 B 类通过其接口公开的内容，则称 A 类和 B 类是松散耦合的。为了克服对象之间紧耦合的问题，spring框架使用依赖注入机制，借助POJO/POJI模型，通过依赖注入实现松耦合。
   示例：如果你换了衬衫，那么你就不会被迫改变你的身体——当你能做到这一点时，你就有了松散的耦合。当你不能这样做时，你就有了紧密的耦合。松耦合的例子有接口、JMS。

   // Java program to illustrate 
   // loose coupling concept
   public interface Topic
   {
       void understand();
   }
   class Topic1 implements Topic {
   public void understand()
       {
           System.out.println("Got it");
       }
   } class Topic2 implements Topic {
   public void understand()
       {
           System.out.println("understand");
       }
   } public class Subject {
   public static void main(String[] args)
       {
           Topic t = new Topic1();
           t.understand();
       }
   }
   

   解释：在上面的例子中，Topic1 和 Topic2 对象是松耦合的。这意味着 Topic 是一个接口，我们可以在运行时注入任何实现的类，我们可以为最终用户提供服务。

   // Java program to illustrate
   // loose coupling concept
   class Volume 
   {
        public static void main(String args[]) 
        {
            Box b = new Box(5,5,5);
            System.out.println(b.getVolume());
        }
   }
   final class Box 
   {
        private int volume;
        Box(int length, int width, int height) 
        {
            this.volume = length * width * height;
        }
        public int getVolume() 
        { 
            return volume; 
              
        }
   }
   

   输出：

   125
   

   解释：在上面的程序中，两个类之间没有依赖关系。如果我们更改 Box 类中的任何内容，那么我们不必更改 Volume 类中的任何内容。

   紧耦合和松耦合哪个更好？

   一般来说，紧耦合是不好的，但大多数时候，因为它降低了代码的灵活性和可重用性，它使更改变得更加困难，它阻碍了测试能力等。松耦合是更好的选择，因为松耦合会有所帮助当您的应用程序需要更改或增长时。如果您使用松散耦合的架构进行设计，那么当需求发生变化时，应该只会影响应用程序的一小部分。
   让我们看一下紧耦合和松耦合的图示：
   

   紧耦合和松耦合的区别

   • 紧耦合的可测试性不好。但是松耦合提高了测试能力。
   • 紧耦合不提供接口的概念。但是松耦合帮助我们遵循程序到接口的 GOF 原则，而不是实现。
   • 在紧耦合中，在两个类之间交换代码并不容易。但是在松散耦合中交换其他代码/模块/对象/组件要容易得多。
   • 紧耦合不具备改变能力。但是松耦合是高度可变的。