面向对象编程中的七种耦合与内聚示例解析-优快云博客

本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/127482445

本文详细探讨了七种常见的软件设计耦合类型（无直接耦合、数据耦合、标记耦合、控制耦合、外部耦合、公共耦合和内容耦合），并通过实例展示了如何在C#代码中实现这些概念。理解这些耦合有助于提升代码结构的清晰度和可维护性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.概要

编号	名称	特点	说明
1	无直接耦合		指两个模块之间没有直接的关系，它们分别从属于不同模块的控制与调用，它们之间不传递任何消息。
2	数据耦合	传：数据	指两个模块之间有调用关系，传递的是简单的数据值。（类似于高级语言中的值传递）
3	标记耦合	传：引用	指两个模块之间传递的是数据结构。（类似于高级语言中的引用传递）
4	控制耦合	传：间接数据	指一个模块调用另一个模块时，传递的是控制变量，被调用模块通过该控制变量的值有选择地执行模块内的某一功能。因此，被调用模块应具有多个功能，哪个功能起作用受调用模块控制。
5	外部耦合	外：数据连接	模块间通过软件之外的环境联结。一组模块都访问同一全局简单变量。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
6	公共耦合	外：数据结果连接	指通过一个公共数据环境相互作用的那些模块间的耦合。一组模块都访问同一个全局数据结构，则称之为公共耦合。
7	内容耦合		当一个模块直接使用另一个模块的内部数据，或通过非正常入口转入另一个模块内部时。

2.代码

using System;

namespace 耦合与内聚实验
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("耦合与内聚实验");
            无直接耦合1.main();
            数据耦合2.main();
            标记耦合3.main();
            控制耦合4.main();
            外部耦合5.main();
            公共耦合6.main();
            内容耦合7.main();
            Console.ReadKey();
        }
    }
}

无耦合

using System;

namespace 耦合与内聚实验
{
    class 无直接耦合1
    {
        public static void main() {
            Console.WriteLine("\n---无直接耦合1");
            A a = new A();
            B b = new B();
            string str = b.viewA("子模块无需知道对方的存在，子模块之间的联系，全部变成子模块和主模块之间的联系");
            a.view(str);
        }
        class A {
            public void view(string str) {
                Console.WriteLine(str);
            }
        }
        class B {
            public string viewA(string str) {
                return "数据处理："+str;
            }
        }
    }
}

数据耦合

using System;

namespace 耦合与内聚实验
{
    class 数据耦合2
    {
        public static void main() {
            Console.WriteLine("---数据耦合2");
            A a = new A();
            B b = new B();
            b.viewA(a, "值传递");
        }
        class A {
            public void view(string value) {
                Console.WriteLine(value);       
            }
        }
        class B {
            public void viewA(A a, string v) {
                //指两个模块之间有调用关系，传递的是简单的数据值。
                //（类似于高级语言中的值传递）
                a.view(v);
            }
        }
    }
}

标记耦合

using System;

namespace 耦合与内聚实验
{
    class 标记耦合3
    {
        public static void main() {
            Console.WriteLine("--标记耦合3");
            A a = new A();
            B b = new B();
            b.viewA(a,new Data("引用传递"));
        }
        class Data {
            public Data(string str) {
                this.a = str;
            }
            public string a;
        }
        class A
        {
            public void view(Data data) {
                Console.WriteLine(data.a);
            }
        }
        class B 
        {
            public int ma;
            //指两个模块之间传递的是数据结构。
            //（类似于高级语言中的引用传递）
            public void viewA(A a,Data data) {
                a.view(data);
            }   
        }
    }
}

控制耦合

using System;

