CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2002 Coupling
	Previous    Lecture Notes Index    Next     © 2002, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 21-Mar-02

Object-Oriented Design Heuristics, Riel, Addison-Wesley, 1996

Doc 10, Coupling Slide # 2

100 functions each 100 line of code long is "better" than

One function 10,000 lines of code long

Doc 10, Coupling Slide # 3

• Modules based on steps needed to perform task

Write down in order list of high level tasks to be done

Each high level task becomes a module (function)

• Modules based on "design decisions"

List

Difficult design decisions

Design decisions that are likely to change

Each module should hide a design decision

Doc 10, Coupling Slide # 4

Doc 10, Coupling Slide # 5

Strength of interaction between objects in system

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

Doc 10, Coupling Slide # 6

Coupling

Relationships between Objects

Object A uses object B if A sends a message to B

Assume that A and B objects of different classes

A is the sender, B is the receiver

Class A contains class B when A has a field of type B

That is an object of type A will have an object of type B inside it

Doc 10, Coupling Slide # 7

Different Ways to Implement Uses

The receiver is a field in the sender

class Sender {
   Receiver here;
   
   public void method() {
      here.sendAMessage();
   }
}

The receiver is an argument in one of the sender's methods

class Sender {
   public void method(Receiver here) {
      here.sendAMessage();
   }
}
Doc 10, Coupling Slide # 8

The sender asks someone else to give them the receiver

class Sender {
   public void method() {
      Receiver here = someoneElse.getReceiver();
      here.sendAMessage();
   }
}

The sender creates the receiver

class Sender {
   public void method() {
      Receiver here = new Receiver();
      here.sendAMessage();
   }
}

The receiver is global to the sender

Doc 10, Coupling Slide # 9

Heuristics for the Uses Relationship

Doc 10, Coupling Slide # 10

Doc 10, Coupling Slide # 11

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

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

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

Doc 10, Coupling Slide # 12

Doc 10, Coupling Slide # 13

Doc 10, Coupling Slide # 14

Data Coupling

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

class ObjectBClass{
   public void message( ObjectXClass X ){
      // code goes here
      X.doSomethingForMe( Object data );
      // more code
   }
}
Doc 10, Coupling Slide # 15

Object A passes object X to object B

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

Doc 10, Coupling Slide # 16

class StudentRecord {
   Name lastName;
   Name firstName;
   long ID;
   
   public Name getLastName() { return lastName; }
   // etc.
}
SortedList cs535 = new SortedList();
StudentRecord newStudent;
//etc.
cs535.add ( newStudent );

Doc 10, Coupling Slide # 17

class SortedList
   {
   Object[] sortedElements = new Object[ properSize ];
   public void add( StudentRecord X )
      {
      // coded not shown
      Name a = X.getLastName();
      Name b = sortedElements[ K ].getLastName();
      if ( a.lessThan( b ) )
         // do something
      else
         // do something else
      }
   }
SortList>>add: aStudentRecord
   Blah
   a := aStudentRecord lastName.
   b := sortedElements at: k.
   blah
Doc 10, Coupling Slide # 18

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
   }
}
class StudentRecord{
   private Name lastName;
   private long ID;
   public boolean lessThan( Object compareMe ) {
      return lastName.lessThan( compareMe.lastName );
   }
   etc.
}
SortList>>add: aStudentRecord
   Blah
   aStudentRecord <  sortedElements last
      ifTrue: [ more blah ]
      ifFalse: [ blah blah ]
   blah
Doc 10, Coupling Slide # 19

interface Comparable {
   public boolean lessThan( Object compareMe ); 
   public boolean greaterThan( Object compareMe ); 
   public boolean equal( Object compareMe ); 
}
class StudentRecord implements Comparable {
   private Name lastName;
   private long ID;
   public boolean lessThan( Object compareMe ) {
      return lastName.lessThan( ((Name)compareMe).lastName );
   }
}
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
      }
   }
    
SortList>>add: anObject
   anObject <  sortedElements last
      ifTrue: [ more blah ]
      ifFalse: [ blah blah ]
   blah
Doc 10, Coupling Slide # 20

| sortedStudents |
   
sortedStudents := SortedCollection sortBlock: 
         [:x :y | x lastName < y lastName].
   
blah
   
sortedStudents 
   add: roger;
   add: pete;
   add: sam.
 

Doc 10, Coupling Slide # 21

