zoukankan      html  css  js  c++  java
  • 内聚和耦合(自己的理解)

    网上对于内聚和耦合的资料太多,这里结合我的感受和其他人的答案http://blog.csdn.net/zhiquan/article/details/4255161谈谈自己的理解

    以下是我对内聚和耦合的理解(例子来源于生活)。

      1.内聚:

        i.偶然内聚:如果一个模块的各成分之间毫无关系,则称为偶然内聚。

          eg.在敲代码时,我们通常对一段代码进行初始化function init(){}。而对各个模块进行的初始化代码通常都是没有关系的,我们将这些代码包装成一个模块,此时这个模块就是偶然内聚的(杨老师在课上提出过这种内聚方式)。

        ii.逻辑内聚。几个逻辑上相关的功能被放在同一模块中,则称为逻辑内聚。如一个模块读取各种不同类型外设的输入。尽管逻辑内聚比偶然内聚合理一些,但逻辑内聚的模块各成分在功能上并无关系,即使局部功能的修改有时也会影响全局,因此这类模块的修              改也比较困难。

          eg.通过模块读取参数不同来执行不同的方法,我感觉类似于函数的重载。在我的快乐运算中有通过传入的参数判断执行的具体方法。此时属于逻辑内聚。代码自:https://github.com/yanyige/CourseWork/blob/master/Week6/js/generation.js):

            其中,通过传入的参数来确定生成算式的不同。

        iii.时间内聚。如果一个模块完成的功能必须在同一时间内执行(如系统初始化),但这些功能只是因为时间因素关联在一起,则称为时间内聚。

          eg.这里例子同偶然内聚,将没有关系(只是时间因素的关系)的代码包装到一起,构成一个代码块。

        (4) 过程内聚。如果一个模块内部的处理成分是相关的,而且这些处理必须以特定的次序执行,则称为过程内聚。

          eg.在快乐运算中,显示每条答案时候必须先计算所有题目(每次生成5道题)的答案,再依次显示到相应位置中。此时,先生成,再计算,最后显示,形成了过程内聚。代码自:https://github.com/yanyige/CourseWork/blob/master/Week6/js/generation.js):

          

    function showFormula(items) { //显示公式并且计算答案
    
    
    
        for(var j = 0 ; j < items.length ; j++){
    
            var str = items[j];
            var strFormula = transforFraction(str);
            var text = document.getElementById("problem-table").children[0].children;
            text[j].children[1].innerHTML = strFormula;
            // console.log('strFormula = '+ strFormula);
            var S1 = [] // 保存运算符的栈
            var S2 = [] // 保存中间结果的栈
    
            for (var i = 0; i < str.length; i++) {
                // if (!isNaN(str[i])){
                if(str[i] instanceof Fraction){
                    S2.push(str[i]);
                }else if(isOperate(str[i])){
                    if(!S1.length){
                        S1.push(str[i]);
                    } else{
                        var s1Top = S1.pop();
                        S1.push(s1Top);
                        if(s1Top == '('){
                            S1.push(str[i]);
                        }
                        else{
                            var prior1 = getPriorty(s1Top);
                            var prior2 = getPriorty(str[i]);
                            if(prior1 < prior2){
                                S1.push(str[i]);
                            }else{
                                var tempOp = S1.pop();
                                S2.push(tempOp);
                                i --;
                            }
                        }
                    }
                }else if(str[i] == '('){
                    S1.push(str[i]);
                }else if(str[i] == ')'){
                    var tempOp = S1.pop();
                    while(tempOp != '('){
                        S2.push(tempOp);
                        tempOp = S1.pop();
                    }
                }
    
            }
    
            while(S1.length){
                var tempOp = S1.pop();
                S2.push(tempOp);
            }
    
    
    
            ANS = getAns(S2);        
    
            // anss.push(Number(ANS.toFixed(2)));
            // allAnss.push(Number(ANS.toFixed(2)));
            anss.push(ANS);
            allAnss.push(ANS);
    
        }
    }

        (5) 通信内聚。如果一个模块的所有成分都操作同一数据集或生成同一数据集,则称为通信内聚。

          eg.在快乐运算中,一次“小试牛刀”中的题目保存var allFormulas = [];这个数组中,每次计算或者添加算式均在操作此数组,这时形成了通信内聚。代码自:https://github.com/yanyige/CourseWork/blob/master/Week6/js/generation.js):

        

    var anss=[];
    var ANS;//记录结果
    var youranss = [];
    var score = 0;
    var tScore = 0;
    var allFormulas = []; //通信内聚
    var allAnss=[];//通信内聚
    var allYourAnss=[];//通信内聚

        (6) 顺序内聚。如果一个模块的各个成分和同一个功能密切相关,而且一个成分的输出作为另一个成分的输入,则称为顺序内聚。

          eg.在快乐运算中,计算方法(function showFormula(items){})接受生成方法(function getFormula(MAXNUM, MAXDIGIT, PUNCTUATION, BRACKET, DENOMINATOR){})的返回值item。此时形成了顺序内聚。

        
        (7) 功能内聚。模块的所有成分对于完成单一的功能都是必须的,则称为功能内聚。

          eg.在之前未完成作品计算器中,计算器中“取反”操作,“点击数字”操作,“点击运算符操作”,都是为了完成计算表达式。此时属于功能内聚。

      2.耦合

        (1)内容耦合。当一个模块直接修改或操作另一个模块的数据,或者直接转入另一个模块时,就发生了内容耦合。此时,被修改的模块完全依赖于修改它的模块。

          eg.我觉得在js的经典问题“闭包”中,产生了内容耦合。

        (2)公共耦合。两个以上的模块共同引用一个全局数据项就称为公共耦合。

          eg.在以前写代码时,容易在全局定义一个变量,此时在不同的函数中使用这个变量,就产生了公共耦合。

        (3)控制耦合。一个模块在界面上传递一个信号(如开关值、标志量等)控制另一个模块,接收信号的模块的动作根据信号值进行调整,称为控制耦合。

          eg.经常我们会在代码中做一个flag进行标记此时的状态,当flag为0时执行部分代码,flag为1时执行另一部分代码,此时产生控制耦合。

        (4)标记耦合。模块间通过参数传递复杂的内部数据结构,称为标记耦合。此数据结构的变化将使相关的模块发生变化。

          eg.两个模块之间传递复杂的数据结构(例如对象),就产生了标记耦合。

        (5)数据耦合。模块间通过参数传递基本类型的数据,称为数据耦合。

          eg.两个模块之间传递简单的数据结构(例如number、boolean等),就产生了标记耦合。

        (6)非直接耦合。模块间没有信息传递时,属于非直接耦合。

          eg.我觉得和初始化init()函数类似,若其中代码毫无关联,则产生了非直接耦合。

    以上就是我对内聚和耦合的理解。

  • 相关阅读:
    常用知识点集合
    LeetCode 66 Plus One
    LeetCode 88 Merge Sorted Array
    LeetCode 27 Remove Element
    LeetCode 26 Remove Duplicates from Sorted Array
    LeetCode 448 Find All Numbers Disappeared in an Array
    LeetCode 219 Contains Duplicate II
    LeetCode 118 Pascal's Triangle
    LeetCode 119 Pascal's Triangle II
    LeetCode 1 Two Sum
  • 原文地址:https://www.cnblogs.com/yyyyg/p/5407075.html
Copyright © 2011-2022 走看看