Chapter 1 Vocabulary

Class - Object - instance-of relationship - type

encapsulation

data hiding - abstraction

message - method (instance vs class method)

argument - return value

data value (instance vs class)

variable - constant

inheritance - superclass - subclass

What goes in a Program?

Information (state)
Perform Actions (operations) on that information
- Modify/transfer data (changes state)
How should these be organized?

Example: Monopoly

What are the different components of the game?

Players
Board
dice
cards
bank/money
the game (controls action)

What does the player need to know? (information/state)

What does the player need to do? (operations/methods/actions/procedures)

What does the player need to communicate to the other components? (Messages)

What do other components need to communicate a player? (Messages)

Encapsulation

Package together everything the player knows and can do.
Package together everything the pair of dice knows and can do.
...

Abstraction/ Information Hiding

Define interface to the outside world that hides all the gory details.

For example:

The player can ask the pair of dice to roll and to report the result back to the player. Player does care how the pair of dice achieves its roll as long as it does it correctly.
The game can ask the deck of cards to shuffle itself.
The player might ask the deck of cards to deal it a card.
The game can ask the play to take its turn.

Components of Object Oriented Language

Classes
Objects
Message Passing
Inheritance

Classes and Objects

A class is a description/definition of the "encapsulated package".
An object is the instantiation of the class. The class must have been created before one can create an object. Each object consists of:
- identity (e.g. name)
- state (variables, current conditions, information/data)
- methods (operations, actions/processes that change state)

Player Class vs. Player Object

There may be many players in a game of monopoly. Each player is the same in that each must store a value for its location, money, etc. However, the specific value will be different for each player. The class defines the structure of the player. Each player object will have that structure but the values stored in that structure will be different.

The class defines the type.
We say that Tabby and Scooby are objects of type Player.

Data

The information an object knows (data) is stored in memory. We give the memory locations names so that we can refer to them. It is important to differentiate between the of the location and the value stored at the location. For example, we might want to store two pieces of data, comChest (location of community chest) and numDice (number of dice):

comChest = 2

numDice = 2

Both have the same value but represent different data.

At a later time, we might set

comChest = 4

The location comChest now has a different value than it had before.

Data: Constants vs. Variables

Data can be constant meaning it's value is set once and never changes. For example, the position of the "go to jail" square is always square 10. Thus we might make the data item called jail to be constant:

jailPosition = 10 (we'll make this a constant)

On the other hand, the position of the player changes over the course of the game so we store a player's current position in something called a variable:

playerPosition = 5 (we'll make this a variable)

The name of the memory location stays the same but the value of playerPosition will change over the course of the game.

Message, Methods, Return Values

The "world" is populated by objects. These objects communicate by sending messages to each other.
To send a message to an object, that object must have a method that knows how to process the message.
The method may also return a value to the object that sent the message.

In the above picture, the message roll(2) is said to have one argument whose value is 2.

Graphical Representation

When designing a program, we plan out what classes we using diagrams:

Classes are represented with rectangles with sharp corners.
Objects are represented with rounded rectangles.
Carefully look over Figure 1.8 in text.

Class vs Instance Data

Each player has a board position (playerPosition) that will be different from the positions of all of the other players. However, we may also want each player to keep track of whose turn it currently is (whoseTurn). While the value of whoseTurn will change over the course of the game, its value should be the same for all players at any instant in time. We can define

instance variable: playerPosition

class variable: whoseTurn

A class variable is defined once for all objects of a given class whereas an instance variable is defined separately for each object in the class.

Methods can also be instance or class. We'll see how these work a little later.

Inheritance

Inheritance forces a common structure onto classes that share components but otherwise are different.
Inheritance saves time by reusing existing classes. Existing classes may be similar but not identical to classes you need. Inheritance enables to extend the structure/functionality of an existing class so as to fit your needs.
We call Employee the superclass or ancestor or parent of the Manager and LowlyWorker classes.
We call Manager and LowlyWorker subclasses or descendants or children of the Employee class.
Subclasses inherit data and methods from the superclass.
A method in the subclass with the same name as a method in the superclass is said to override the method in the superclass.
Many of the classes you will be writing will inherit from existing classes.

Practice

Create a Person class: Do exercise 3 on page 34. Draw the class as well as an instance of the class.
Use inheritance to create a Student and Staff class from your person class.

next lecture