typedef int (*compareFun ) ( StudentRecord, StudentRecord );
class SortedList {
   StudentRecord[] sortedElements = 
         new StudentRecord[ properSize ];
    int (*compare ) ( StudentRecord, StudentRecord );
   public setCompare( compairFun newCompare )
      { compare = newCompare; }
   public void add( StudentRecord X ) {
      // coded not shown
      if ( compare( X,  sortedElements[ K ] ) )
      // code not shown
   }
}
 
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 10, Coupling Slide # 22

Doc 10, Coupling Slide # 23

Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second

Indicates whether some other object is "equal to" this Comparator.

Doc 10, Coupling Slide # 24

import java.util. Comparator;
class Student  {
   String name;
   int id;
   
   public Student( String newName, int id ) {
      name = newName;
      this.id = id;
      }
   
   public String toString() {
      return name + ":" + id;
      }
   }
final class StudentNameComparator implements Comparator {
   
   public int compare( Object leftOp, Object rightOp ) {
      String leftName = ((Student) leftOp).name;
      String rightName = ((Student) rightOp).name;
      return leftName.compareTo( rightName );
   }
   
   public boolean equals( Object comparator ) {
      return comparator instanceof StudentNameComparator;
   }
}
Doc 10, Coupling Slide # 25

final class StudentIdComparator implements Comparator {
   static final int LESS_THAN = -1;
   static final int GREATER_THAN = 1;
   static final int EQUAL = 0;
   
   public int compare( Object leftOp, Object rightOp ) {
      long leftId = ((Student) leftOp).id;
      long rightId = ((Student) rightOp).id;
      if ( leftId < rightId )   
         return LESS_THAN;
      else if ( leftId > rightId )
         return GREATER_THAN;
      else
         return EQUAL;
   }
   
   public boolean equals( Object comparator ) {
      return comparator instanceof StudentIdComparator;
   }
}
Doc 10, Coupling Slide # 26

import java.util.*;
public class Test  {
   public static void main(String args[])  {
      Student[] cs596 = { new Student( "Li", 1 ), new Student( "Swen", 2 ), 
                                 new Student( "Chan", 3 ) };
      //Sort the array
      Arrays.sort( cs596, new StudentNameComparator() );
      for ( int k = 0; k < cs596.length; k++ )
         System.out.print( cs596[k].toString() + ", " );
      System.out.println( );
      
      List cs596List = new ArrayList( );
      cs596List.add( new Student( "Li", 1 ) );
      cs596List.add( new Student( "Swen", 2 ) );
      cs596List.add( new Student( "Chan", 3 ) );
      System.out.println( "Unsorted list " + cs596List );
      //Sort the list
      Collections.sort( cs596List,  new StudentNameComparator() );
      System.out.println( "Sorted list " + cs596List );
      //TreeSets are aways sorted
      TreeSet cs596Set = new TreeSet(  new StudentNameComparator() );
      cs596Set.add( new Student( "Li", 1 ) );
      cs596Set.add( new Student( "Swen", 2 ) );
      cs596Set.add( new Student( "Chan", 3 ) );
      System.out.println( "Sorted Set " + cs596Set );
   }
}
Doc 10, Coupling Slide # 27

Chan:3, Li:1, Swen:2, 
Unsorted list [Li:1, Swen:2, Chan:3]
Sorted list [Chan:3, Li:1, Swen:2]
Sorted Set [Chan:3, Li:1, Swen:2]
Doc 10, Coupling Slide # 28

import java.util.*;
public class MultipleSorts {
   public static void main(String args[]) {
      List cs596List = new ArrayList( );
      cs596List.add( new Student( "Li", 1 ) );
      cs596List.add( new Student( "Swen", 2 ) );
      cs596List.add( new Student( "Chan", 3 ) );
      
      Collections.sort( cs596List,  new StudentNameComparator() );
      System.out.println( "Name Sorted list " + cs596List );
      Collections.sort( cs596List,  new StudentIdComparator() );
      System.out.println( "Id Sorted list " + cs596List );
      TreeSet cs596Set = new TreeSet( new StudentNameComparator());
      cs596Set.addAll( cs596List );
      System.out.println( "Name Sorted Set " + cs596Set );
      TreeSet cs596IdSet = new TreeSet( new StudentIdComparator() );
      cs596IdSet.addAll( cs596List );
      System.out.println( "Id Sorted Set " + cs596IdSet );
   }
}

