Introduction: What is Object-Oriented Programming?

• What is Object-Oriented Programming?
  • What is An Object?
  • Sequential Operation
  • Method
  • Object's Data
• Object-Oriented Problem Solving Approach
• Object-Oriented Paradigm
  • Data Abstraction
  • Encapsulation
  • Polymorphism
  • Inheritance
• The Power of Reuse

Object-Oriented Programming (OOP) is different from procedural programming languages (C, Pascal, etc.) in several ways. Everything in OOP is grouped as "objects" (see data abstraction). OOP, defined in the purest sense, is implemented by sending messages to objects. To understand this concept, we first need to know what is an object?

What is An Object?

An object can be considered a "thing" that can perform a set of activities. The set of activities that the object performs defines the object's behavior. For example, a "StudentStatus" object can tell you its grade point average, year in school, or can add a list of courses taken. A "Student" object can tell you its name or its address.

The object's interface consists of a set of commands, each command performing a specific action. An object asks another object to perform an action by sending it a message. The requesting (sending) object is referred to as sender and the receiving object is referred to as receiver.

Control is given to the receiving object until it completes the command; control then returns to the sending object.

For example, a School object asks the Student object for its name by sending it a message asking for its name. The receiving Student object returns the name back to the sending object.

A message can also contain information the sending objects needs to pass to the reveiving object, called the argument in the message. A receiving object always returns a value back to the sending object. This returned value may or may not be useful to the sending object.

For example, the School object now wants to change the student's name. It does this by sending the Student object a message to set its name to a new name. The new address is passed as an argument in the message. In this case, the School object does not care about the return value from the message.

Sequential Operation

Method

Each message has code that associated with it. When an object receives a message, code is excercuted. In other words, these messages determine an object's behavior and the code determines how the object carries out each message. The code that is associated with each message is called a method. The message name is also called the method name due to its close association with the method.

When an object receives a message, it determines what method is being requested and passes control to the method. An object has as many methods as it it takes to perform its designed actions.

Refer to the following diagram, name, name:, address and name:address are method names for the Student object (Please see "Object and Message Naming" for more information). When the Student object receive the name message, the name message passes control to the name method defined in Student.

Methods that operate on specific objects are instance methods and messages that invoke instance methods are called instance message. Methods that operate on specific classes are class methods. This will be discussed in more details in later chapter.

Methods are similar to subroutines, procedures, or functions found in procedural languages (C, Pascal). For example, a method name equates to a subroutine name, and the code for the method equates to the code found in a subroutine. Sending a message to an object is similar to calling a subroutine.

See also "Basic Structure of a Method".

Object's Data

Refer to the following diagram, the instance variables variableOne through variableX can only be accessed by the sender via instance methods methodOne through methodX. The sender can not refer to the variables directly by itslef.

Unlike procedural progamming where common data areas are often used for sharing information, object-oriented programming discourages direct access to common data (other than the use of global variables) by other programs. Only the object that "owns" the data can change its contant. Other objects can view or change this data by sending message to the "owner."

The instance variable names can be identical to the method names that associate with them. For example, the Student object has methods of name, address, and major as well as instance variables of name, address, and major. Smalltalk distinguishes variable identifier and a method identifier by the identifier's position in the expression.

The object-oriented problem solving approach, in general, can be devided into four steps. They are: (1) Identify the problem, (2) Identify the objects needed for the solution, (3) Identify messages to be sent to the objects, and (4) Create a sequence of messages to the objects that solve the problem.

Following is an example of solution to a simple problem using the four steps.

Example 1: Object-oriented Problem Solving Approach

Step 1: Problem Identification - Compute the sum of two numbers and print out the result.

Step 2: Object Identification - Identify objects needed to solve the problem.

   Num1 - first number (object).
   Num2 - second number (object).
   Sum - result of the addition of the two numbers (object).

Step 3: Message Identification - Messages needed to send to objects.

   + aNum - This is the message sent to the receiver 
            object with an parameter aNum.  The result of 
            this message is the value (a numeric object) of the
            total sum of the receiver object and aNum.
   print - a message that displays the value of the receiver  
           object. 

   (Num1 + Num2)print

Note: The sequence of Smalltalk evaluation is from left to right unless is specified by parentheses ( ). For example:

               2 + 3 * 4               is 20
  while        2 +(3 * 4)              is 14

                       Inheritance??!!
 Data Abstraction???                        Encapsulation?!!?
         Reuse???          Polymorphism??
                                   Smalltalk??!!                          

The objective of this section is to provide a thorough understanding of the principles of object-oriented paradigm.

Data Abstraction

Encapsulation

In object-oriented programming, objects interact with each other by messages. The only thing that an object knows about another object is the object's interface. Each object's data and logic is hidden from other objects. In other words, the interface encapsulates the object's code and data.

This allow the developer to separate an object's implementation from its bahavior. This separation creates a "black-box" affect where the user is isolated from implementation changes. As long as the interface remains the same, any changes to the internal implementation is transparent to the user. For example, if the name message is sent to the Student object, it does not matter to the user how the developer implemented the code to handle this message. All the sending object needs is the correct protocol for interacting with the Student object. The developer can change the implementation at any time, but the name message would still work because the interface is the same.

Polymorphism

An analogy of polymorphism to daily life is how students response to a school bell. Every student knows the significant of the bell. When the bell (message) rings, however, it has its own meaning to different students (objects). Some students go home, some go to the library, and some go to other classes. Every student responds to the bell, but how they response to it might be different.

Another example of polymorphism is the function of printing. Every printable object must know how to print itself. The message is the same to all the different objects: print, but the actual implementation of what they must do to print themselves varies.

The sending object does not have to know how the receiving object implement the message. Only the receiving objects worries about that. Assume that there is a printPage method in a Document object that has the responsibility of printing a page. To print the page, the printPage method sends the print message to each object on the page. The Document does not need to know what types of objects are on the page, only that each object supports the behavior of printing.

New objects can be added to the page without affecting the printPage method. This method still sends the print message and the new object provides its own print method in response to that message.

Polymorphism allows the sending object to communicate with receiving objects without having to understand what type of object it is, as long as the receiving objects support the messages.

Inheritance

Let's use the following application as an example. Both Graduate class and Undergraduate class have similar bahavior such as managing a name, an address, a major, and a GPA. Rather than put this bahavior in both of these classes, the bahavior is placed in a new class called Student. Both Graduate and Undergraduate become subclass of the Student class, and both inherit the Student behavior.

Classes that inherit from a class are called subclasses. The class a subclass inherits from are called superclass. In the example, Student is a superclass for Graduate and Undergraduate. Graduate and Undergraduate are subclasses of Student.

Reusability is probably the most important and the strongest feature of Smalltalk. Although procedural languages can be reuse too, Smalltalk makes programming for reuse much easier.

Smalltalk Tutorial

Go to Chapter 1: Introduction to IBM Smalltalk Programming

Return to Main Page