Spring Semester, 2002
Coupling
© 2002, All Rights Reserved, SDSU & Roger Whitney
San Diego State University -- This page last updated 21-Mar-02
|
|
CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2002 Coupling |
|
|---|---|---|
|
© 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
|
Type |
Relation
between
|
|
Uses |
(Object) |
|
Containment |
(Object) |
|
Inheritance |
(Class) |
|
Association |
(Object) |
class Sender {
Receiver here;
public void method() {
here.sendAMessage();
}
}
class Sender {
public void method(Receiver here) {
here.sendAMessage();
}
}
3.
Ask
someone else
class Sender {
public void method() {
Receiver here = someoneElse.getReceiver();
here.sendAMessage();
}
}
class Sender {
public void method() {
Receiver here = new Receiver();
here.sendAMessage();
}
}
4.2 Minimize the number of message sends between a class and its collaborator
class ObjectBClass{
public void message( ObjectXClass X ){
// code goes here
X.doSomethingForMe( Object data );
// more code
}
}
Example: Sorting student records, by ID, by Name
class StudentRecord {
Name lastName;
Name firstName;
long ID;
public Name getLastName() { return lastName; }
// etc.
}
SortedList cs535 = new SortedList();
StudentRecord newStudent;
//etc.
cs535.add ( newStudent );
Solution 1 Bad News
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
Solution
2
Send
message to object to compare self to another StudentRecord Object
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
Solution
3
Program
to an Interface or "required operations"
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
Solution
4 Strategy
Pattern & Blocks
| sortedStudents |
sortedStudents := SortedCollection sortBlock:
[:x :y | x lastName < y lastName].
blah
sortedStudents
add: roger;
add: pete;
add: sam.
sortedStudents sortBlock: [:x :y | x grade < y grade ]Solution 4 Strategy Pattern & Function Pointers
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 );
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;
}
}
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;
}
}
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 );
}
}
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]
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]
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 );
Cure: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();
BankAccount>>withdrawal: aFloat balance := balance – aFloat.
BankAccount>>withdrawal: aFloat
balance < aFloat
ifTrue: [ self bounceThisCheck ]
ifFalse: [balance := balance – aFloat]
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 )
Cure:
Use exceptions
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
}
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
}
class LinkedListCellA {
int cellItem;
LinkedListCell next;
if ( cellItem == 5 ) print( "We Win" );
}
class LinkedListCellB {
Object cellItem;
LinkedListCell next;
if ( cellItem.operation1() ) print( "We Win" );
}
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 );}
}
public void display() {
code to display the counter
}
public String toString() {return String.valueOf( count );}
class Calendar {
public void getMonth( from where, or what) { blah }
}
class Calendar {
public static Calendar fromString( String date ) { blah}
}
class Date{
int year;
int month;
int day;
}
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 );
List grades = new List();
Iterator gradeList = grades.iterator();
while ( gradeList.hasNext() ){
listItem = gradeList.next();
print ( listItem );
}
|
Methods |
||
Enumeration |
Iterator |
ListIterator |
|
hasMoreElements() |
hasNext() |
hasNext() |
|
nextElement() |
next() |
next() |
|
|
remove() |
remove() |
|
|
|
nextIndex() |
|
|
|
hasPrevious() |
|
|
|
previous() |
|
|
|
previousIndex() |
|
|
|
add() |
|
|
|
set() |
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
}
String[] example = new String[10]; List listBackedByArray = Arrays.asList( example );
Collection list;
Iterator elements = list.iterator();
while (elements.hasNext() ) {
System.out.println( elements.next() );
}
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;
};