Name Sorted list [Chan:1, Li:2, Swen:1]
Id Sorted list [Chan:1, Swen:1, Li:2]
Name Sorted Set [Chan:1, Li:2, Swen:1]
Id Sorted Set [Chan:1, Li:2]
 
Doc 10, Coupling Slide # 29

Control Coupling

A sends a message to B

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 10, Coupling Slide # 30

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 10, Coupling Slide # 31

BankAccount>>withdrawal: aFloat
   balance := balance – aFloat.

BankAccount>>withdrawal: aFloat
   balance < aFloat
      ifTrue: [ self bounceThisCheck ]
      ifFalse: [balance := balance – aFloat]

Doc 10, Coupling Slide # 32

A sends a message to B

B returns control information to A

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 10, Coupling Slide # 33

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 10, Coupling Slide # 34

Global Data Coupling

Doc 10, Coupling Slide # 35

Internal Data Coupling

C++ Friends

Doc 10, Coupling Slide # 36

Lexical Content Coupling

C/C++ header files

Restrict what goes in header file

C++ header files should contain only class interface specifications

Doc 10, Coupling Slide # 37

Object Coupling

Doc 10, Coupling Slide # 38

Interface Coupling

Object abstraction decoupling

Selector decoupling

Constructor decoupling

Iterator decoupling

Doc 10, Coupling Slide # 39

Object Abstraction Decoupling

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 10, Coupling Slide # 40

class LinkedListCellA {
   int cellItem;      
   LinkedListCell next;
   if ( cellItem == 5 ) print( "We Win" );
}
class LinkedListCellB {
   Object  cellItem;
   LinkedListCell next;
   if ( cellItem.operation1() ) print( "We Win" );
}
Doc 10, Coupling Slide # 41

Selector Decoupling

class Counter{
   int count = 0;
   public void increment()    {  count++; }
   public void reset()    { count = 0; }
   public void display()    {
      code to display the counter in a slider bar
}

class Counter{
   int count = 0;
   public void increment()    {  count++; }
   public void reset()    { count = 0; }
   public int count()      {return count;}
   public String toString() {return String.valueOf( count );}
   }
Doc 10, Coupling Slide # 42

Primitive Methods

Functionally cohesive, they perform a single specific function

Small, seldom exceed five "lines of code"

Selectors (get operations)

Constructors (not the same as class constructors)

Iterators

Doc 10, Coupling Slide # 43

Selectors

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

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

Doc 10, Coupling Slide # 44

Constructors

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

class Calendar {
   public static Calendar fromString( String date ) { blah}
}
Doc 10, Coupling Slide # 45

• Defined in the standard for the implementation language

This can include standard libraries and standard environments

• Globally known

That is any object that is known in any part of any application created using the implementation language

Doc 10, Coupling Slide # 46

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

Doc 10, Coupling Slide # 47

Doc 10, Coupling Slide # 48

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

   List grades = new List();
   aFunction = ( item ){ print( item ) };
   grades.do ( aFunction );

Doc 10, Coupling Slide # 49

List grades = new List();
Iterator gradeList = grades.iterator();
while ( gradeList.hasNext() ){
   listItem = gradeList.next();
   print ( listItem );
   }

Doc 10, Coupling Slide # 50

int[] list 
for (int k = 0; k < list.length; k ++ )
   System.out.println( list[k] );

Vector list 
for (int k =0; k < list.size(); k++ )
   Sytem.out.println( list.elementAt( k ) );

BinarySeachTree list
Node current = list.root();
Stack previous = new Stack();
Previous.push( current );
while (current != null )
   {
   a lot of code here
   }
Doc 10, Coupling Slide # 51

String[] example = new String[10];
List listBackedByArray = Arrays.asList( example );

Doc 10, Coupling Slide # 52

Collection list;
Iterator elements = list.iterator();
while (elements.hasNext() ) {
   System.out.println( elements.next() );
}

Doc 10, Coupling Slide # 53

Inside Internal Object Coupling

Provide private functions to access and change each data member

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 10, Coupling Slide # 54

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 10, Coupling Slide # 55

Outside Internal Coupling from Underneath

• 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 10, Coupling Slide # 56

Outside Internal Coupling from the Side

Using nonobject-oriented languages

Special language "features"

C++ friends

"First create a solution using sound software engineering techniques, then if needed, introduce small violations of good software engineering principles for efficiency's sake."

Previous    visitors since 21-Mar-02    Next