6.2 Classes

“ A class is basically a structure with member functions as well as member data. Classes are central to the programming methodology known as object-oriented programming.”

Procedural Programming

In procedural programming, we break down a program in terms of functions. Top-down design principles start with the problem at hand and finds a solution by breaking down the problem into steps that can be used to solve it. We begin with the major steps, and then break those down into smaller steps. This process is called stepwise-refinement.

Result

The result is a program in which functions play the major role. Data is merely passed to and from functions. Data may be structured (arrays, structs), but is secondary to the flow of control of the program. This is the procedural programming paradigm.

Object-Oriented Design

In object-oriented design, instead of thinking in terms of functions, we think in terms of objects. Objects are collections of related data along with the functions that apply to that data. Objects occur naturally in many problems, and so by thinking about what objects are needed to solve a problem, we often can create better solutions.

OOD - Example

Let's take a simple example: A clock.What is the data associated with a clock?What functions do we normally perform on that

data?

OOD – Another Example

A second example is a bank account. Let's take a simple form of a bank account – a checking account with interest.

What is the data?balance, APR

What are the functions?deposit, withdrawal, check balance, modify APR,

check APR

Implementation

In object-oriented programming, we call the functions that are part of an object its methods.

The data is stored in fields or components.

Object-Oriented Design

In object-oriented design the problem is decomposed into different objects that are inherent in the problem. The program relies on the interaction between the objects. The objects can call each others' methods. This is called message passing. A message is the name (and parameters) of the method to be called. Different types of objects may have methods with the same name, so which method is actually run depends on the object and the message.

OOD Example – Battleship Game

Consider the game Battleship. An example can be found at

http://www.superkids.com/aweb/tools/logic/bshipThis is a two player game, where each player has a

board full of ships, unseen by the other player. The players take turns shooting at squares on their opponents board. The opponent indicates when a ship is hit and when a ship is sunk (all spots are hit). The game is over when one player sinks all of the opponent's ships.

Battleship Implementation

What objects are necessary?ShipWaterHit Miss BoardPlayer?

Ships and Other Objects

Ship objects would have the following fields: name, position?, size, number of hits, symbol (for non-GUI version)

Ship objects would have the following methods: shootAt, place?, anything else?

Shooting a ship would increment the number of hits, and if the size is reached, sink the ship.

The other classes – Water, Hit, and Miss, would also have a shootAt method.

Board Object

The board would have a two dimensional array of Things (where a Thing is a Ship, Water, Hit, or Miss). The board would also have to remember the number of ships sunk.

The board would have the following methods: shootAt(x,y), display, placeShips.

Object Interaction

The main program would prompt the user for a shot, say (x,y), then call the board's shootAt(x,y) method (send the shootAt(x,y) message to the board).

The board object would, in turn, look up what object is at (x,y) (a Ship, Water, Hit, or Miss) and send a shootAt message to that object.

The board does not care what object is there. It sends the same shootAt message to the object, and depending on the object, the appropriate method is called.

Ship ShootAt

A ship object would react to the shootAt method by incrementing its number of hits (numHits) field, and if numHits == size, send a message to the board to increment its number of ships sunk (incrShipsSunk).

The object would also return an object that is to replace it on the board, in this case, a Hit object, which looks different, and avoids the problem of counting a second hit if the player shoots at the same spot more than once.

Pseudo-codeThe Ship's shootAt method would look like: if(++numHits == size) send the incrShipsSunk message to the board,return Hit;The Board's shootAt(x,y) method would look like:send the shootAt message to what's at (x,y), and set that position to be whatever is returned.

Water's shootAt method would just return a Miss.Hit and Miss would just return a Hit and Miss

object, respectively.

Main Program

The main program would first create the board and place the ships, and then have a loop which:

Reads in the player's move – (x,y)Sends the shoot(x,y) message to the boardDisplays the resultContinues until the board says that all the ships are

sunk (this would mean asking the board if all the ships are sunk)