Think of data as a wallet full of cash. The more people who handle your wallet before giving it back to you, the greater the chance that someone takes money out of that wallet (manipulating the data). Ideally, you want as few people to handle your wallet as possible and if people absolutely must handle your wallet, you want them close enough so you can keep an eye on them.

Figure II.7-5. Encapsulation isolates a chunk of code as an independent object.

That's the same idea behind encapsulating data inside an object. In a program divided into multiple subprograms, data gets passed around like a hot potato. The more subprograms capable of changing a chunk of data, the more likely one of those subprograms can accidentally change that data incorrectly.

By encapsulating data inside of an object, you prevent anything outside that object from manipulating the data.

After you isolate data inside an object, you also need to isolate all the subprograms that manipulate that data inside that same object. By storing all subprograms that manipulate the same data, objects make it easy to isolate any problems.

If data inside an object gets messed up, the faulty subprogram can be located only inside that same object. This makes troubleshooting easier. In comparison, if data gets messed up in a non-object-oriented program, the faulty subprogram could be located anywhere. Trying to find a faulty subprogram in an object is like trying to find your lost keys in your apartment. Trying to find a faulty subprogram in an entire program is like trying to find your lost keys in a 20-story apartment building.

Objects isolate data from other parts of the program, but objects can also isolate subprograms from other programmers.

Without objects, someone might write a useful subprogram that everyone else working on the program can use. One programmer might find that subprogram perfect whereas a second programmer might find that subprogram doesn't quite do what he wants it to do, so he goes into the subprogram and changes the code.

These changes wreck the subprogram for the first programmer, who now has to go back and fix the changes made by the second programmer. These changes make the subprogram work good for the first programmer, but now wreck the subprogram for the second programmer, and so on in an endless cycle.

The problem is that the more people you have working on the same program, the more likely someone might accidentally modify one part of a program without notifying the other programmers. Even one change in a program can affect another part of that same program, so object-oriented programming defines distinct boundaries that keep programmers from modifying code stored in objects created by someone else.

When creating an object-oriented program, every programmer is given control of certain objects and no one is supposed to modify the code in any objects but his own.

Objects let you physically store the source code for your entire object in a separate file, called a class file or just a class. At this point, a class is no different than storing a group of related subprograms in a separate file and keeping other programmers from modifying that separate file. However, the difference becomes more apparent when you want to reuse code.

A hybrid language is simply a language originally designed without object-oriented features, but with object-oriented features added on. Some popular examples of hybrid languages include

Because hybrid languages are based on popular languages, they make it easy for current programmers to understand and use. Unlike "pure" object-oriented languages that force you to design a program completely around objects, hybrid languages let you write programs by using the traditional task-oriented, subprogram approach and only using object-oriented features sparingly until you get comfortable with using and designing programs with OOP.

Because hybrid languages are based on languages that have been around for decades, a hybrid language lets you take an existing program and add object-oriented features to it. COBOL programs have been around since the 1960s, so companies are reluctant to rewrite working programs in another language just to gain object-oriented features. Rather than rewrite a perfectly working COBOL program in C++, programmers can just use Object Oriented COBOL instead, which effectively extends the life of ancient COBOL programs.

Although programmers can quickly adapt to the object-oriented language based on a language they already know, most programmers tend to stick with writing programs the way they've always done it, which often means not using object-oriented programming techniques at all or using the object-oriented features poorly.

To get around this problem, computer scientists have developed pure object-oriented languages, which forces programmers to use object-oriented techniques whether they like it or not. Some popular pure OOP languages include

By forcing you to use object-oriented programming techniques, pure object-oriented languages make sure that every program written in that particular language can be easily understood in terms of objects. A program written in a hybrid language can be as sloppy as a native Arabic-speaker writing a letter in both Arabic and English. A program written in a pure object-oriented language may be sloppy and poorly written, but it's like forcing a native Arabic-speaker to write a letter completely in English, so at least it's easier for English speakers to understand.

So which type of language should you learn and use? If you need to update programs written in older programming languages, like C, BASIC, or Pascal, you have no choice but to update those programs by using a hybrid language.

Ultimately, it's probably best to force yourself to know at least one pure object-oriented language so you fully understand the benefits of OOP and put those benefits into practical use. After you completely understand how to design and use object-oriented techniques, you're more likely to use OOP features in a hybrid language.

Despite its clear-cut advantages, object-oriented programming isn't perfect and suffers its share of drawbacks:

Like all programming techniques, such as structured programming, object-oriented programming isn't a magical solution for writing large programs flawlessly. Instead, object-oriented programming is more of a guideline for steering you into using proven techniques for organizing programs and making them easier to modify and update.