namespace 耦合与内聚实验
{
    class 控制耦合4
    {
        public static void main() {
            Console.WriteLine("---控制耦合4");
            A a = new A();
            B b = new B();
            b.viewA(true);
            a.view();
        }
        static bool state;
        class A {
            public void view() {
                if (state == true)
                {
                    Console.WriteLine("表示:指一个模块调用另一个模块时，传递的是控制变量，被调用模块通过该控制变量的值有选择地执行模块内的某一功能");
                }
                else {
                    Console.WriteLine("隐藏");
                }
            }
        }
        class B {
            /// <summary>
            /// 指一个模块调用另一个模块时，传递的是控制变量，被调用模块通过该控制变量的值有选择地执行模块内的某一功能。因此，被调用模块应具有多个功能，哪个功能起作用受调用模块控制。
            /// （类似于计算工资模块，调用它的模块先区别是普通员工还是经理，进而生成控制变量，传递给计算工资模块进而选择其中一种计算功能）
            /// </summary>
            /// <param name="b"></param>
            public void viewA(bool b) {
                state = b;   
            }
        }
    }
}

外部耦合

using System;

namespace 耦合与内聚实验
{
    class 外部耦合5
    {
        static string data = "";
        public static void main() {
            Console.WriteLine("---外部耦合5");
            A a = new A();
            B b = new B();
            b.viewA(a, "一组模块都访问同一全局简单变量而不是同一全局数据结构");
        }
        class A {
            public void view() {
                Console.WriteLine(data);   
            }    
        }
        class B
        {
            /// <summary>
            /// 模块间通过软件之外的环境联结。（如I/O将模块耦合到特定的设备、格式、通信协议上）
            /// 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
            /// 一组模块都访问同一全局简单变量，而且不通过参数表传递该全局变量的信息，则称之为外部耦合。外部耦合和公共耦合很像，区别就是一个是简单变量，一个是复杂数据结构。
            /// </summary>
            /// <param name="a"></param>
            public void viewA(A a,string value) {
                data = value;
                a.view();
            }   
        }
    }
}

公共耦合

using System;
using System.Collections.Generic;

namespace 耦合与内聚实验
{
    class 公共耦合6
    {
        static SesionData Data = new SesionData();
        public static void main() {
            Console.WriteLine("---公共耦合6");
            A a = new A();
            B b = new B();
            b.viewA("xjc");
            a.view();
        }
        class SesionData
        {
            Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
            public void Add(string key, string value) {
                keyValuePairs.Add(key, value);
            }
            public string get(string key) {
                return keyValuePairs[key];
            }
        }
        class A
        {
            public void view() {
                Console.WriteLine("用户名："+ Data.get("user")); 
            }
        }
        class B
        {
            public void viewA(string user) {
                Data.Add("user", user);
            }
        }
    }
}

7内容耦合

using System;

namespace 耦合与内聚实验
{
    class 内容耦合7
    {
        public static void main() {
            Console.WriteLine("---内容耦合7");
            A a = new A();
            B b = new B();
            b.a = a;
            b.viewA("当一个模块直接使用另一个模块的内部数据");
        }
    }
    class A {
        public string a;
        public void view() {
            Console.WriteLine(a);
        }
    }
    class B {
        public A a;
        /// <summary>
        /// 当一个模块直接使用另一个模块的内部数据，或通过非正常入口转入另一个模块内部时。
        /// </summary>
        /// <param name="data"></param>
        public void viewA(string data) {
            a.a = data;
            a.view();
        }
    }
}

3.运行结果

耦合与内聚实验

---无直接耦合1
数据处理：子模块无需知道对方的存在，子模块之间的联系，全部变成子模块和主模块之间的联系

---数据耦合2
值传递

--标记耦合3
引用传递

---控制耦合4
表示:指一个模块调用另一个模块时，传递的是控制变量，被调用模块通过该控制变量的值有选择地执行模块内的某一功能

---外部耦合5
一组模块都访问同一全局简单变量而不是同一全局数据结构

---公共耦合6
用户名：xjc

---内容耦合7
当一个模块直接使用另一个模块的内部数据

引用

耦合度举例分析、结合面向对象5关系分析、耦合度再分类_科学的发展-只不过是读大自然写的代码的博客-优快云博客_耦合度分析

内聚与耦合_cyyJames的博客-优快云博客_内聚和耦合

耦合和内聚-图解7种耦合关系_花无凋零之时的博客-优快云博客_耦合和内聚