Object Oriented Design

Chapter 13: Object Oriented Design

Chapter Goals

To learn about relationships between classes
To learn how to discover classes and member functions
To learn the CRC card method
To gain an understanding of UML class diagrams
To learn how to use object-oriented design to build complex programs
To study an example of the object-oriented design process

Relationships between Classes

When designing a program, it is useful to document the relationships between classes.
- For classes with common behavior, you can save effort by placing the common behavior in a base class.
- For classes that are not related to each other, you can assign different programers to implement each of them.
The inheritance relationship is a very important relationship between classes - a more general class (the base class) and a more specialized class (the derived class).
This relationship is often described as the is-a relationship.
- Every truck is a vehicle.
- Every square is a rectangle.
- Every manager is an employee.

Inheritance, although useful, can be over-used.
Should a class Tire be derived from a Circle class?
Conceptually, the arrangement does not make sense. It is not true that every tire is a circle. Tires are car parts, whereas circles are geometric objects.

A tire has a circle as it's boundary.

class Tire  { 
...
private:
   string rating;
   Circle boundary;
};

The term for this relationship is association.

Every car is a vehicle. Every car has a tire (several tires, actually).

class Car : public Vehicle {
   ...
private:
   vector<Tire> tires;
};

In UML notation, association is denoted by a solid line with an arrow at the tip.

A class is associated with another if you can navigate from objects of one class to objects of the other class.
Example: You can navigate from a Car object to the Tire object, so these classes are associated.

A class depends on another class if one of its member functions uses an object of the other class in some way.

class Coin { 
public: 
   Coin(double v, string n);
   double get_value() const;
private:
   ...
};

class Purse { 
public:
   Purse();
   void add(Coin c);
   double get_total() const;
private:
   ...
};

The association relationship is related to the dependency relationship. Association is a stronger form of dependency.
If a class is associated with another, it also depends on the other class.
If a class depends on another, it comes in contact with objects of the other class in some way, not necessarily through navigation.

In the field of software engineering, the Unified Modeling Language (UML) is a standardized specification language for object modeling. UML is a general-purpose modeling language that includes a graphical notation used to create an abstract model of a system, referred to as a UML model.
The arrows in the UML notations can get confusing; the table shows the relationships symbols used in the book.

Implementing Associations

Associations between classes are usually implemented in data fields.
You need to make two important choices:
- Do you store a single object, or a vector of objects?
- Should you store objects or pointers?
First decide what the multiplicity of the association is:
- 1 : many (ex. every company has many employees)
- 1 : 1 (ex. every bank account has one owner)
- 1 : 0 or 1 (every department has 0 or 1 receptionist)
For a "1 : many" relationship, you need to use a vector (or some other data structure).

You use pointers in three circumstances.
- For a "1 : 0 or 1" relationship
- For object sharing
- For polymorphism, to refer to an object that may belong to a base class or a derived class.
Examples:
- Since multiple bank accounts could share the same owner, it makes sense to use a pointer.
```
class Bank Account {
   ...
private:
   Person* owner;
};
```
- A vehicle has multiple tires, but a tire can only be part of a single vehicle.
```
class Vehicle {
   ...
private:
   vector<Tire> tires;
};
```

Example: An Educational Game (Requirements)

You task is to write a game program that teaches your baby sister how to read the clock.
The game must:
- Randomly generate a time.
- Draw a clock face with that time.
- Ask the player to type in the time.
The player gets two tries to guess the time before the game displays the answer.
The score increases by one point each time the player guess the time correctly.

The game has four difficulty levels:
- Level 1: full hours.
- Level 2: 15 minutes intervals
- Level 3: 5 minute intervals
- Level 4: all possible times (1 minute intervals)
When the player scores 5 points the game automatically advances to the next level.
The game begins by asking for player's name and starting level.
After every round the player is asked whether she wants to play more.

CRC Cards

