CS 696: Advanced OO
Spring Semester, 1997
Doc 2 Coupling

Doc 2 Coupling Slide # 1

References

Doc 2 Coupling Slide # 2

Strength of interaction between objects in system

Cohesion

Degree to which the tasks performed by a single module are functionally related

Doc 2 Coupling Slide # 3

Decomposable system

One or more of the components of a system have no interactions or other interrelationships with any of the other components at the same level of abstraction within the system

A nearly decomposable system

Every component of the system has a direct or indirect interaction or other interrelationship with every other component at the same level of abstraction within the same system

Design Goal

The interaction or other interrelationship between any two components at the same level of abstraction within the system be as weak as possible

Doc 2 Coupling Slide # 4

"Unnecessary object coupling needlessly decreases the reusability of the coupled objects"

"Unnecessary object coupling also increases the chances of system corruption when changes are made to one or more of the coupled objects"

Data Coupling (weakest ­ most desirable)

Control Coupling

Global Data Coupling

Internal Data Coupling (strongest ­ least desirable)

Content Coupling (Unrated)

Doc 2 Coupling Slide # 5

Using parameter lists to pass items between routines

Common Object Occurrence:

Object A passes object X to object B

Object X and B are coupled

A change to X's interface may require a change to B

Example

class Receiver
     {
     public void message( MyType X )
          {
          // code goes here
          X.doSomethingForMe( Object data );
          // more code
          }
     }

Doc 2 Coupling Slide # 6

X is a compound object

Object B must extract component object Y out of X

B, X, internal representation of X, and Y are coupled

Example: Sorting student records, by ID, by Name

class StudentRecord
     {
     String name;
     Long ID;
     
     public String getName()
          { return name; }

     // etc.
     }

SortedList cs696 = new SortedList();
StudentRecord newStudent;
//etc.
cs696.add ( newStudent );

Doc 2 Coupling Slide # 7

class SortedList
     {
     Object[] sortedElements = new Object[ properSize ];

     public void add( StudentRecord X )
          {
          // coded not shown
          Long IDa = X.getID();
          Long IDb = sortedElements[ K ].getID();
          if ( IDa < IDb )
               // do something
          else
               // do something else
          }
     }

Doc 2 Coupling Slide # 8

class SortedList
     {
     Object[] sortedElements = new Object[ properSize ];

     public void add( StudentRecord X )
          {
          // coded not shown
          if ( X.lessthan( sortedElements[ K ] ) )
               // do something
          else
               // do something else
          }
     }

Doc 2 Coupling Slide # 9

Interface Comparable
     {
     public boolean lessThan( Object compareMe ); 

     public boolean greaterThan( Object compareMe ); 
     public boolean equal( Object compareMe ); 
     }

class StudentRecord implements Comparable
     {
     public boolean lessThan( Object compareMe )
          {
          // compare student record to object compareMe
          }
     }