The ultimate goal of any programmer is to write software that works, is easy to fix and modify, and gets completed on time. If you can achieve these three goals on a consistent basis, you'll always have plenty of people willing to hire you at whatever salary you want.

To create an object, you must first create a class, stored in a separate file that defines

At the simplest level, a C++ class consists of the class keyword along with a descriptive name for your class, such as

class ClassName
{
};

So if you wanted to name your class animal, your class would now look like this:

class animal
{
};

Next, you need to define the public data (properties) and subprograms (methods) by using the public keyword. Then you must define the private data and subprograms by using the private keyword, such as

class animal
{

public:

private:

};

Underneath both the public and private keywords, you must declare your data and subprograms. If you wanted to define an X coordinate and Y coordinate variable as public and an X variable as privateh, you'd do this:

class animal
{
public:
  int x_coordinate;
  int y_coordinate;

private:
  int x;

};

The preceding code creates three integer variables — x_coordinate, y_coordinate, and x. After you define the data your object will use, the next step is to define the subprograms it'll use, such as

class animal
{
public:
  int x_coordinate;
  int y_coordinate;

  void initial_position (int, int);
  void move(int, int);

private:
  int x;

};

The preceding code defines two subprograms (methods) — initial_position and move. The initial_position and move subprograms both accept two integers in their parameter list. After you define the names of the subprograms you want to use, you have to write the actual code to make each subprogram work, such as

class animal

{
public:
  int x_coordinate;
  int y_coordinate;

  void initial_position (int, int);
  void move(int, int);

private:
  int x;

};


void animal::initial_position (int init_x, int init_y);
  {
  x_coordinate = init_x;
  y_coordinate = init_y;
  }

void animal::move (int new_x, int new_y);
  {
  x = 5;
  x_coordinate = x_coordinate + new_x + x;
  y_coordinate = y_coordinate + new_y;
  }

The initial_position subprogram defines an initial value for the two public variables x_coordinate and y_coordinate.

The move subprogram adds a new value to the current x_coordinate and y_coordinate values. This subprogram also uses the private variable (x), sets its value to 5, and uses that value to modify the value of the x_coordinate variable.

At this point, you've defined a class. The next step is to use this class in an actual program.

Before you can use a class in your program, you need to

If you stored the animal class in an "animal.h" file, you'd tell your main C++ program to use this "animal.h" file by using the include command like this:

#include "animal.h"

Next, you'd have to define an object name and declare it as an object based on a class. So if you wanted to create a cow object with the animal class, you'd use this:

#include "animal.h"

int main()
  {
  animal cow;
  return 0;
  }

#include <stdio.h>
#include <iostream.h>
#include "animal.h"

int main()
  {
  animal cow;
  return 0;
  }

After you define an object in your main program, you can run a subprogram stored in that object. So if you wanted to run the initial_position subprogram, stored in the cow object, you'd identify the object name followed by the object's subprogram to run, such as

cow.initial_position (1,1);

The cow.initial_position (1,1) command tells the computer to use the cow object, run the initial_position subprogram stored in that cow object, and use the values 1 and 1.

If you wanted to run the move subprogram, you'd define the object name (cow) followed by the subprogram name (move) and wind up with a command like this:

cow.move (24,9);

Putting the whole program together, you might have something like this:

#include <stdio.h>
#include <iostream.h>
#include "animal.h"

int main()
  {
  animal cow;
  cow.initial_position (1,1);
  cout << "X-location = " << cow.x_coordinate << "
";
  cout << "Y-location = " << cow.y_coordinate << "
";
  cow.move (24,9);
  cout << "New X-location = " << cow.x_coordinate << "
";
  cout << "New Y-location = " << cow.y_coordinate << "
";
  cout << "
Press ENTER to continue..." << endl;
  getchar();
  return 0;
  }

If you ran this C++ program, the following would appear on-screen:

X-location = 1
Y-location = 1
New X-location = 30
New Y-location = 10

Press ENTER to continue...

To inherit an object, you must first create another class file. So if you wanted to create a human class and have it inherit from the animal class, you'd do this:

class human : public animal
{
};

The preceding code tells the computer that the human class inherits from the animal class. At this point, the human class is identical to the animal class.

To use the human class in the main program, you need to use the #include command, such as

#include <stdio.h>
#include <iostream.h>
#include "animal.h"
#include "human.h"

