CSC/ECE 517 Summer 2008/wiki2 c6 CohCoupling: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
Line 50: Line 50:


===Types of Cohesion===
===Types of Cohesion===
#Coincidental cohesion-A module has oincidental cohesion if its elements have no meaningful relationship to one another. It is explained with an example here [http://www.cs.unc.edu/~stotts/145/cohesion.html]
#Coincidental cohesion-A module has oincidental cohesion if its elements have no meaningful relationship to one another. It is explained with an example here. [http://www.cs.unc.edu/~stotts/145/cohesion.html]
#Logical cohesion-A module has Logical cohesion when parts of a module are grouped together as they are logically categorized to do the same thing, even if they are different by nature (e.g. grouping all I/O handling routines).
#Logical cohesion-A module has Logical cohesion when parts of a module are grouped together as they are logically categorized to do the same thing, even if they are different by nature (e.g. grouping all I/O handling routines). [http://www.cs.unc.edu/~stotts/145/logicalcohesion.gif Diagram]


== Coupling ==
== Coupling ==

Revision as of 11:33, 24 June 2008

Introduction

Cohesion and Coupling are two terms often used in object-oriented software development. They sound similar, but have very different meanings. Cohesion is the “act or state of sticking together” or “the logical agreement". It is the basic idea that a class has a focused set of responsibilities or behaviors from a particular perspective. In contrast to cohesion, Coupling refers to the physical connections between elements of the OO design (eg: the number of collaborations between classes or the number of messages passed between objects) within an OO system. In a simple way, it gives the measure of the interdependence of one module to another.

Problem Definition

Cohesion and coupling are concepts that are reasonably easy to understand, but nonetheless, it is worthwhile to gather readable illustrations of where they apply. Browse the hundreds of Web pages that attempt to explain these concepts, picking your favorite examples. Categorize these examples, so that the reader will see the big picture, rather than just a set of redundant illustrations. Many of these pages mention related concepts; list some of them and explain how they relate to cohesion and coupling.

Cohesion

Cohesion is the "glue" that holds a module together. It can be thought of as the type of association among the component elements of a module. Generally, one wants the highest level of cohesion possible. An object with high cohesion is defined for one purpose and it performs only that purpose. An object with low cohesion tends to try to do a lot of different things. For example, if our Card object was responsible for drawing itself, sending messages back to the server, and executing game logic, it would have low cohesion because that one class is attempting to do too much. A system can also have low cohesion if too many objects are attempting to do the same thing. For example, if a system has objects to implement a NetRunner game and every card has a unique class with a rendering method and that method is nearly identical in all classes, then the system has low cohesion. An example of a high cohesive EmailMessage class is given below [1].

class EmailMessage
{
   private string sendTo;
   private string subject;
   private string message;
   public EmailMessage(string to, string subject, string message)
   {
       this.sendTo = to;
       this.subject = subject;
       this.message = message;
   }
   public void SendMessage()
   {
       // send message using sendTo, subject and message
   }
}

The above class was originally designed to send an email message. Suppose if it is modified in the future in a way that the user needed to be logged in to send an email which is implemented by adding a Login method to the EmailMessage class.

class EmailMessage
{
   private string sendTo;
   private string subject;
   private string message;
   private string username;
   public EmailMessage(string to, string subject, string message)
   {
       this.sendTo = to;
       this.subject = subject;
       this.message = message;
   }
   public void SendMessage()
   {
       // send message using sendTo, subject and message
   }
   public void Login(string username, string password)
   {
       this.username = username;
       // code to login
   }
}

The Login method and username class variable really have nothing to do with the EmailMessage class and its main purpose which makes it a low cohesive class.

Types of Cohesion

  1. Coincidental cohesion-A module has oincidental cohesion if its elements have no meaningful relationship to one another. It is explained with an example here. [2]
  2. Logical cohesion-A module has Logical cohesion when parts of a module are grouped together as they are logically categorized to do the same thing, even if they are different by nature (e.g. grouping all I/O handling routines). Diagram

Coupling

Coupling can be defined as the amount of interaction of one object with another object, or one module with another module. For a good software design, it is always advisable to minimize coupling. Low coupling indicates that each object or module performs independent tasks. Strong coupling means that one object or module is dependent on other object or module to perform an operation or task. It simply means that the object or module is strongly coupled with the implementation details of another object or module. Disadvantages of strong coupling can result in less flexible, less scalable and high maintainance software application.

Measuring the degree of coupling

It is difficult to come to a common consensus to decide the appropriate amount of coupling. Object oriented metrics can be useful for measuring the right level of coupling.

In languages like Java, coupling can be measured in 3 different ways Java Tutorial-

1. Coupling Between Objects (CBO): CBO is defined as the number of non-inherited classes associated with the target class. It is counted as the number of types that are used in attributes, parameters, return types, throws clauses, etc. Primitive types and system types (e.g. java.lang.*) are not counted.

2. Data Abstraction Coupling (DAC): DAC is defined as the total number of referred types in attribute declarations. Primitive types, system types, and types inherited from the super classes are not counted.

3. Method Invocation Coupling (MIC): MIC is defined as the relative number of classes that receive messages from a particular class.

     MIC = nMIC / (N -1 )
     Where N = total number of classes defined within the project.
     nMIC = total number of classes that receive a message from the target class.

References