class SortedList
     {
     Object[] sortedElements = new Object[ properSize ];

     public void add( Comparable X )
          {
          // coded not shown
          if ( X.lessthan( sortedElements[ K ] )
               // do something
          else
               // do something else
          }
     }

Doc 2 Coupling Slide # 10

Code is neither C/C++ nor Java

int compareID( StudentRecord a, StudentRecord b )
     { // code not shown }

int compareName( StudentRecord a, StudentRecord b )
     { // code not shown }

SortedList myList = new SortedList();
myList.setCompair( compareID );

Doc 2 Coupling Slide # 11

typedef int (*compairFun ) ( <type>, <type> );

Doc 2 Coupling Slide # 12

B uses a parameter of the message to decide what to do

class Lamp {
     public static final ON = 0;

     public void setLamp( int setting ) {
          if ( setting == ON )
               //turn light on
          else if ( setting == 1 )
               // turn light off
          else if ( setting == 2 )
               // blink
     }
}

Lamp reading = new Lamp();
reading.setLamp( Lamp.ON );

reading.setLamp)( 2 );

Doc 2 Coupling Slide # 13

class Lamp {

     public void on() {//turn light on }
     public void off() {//turn light off }
     public void blink() {//blink }
}


Lamp reading = new Lamp();
reading.on();

reading.blink();

Doc 2 Coupling Slide # 14

B returns control information to A

Example: Returning error codes

Cure:
Use exceptions

class Test {
     public int printFile( File toPrint ) {
          if ( toPrint is corrupted )
               return CORRUPTFLAG;
          blah blah blah

     }
}


Test when = new Test();
int result =  when.printFile( popQuiz );
if ( result == CORRUPTFLAG )
     blah
else if ( result == -243 )

Doc 2 Coupling Slide # 15

class Test 
{
     public int printFile( File toPrint ) throws PrintExeception
     {
          if ( toPrint is corrupted )
               throws new PrintExeception();
          blah blah blah
     }
}

try
{

     Test when = new Test();
     when.printFile( popQuiz );
}
catch ( PrintException printError )
{
do something
}

Doc 2 Coupling Slide # 16

A method in one object makes a specific reference to a specific external object

A method in one object makes a specific reference to a specific external object, and to one or more specific methods in the interface to that external object

A component of an object-oriented system has a public interface which consists of items whose values remain constant throughout execution, and whose underlying structures/implementations are hidden

A component of an object-oriented system has a public interface which consists of items whose values remain constant throughout execution, and whose underlying structures/implementations are not hidden

A component of an object-oriented system has a public interface which consists of items whose values do not remain constant throughout execution, and whose underlying structures/implementations are hidden

A component of an object-oriented system has a public interface which consists of items whose values do not remain constant throughout execution, and whose underlying structures/implementations are not hidden

Doc 2 Coupling Slide # 17

Internal Data Coupling

Common Object Occurrence:

C++ Friends

Doc 2 Coupling Slide # 18

Common Object Occurrence:

C/C++ header files

Decrease coupling by:

Restrict what goes in header file

C++ header files should contain only class interface specifications

---

Doc 2 Coupling Slide # 19

Object Coupling

Cohesion measures the logical relationship among the items that comprise an object

Interface coupling is the coupling between an object and all objects external to it. Interface coupling is the most desirable form of object coupling. Internal coupling is coupling among the items that make up an object.

Doc 2 Coupling Slide # 20

Includes module coupling already covered

Weakest form of object coupling, but has wide variation

Sub-topics

Object abstraction decoupling

Selector decoupling

Constructor decoupling

Iterator decoupling

Doc 2 Coupling Slide # 21

Example: List items

class LinkedListCell
     {
     int cellItem;
     LinkedListCell* next;

     // code can now use fact that cellItem is an int
     if ( cellItem == 5 ) print( "We Win" );
     }

template <class type>
class LinkedListCell#2
     {
     type cellItem;
     LinkedListCell* next;

     // code does not know the type, it is just a cell item,
     // it becomes an abstraction
     }

Doc 2 Coupling Slide # 22

class LinkedListCellA
     {
     int cellItem;          
     LinkedListCell* next;

     if ( cellItem == 5 ) print( "We Win" );
     }

class LinkedListCellB
     {
     Object cellItem;          
     LinkedListCell* next;

     if ( cellItem.equals( "hi" ) ) print( "We Win" );
     }

interface ListItem
     {
     public operation1();

public operation2();
     }

class LinkedListCellC
     {
     ListItem cellItem;          
     LinkedListCell* next;

     if ( cellItem.operation1() ) print( "We Win" );
     }

Doc 2 Coupling Slide # 23

Selector Decoupling

class Counter
     {

     int count = 0;

     public void increment()      {  count++; }
     public void reset()      { count = 0; }
     public void display()      {
          code to display the counter
     }

"display" couples the counter object to an output object

The counter class is nearly useless do to this coupling

class Counter
     {
     int count = 0;

     public void increment()      {  count++; }
     public void reset()      { count = 0; }
     public String toString()      {return String.valueOf( count );}
     }
Doc 2 Coupling Slide # 24

Primitive methods are:

functionally cohesive, they perform a single specific function

small, seldom exceed five "lines of code"

A composite method is any method constructed from two or more primitive methods ­ sometimes from different objects

Constructors (not the same as class constructors)

Iterators

Doc 2 Coupling Slide # 25

Replacing

     public void display()      {
          code to display the counter
     }

public String toString()      {return String.valueOf( count );}

is an example of Selector decoupling.

By replacing a composite method (display) with a primitive method the Counter class is decoupled from the display device

This makes the Counter class far more useful

It also moves the responsibility of displaying the counter else where

Doc 2 Coupling Slide # 26

Constructors

class Calendar
     {

     public void getMonth( from where, or what)
          {
          }
     }

class Calendar
     {

     public static Calendar fromString( String date )
          {
          }
     }

Doc 2 Coupling Slide # 27

• Defined in the standard for the implementation language

  This can include standard libraries and standard environments

  
  

• Globally known

  This is objects that are known in any part of any application created using the implementation language

Doc 2 Coupling Slide # 28

class Date
     {
     int year;
     int month;
     int day;
     }

Doc 2 Coupling Slide # 29

Iterator

Allows the user to visit all the nodes in a homogeneous composite object and to perform some user-supplied operation at each node

     List grades = new List();

     // add some grades 

     while ( grades.nextpointer != null )
          {
          grades = grades.nextpointer^;
          print( grades.examName )
          }

     for ( int k = 0; k < grades.length(); k++ )
          print( grades.getExamNameAt( k ) );

Doc 2 Coupling Slide # 30

class List
     {
     Object[] listElements = new Object[ size ];

     public void do( Function userOperation )
          {
          for ( int k = 0; k < listElements.length(); k++ )
               userOperation( listElements[ k ] );
          }
     }

In Main

     List grades = new List();

     aFunction = ( item ){ print( item ) };

     grades.do ( aFunction );

Doc 2 Coupling Slide # 31

List grades = new List();

Enumeration gradeList = grades.elements();

while ( gradeList.hasMoreElements() )
     {
     listItem = gradeList.nextElement();
     print ( listItem );
     }

public interface Enumeration {
    /**
     * Returns true if the enumeration contains more elements; false
     * if its empty.
     */
    boolean hasMoreElements();

    /**
     * Returns the next element of the enumeration. Calls to this
     * method will enumerate successive elements.
     */
    Object nextElement();

Doc 2 Coupling Slide # 32

Inside Internal Object Coupling

Coupling between state and operations of an object

Solution: Access state via access operations

C++ implementation
Provide private functions to access and change each data member

Simple Cases:

One function to access the value of the date member

One function to change the value of the data member

Only these two functions can access the data member

Doc 2 Coupling Slide # 33

class Counter
{
public:
     void increment(void);

private:
     int  value;
     
     void  setValue(int newValue);

     int  getValue(void);
};

void Counter::increment(void)    //Increase counter by one
{
     setValue(getValue() + 1);
};

void Counter::setValue(int newValue)
{
     value = newValue;
};

int Counter::getValue
{
     return value;
};

Doc 2 Coupling Slide # 34

Outside Internal Coupling from Underneath

Major Issues:

€ Access to inherited state

Direct access to inherited state

See inside internal object coupling

Access via operations

Inherited operations may not be sufficient set of operations to access state for subclass

€ Unwanted Inheritance

Parent class may have operations and state not needed by subclass

Unwanted inheritance makes the subclass unnecessarily complex. This reduces understandability and reliability.

Doc 2 Coupling Slide # 35

Class A and B are not related via inheritance

Main causes:

Using nonobject-oriented languages

Special language "features"

C++ friends

Doc 2 Coupling Slide # 36

integer, float, string, boolean

Classes define structures

methods

internal state information

exportable constants

etc.

Smalltalk has classes but no type

C++ tightly couples the type hierarchy with the class hierarchy

That is a user defined type A can be a subtype of B if and only if A is a subclass of B