In the design phase of software development, your task is to discover structures that make it possible to implement a set of tasks on a computer.
- Discover classes.
- Determine the responsibilities of each class.
- Describe the relationships between the classes.
A simple rule for finding classes is to look for nouns in the task description.
First we list the nouns:

Player Clock Time

Level Game Round

Once a set of classes had been identified, you need to define the behavior (member functions) for each classes.
A simple rule for finding member functions is to look for verbs in the task description, and then match the verbs to the appropriate objects.

In the CRC card method, you create an index card for each class.
CRC stands for "classes", "responsibilities", "collaborators."
As you think about the verbs in the task description, pick the card of the class that you think should be responsible, and write that responsibility on the left-hand side of the card.
For each responsibility, you record on the right-hand side of the card which other classes (the collaborators) are needed to fulfill it.

Clock

draw Time

set time

As you list responsibilities and collaborators, think about the member functions the collaborators might need to help with the task.
Responsibilities that you list on the CRC card are on a high level, and may need two or more member functions for carrying out.
The CRC method is an informal process:
- Be creative and discover the classes and their responsibilities.
- Cross out, move, or split responsibilities.
- Rip cards up if they become too messy.

Example: An Educational Game (CRC Cards)

First we list the nouns:

Player Clock Time

Level Game Round
Level is just an integer between 1 and 4; it doesn't need a class.
Start with a simple class: the Clock class.
When a clock draws itself, it must draw the hands to show the current time.
To get the current time, it must collaborate with the Time class.

How does the clock know what time it is? You need to tell it:

Clock

draw Time

set time

The Time class must be able to get the hours and minutes of a given time and check when two times are the same.

Time

get hours and minutes

check if equal to another Time object

A player has a name, a level, and a score.
When the player gets a correct answer, the score must be incremented.

After five score increments, the level is incremented - we will let the increment score function take care of that, but we must be able to find out what the level is.

Player

increment score

get level

A good plan is to introduce a class that represents the entire program:

Game

play

What does it mean to play a game?

read player information
do
{  play a round
   ask whether player wants to play again
}
while (player wants to play again);

New actions are added to the game class based on this pseudocode.

Game

play

read player information

Whose responsibility is it to play a round?
- The Game class or
- The Player class
It probably doesn't matter, so we will choose the Game class.
What happens in a round?
- Make a time (uses Time class).
- Draw a clock (uses Clock class).
- Ask for input (uses Player class).
- Check input (uses Clock class)
- Ask again or increment score (uses Player class).

Game

play Player

read player information Clock

play round Time

There is no need for Round and Level classes, so do not implement them.

Example: An Educational Game (UML Diagram)

The collaborator columns of the CRC cards indicate part of the relationship between class, but which are dependencies and which are associations?
Since the same player must be manipulated for several rounds, you can't just construct local player objects.
The Game object must have a data field of type Player and a have the play round function modify its state (association).
The Clock and Time classes to not need to be associated with the Game class (dependencies).
The set time functions from the Clock class suggests that the Time class is associated with the Clock class.

Example: An Educational Game (Class and Function Comments)

The Clock class:

class Clock {
public:
   /**
      Sets current time.
      @param t the time to set
   */
   void set_time(Time t);

   /**
      Draws the clock face, with tick marks and hands.
   */
   void draw() const;
};

The Player class:

class Player {
public:
   /** 
      Increments the score. Moves to next level if
      current level complete.
   */
   void increment_score();

   /**
      Gets the current level.
      @return the level
   */
   int get_level() const;
};

The Game class:

class Game {
public:
   /**
      Plays the game while the player wants to continue
   */
   void play();
   
   /** 
      Reads player name and level.
   */
   void read_player_information();

   /**
      Plays a round, with up to two guesses.
   */
   void play_round();
};

Before reinventing the wheel, determine if you can use the Time class that is part of the book before designing a new class.
To use the Time class from the book, you must set seconds to zero. (Seconds has no use in our game).
To see whether two times are identical, check whether there are zero seconds from the first time to the second time.
```
time1.seconds_from(time2) == 0
```