int main()
  {
  human cow;
  cow.initial_position (1,1);
  cout << "X-location = " << cow.x_coordinate << "
";
  cout << "Y-location = " << cow.y_coordinate << "
";
  cow.move (24,9);
  cout << "New X-location = " << cow.x_coordinate << "
";
  cout << "New Y-location = " << cow.y_coordinate << "
";
  cout << "
Press ENTER to continue..." << endl;
  getchar();
  return 0;
  }

In this version of the program, the cow object is declared to be a human class. Because the human class is identical to the animal class, this program runs identically as the preceding version where the cow object was declared as an animal class.

Although the human class behaves identically to the animal class, the human class is actually empty because it inherits all its code from the animal class. Now any code you add to the human class is unique just to that human class, such as

class human : public animal
{
public:
  int iq;

  void setiq (int);
  void iqtest (int);
};

void setiq (int startiq)
{
  iq = startiq;
}

void iqtest (int new_iq)
{
  iq = iq + new_iq;
}

Because this inherits all the code from the animal class, the human class is actually equivalent to the following, where the gray shaded code highlights the code unique to the human class:

class human
{
public:
  int x_coordinate;
  int y_coordinate;

  void initial_position (int, int);
  void move(int, int);

  int iq;

  void setiq (int);
  void iqtest (int);

private:
  int x;
};

void animal::initial_position (int init_x, int init_y);
  {
  x_coordinate = init_x;
  y_coordinate = init_y;
  }

void animal::move (int new_x, int new_y);
  {
  x = 5;
  x_coordinate = x_coordinate + new_x + x;
  y_coordinate = y_coordinate + new_y;
  }
void setiq (int startiq)
{
  iq = startiq;
}

void iqtest (int new_iq)
{
  iq = iq + new_iq;
}

As you can see, without inheritance, the code stored inside an object can soon grow out of control, but by using inheritance, each object contains only unique code.

An object that inherits code is treated no differently than an object created entirely from scratch. The following program shows how to use the human class:

#include <stdio.h>
#include <iostream.h>
#include "animal.h"
#include "human.h"

int main()
  {
  human cow;
  cow.initial_position (1,1);
  cout << "X-location = " << cow.x_coordinate << "
";
  cout << "Y-location = " << cow.y_coordinate << "
";
  cow.move (24,9);
  cout << "New X-location = " << cow.x_coordinate << "
";
  cout << "New Y-location = " << cow.y_coordinate << "
";
  cow.setiq (45);
  cout << "The cow's initial IQ is " << cow.iq << "
";
  cow.iqtest (26);
  cout << "The cow's IQ is now " << cow.iq << "
";
  cout << "
Press ENTER to continue..." << endl;
  getchar();
  return 0;
  }

Running this program displays the following on-screen:

X-location = 1
Y-location = 1
New X-location = 25
New Y-location = 10
The cow's initial IQ is 45
The cow's IQ is now 81

Press ENTER to continue...

After you inherit code from another object, you can use polymorphism to rewrite a subprogram. To use polymorphism, you may need to define which subprograms (methods) in an object can be changed with polymorphism.

In C++, you define a polymorphic subprogram by using the virtual keyword. So if you wanted to make the Move subprogram polymorphic in the animal class, you'd have to modify the animal class like this:

class animal
{
public:
  int x_coordinate;
  int y_coordinate;

  void initial_position (int, int);
  virtual void move(int, int);

private:
  int x;

};

After you define that the Move subprogram is polymorphic and can be changed inside an object, the second step is to use the virtual keyword a second time to identify the new version of the subprogram.

So if you want to change the Move subprogram inside the human class, you'd have to use the virtual keyword again like this:

class human : public animal
{
public:
  int iq;

  void setiq (int);
  void iqtest (int);
  virtual void move (int, int);
};

void setiq (int startiq)
{
  iq = startiq;
}

void iqtest (int new_iq)
{
  iq = iq + new_iq;
}
void move (int new_x, int new_y)
{
  x_coordinate = new_x * 2;
  y_coordinate = new_y * 2;
}

After identifying the polymorphic subprogram with the virtual keyword, you then need to rewrite the Move subprogram. In the preceding example, the new Move subprogram accepts two numbers (new_x and new_y), multiplies them by 2, and uses that result for the cow object's new X and Y coordinates.

So running the main program would now print the following on-screen:

X-location = 1
Y-location = 1
New X-location = 48
New Y-location = 18
The cow's initial IQ is 45
The cow's IQ is now 81

Notice that the main program now uses the Move subprogram stored in the human class, which multiplies each number by 2. So the cow.move (24, 9) command sets the cow's x_coordinate to 48 (24 * 2) and the y_coordinate to 18 (9 * 2).

Although these examples use C++, the basic steps to using objects remain the same: