Back

Object Oriented Programming Fundamentals

By Jim Booth

Introduction

Object orientation, these words can wreak havoc in the minds of developers everywhere.  It doesn’t need to be this way though.  Object orientation is actually a much more direct method of mapping business problems to program code than any methods we have had in the past.

As an approach to system design and construction, object orientation is not a drastic change in how we build things.  The same principles that we have always used still apply. Spaghetti code is bad, structured code is good.  Encapsulating functionality into discrete blocks of code results in better maintainability.

However, object orientation requires that we adjust the way we think about what we do.  Changing methodology is fairly easy.  Most of us have learned more than one programming language in our careers and it wasn’t the end of the world. But changing the way we think, well that is another beast altogether.

What Is Object Orientation?

Object orientation is an approach to software development in which we focus on objects and their attributes and responsibilities.  All business problems involve things.  These things can be mapped to a set of objects, such as customers, invoices, etc. In any given business problem the various things have attributes like name, color, weight, etc and they have responsibilities such as initiate and order, fulfill an order, pay an invoice, etc.

The object oriented approach of system building starts with the earliest phase of analysis of the business problem.  In this early phase we center on identifying the objects involved and what their attributes and responsibilities are.  One interesting part of object orientation is that it closely parallels the real world, much more so than the traditional structured approach of system design.  This allows for a more thorough and accurate modeling of the business problem in the system design.

Object orientation can be defined as, a system of components which encapsulate data and function, inherit these things from other components, and communicate via messages with one another.

In the object oriented approach we not only identify the objects required, but we also organize them into classes of objects.

What Is the Difference Between a  Class and Object?

Edward Yourdan defines a class as, “A collection of one or more objects with a uniform set of attributes and services, including a description of how to create new objects in the class.”

Grady Booch defines an object as, “An object has state, behavior, and identity; The structure and behavior of similar objects are defined in their common class; The terms instance and object are interchangeable.”

From these two definitions we can see that there is a difference between a class and an object.  A class is the definition, or blueprint, for an object.  Classes don’t real ever exist, they are plans.  We use the class to create an object which has identity.  That is, an object exists, has values in its properties and can execute behaviors.

This difference between a class and an object is a subtle but very important one. It is analogous to visiting an architect to have a new house built.  The architect will draw up plans for the house that show all the rooms and elevations etc. However, you cannot move into the plans and live there.  The plans must be used to build a house.  The house is an object while the plans are a class.

Concepts of Object Orientation

Object orientation is more than classes and objects, it is a whole thought process about building applications.  An object oriented development language has many qualities that support the object oriented approach to system design and construction.

The concepts we will investigate are abstraction, specialization, encapsulation, inheritance, polymorphism, communication, and reuse.  The following sections discuss each of these concepts in detail.  You may find situation where the various concepts are in conflict with each other, that is fine because in the real world we often find our goals in conflict and we must make a decision and go with it.

Abstraction

This is the ability to represent a complex problem in simple terms.  In the object oriented approach it is seen in the ability to create a high level class definition that has little or no detail included in it.  We are able to “abstract” the problem to a simple class definition and only add detail alter in the process.

The ability to support abstraction is instrumental in being able to model very complex business problems in our designs.

Specialization

Seen in class structures, specialization is the ability to make lower level subclasses more detailed than their parent classes.  Technically, specialization is defined as the ability of an object to inherit operations and attributes from a superclass (parent class) with possible restrictions and additions.

These first two concepts work in conjunction with one and other.  Abstraction allows us to define high level classes that lack minute details of implementation while specialization supports the introduction of those details later in the class design.

Encapsulation

Defined as hiding the implementation of the object, encapsulation is really the process of making an object as self sufficient as is possible.  An object contains not only code but also data.  Encapsulation, in the structured design, is the process of enclosing all of the code necessary to a particular operation into a single module and limiting the external dependencies of that module.

In object orientation, not only is the code encapsulated, but also the data required by that code (in the form of object properties).

Inheritance

Just as you and I have inherited certain traits from our ancestors, so do classes in an object oriented system. There are superclasses (classes that have subclasses) and there are subclasses (classes that inherit form another class).  These terms, superclass and subclass, are relative in that a given class may be a subclass of one class and a superclass for another.

Microsoft has opted to use the term parentclass instead of superclass in Visual FoxPro. Don’t let this confuse you, a parentclass and a superclass are exactly the same thing.

Inheritance is the ability of one class to incorporate all or part of another class’s definition in its own definition.  An example may help to understand this.

Assume a class named cmdBase which is derived from the Visual FoxPro baseclass of CommandButton.  In this class, cmdBase, we change the FontName to Times New Roman.  We then create a new class named cmdSpecial as a subclass of cmdBase. The cmdSpecial class will have Times New Roman as its default font because it inherits this trait form the parentclass cmdBase.  If we later change the font for cmdBase then the font for cmdSpecial will also change (as long as we have not overridden the inherited font name).

Polymorphism

Ah, the 35 cent word.  An aside, it has been noticed that we get compensated for our work proportional to the length of the words we used to describe that work.  If this is true then polymorphism should get us all a raise.

The word is comprised of poly, meaning many, and morph meaning shape.  So polymorphism means many shapes and that is correct.

The general definition of polymorphism is the ability of different things to use the same name.  There are two types of polymorphism seen in object oriented systems, inherent and ad hoc.

Inherent polymorphism

The ability of an operation to apply to different classes.  Basically the ability to define a method in a class and have that method exist for all subclasses of that class even when the subclasses a very different in their behavior.  For example, if we create a form class and give it a PrintMe method, then all subclasses of that form class will have a PrintMe method.  Now we may create subclasses of this form class for Invoices and Customers each of which will have specific code in the PrintMe method for printing the respective information.  The fact that they both have a PrintMe method is inherent polymorphism.

Ad Hoc polymorphism

With ad hoc polymorphism we are concerned with the specific behavior of the PrintMe methods.  Ad Hoc polymorphism is defined as the ability of different operation of different types to have the same name.

In our example, ad hoc polymorphism is seen in the fact that the invoice class prints an invoice and the customer class prints a customer ledger but both methods have the same name, PrintMe. The printing of an invoice and a customer ledger are very different processes, however, they both have the same name.

This ad hoc polymorphism allows us to create reusable components easily.  Since the form’s both have the same method name, we can create a print button that simply says Thisform.PrintMe() and not be concerned with what form that button may appear in.

Object Communications

Probably the simplest and yet most misunderstood aspect of object orientation is the fact that all behavior in an object oriented system is the result of objects communicating with other objects.

How do objects communicate?  By calling methods or assigning values to properties.  In our example above, the Print button communicates with the form by calling the form’s PrintMe method.  The form is responsible for the actual action of printing, the button’s responsibility is to provide a way for the user to communicate their desires to the form.

Where does the user fit in this scenario?  The user is another object in the design.  We provide objects that the user can communicate with (buttons, textboxes etc.) and then code those objects to respond to the user’s interaction.  The user uses the keyboard and mouse to send messages and our objects use the screen and printer to send messages to the user.

Reuse

The concept of code reusability has been around for much longer than object orientation.  In structured programming we were always looking for ways to create reusable routines or functions that could reduce the effort required on later projects.  We were working towards encapsulation and loose external coupling in the effort to get thing to be reusable.

In object oriented programming we have new tools that allow for an even better level of reusability.  By taking advantage of things like polymorphism and inheritance we can create class definitions that are truly universal in their applicability.  In the example above about the PrintMe method, by combining the form class with the PrintMe method and the button class with the Thisform.Printme() call in its click event, we have just removed the need to ever make a print button again.

Design First

Many folks find the transition to object oriented programming a difficult one.  The major reason for this is a tendency to “code from the hip.”  That is, to invent the solution as you write the code.  While this approach can cause problems in any programming style, it is especially harmful in object oriented programming.

Object oriented development requires the design and creation of objects that have specific responsibilities and behaviors.  These object must interact with one and other.  Without careful planning up front, the likelihood that these objects will communicate well together is slim to none. The vary goals of OO will be lost in the monolithic code segments that are trying to handle complete problems without benefit of individual objects with specific responsibilities.

I have heard some folks say that doing things in VFP is difficult, I say that is not true.  Doing things in VFP is easy, figuring out what to do is the hard part.  Figuring out what to do is the design.  VFP gives you a multitude of approaches to each problem you face.  There is invariably more than one way to attack each situation.  The difficulty, or complexity, that VFP presents is in making the decision as to which approach you will take.

Any trip will be easier if you know where you want to go before you start.  Just as you would make plans for a vacation, you should also make plans for a project.  If you were to get in your car one day to leave on vacation with no plans or goals for the trip, it is unlikely that you will have a truly enjoyable vacation.  The same is true for your development efforts.  If you start a project with no plan of what it will do and how it will do it, you are headed down a long and tortuous path of difficulty and complexity.

Object Orientation and Visual FoxPro

The Concept of Containership

Visual FoxPro has a containership model built into it.  This model is the implementation of the concept of one object containing other objects.  Containership is defined as the ability of one object or class to contain other objects including other containers.

This containership model dictates the way we address various objects with our code.  Just like addressing a letter to someone, where we must supply the postal code, state, city, street and name, in VFP we must tell fox where the object exists that we want to address.  Below is a diagram showing a containership.  In this diagram there is a textbox in a Page of a PageFrame that is in a Form.  To address the textbox it is necessary to tell VFP where the textbox is as in; Thisform.PageFrame.Page.Textbox.  Notice that the syntax lists the containership for the textbox as being in the form, in the PageFrame, and in the page.

Example:

   

 

 

 

 

 

 

 

The syntax of containership can be made simpler through the use of certain FoxPro keywords that provide for relative addressing, that is addressing starting from the location of the object that contains the code.  ThisForm, ThisFormSet, and This are three examples of this relative addressing.

ThisForm refers to the form that the code is contained in regardless of which control or object in that form has the code.   ThisFormSet does the same thing as ThisForm except that it refers to the formset containing the code.  This refers to the immediate object that contains the code.  By using these keywords we can write code that is independent of the names of the objects.

There is one more keyword that can be helpful here, Parent.  Every object in Visual FoxPro has a parent property.  This property holds an object reference to the immediate container of the object.  In the example above, the Textbox’s parent is the Page, the page’s parent is the PageFrame, the PageFrame’s parent is the form, and the form has no parent.

This concept of containership is instrumental in understanding how to best use the features of Visual Foxpro.  You can construct complex classes with multiple controls and provide all the behavior for those controls in the class definition.  Then using them is as simple as dropping them on a form, setting some properties and that’s it.

The Baseclasses

Every class we define in Visual FoxPro must derive from a Visual FoxPro base class.  These base classes are the default class definitions that come with Visual Foxpro.  If you open the form designer and look at the Form Controls toolbar, you will see many of the Visual FoxPro base classes.  Not all of them are on that toolbar, but many of them are.

The following table is a list of all of the base classes provided with Visual FoxPro 6.0.

Baseclass

Container

Visual Design

CheckBox

No

Yes

ListBox

No

Yes

ComboBox

No

Yes

CommandButton

No

Yes

OptionButton

No

Yes

Spinner

No

Yes

TextBox

No

Yes

EditBox

No

Yes

ActiveDoc

Yes

Yes

Column

Limited

No

CommandGroup

Limited

Yes

Container

Yes

Yes

Control

Yes

Yes

Cursor

No

No

Custom

Yes

Yes

DataEnvironment

Limited

No

Form

Yes

Yes

FormSet

Limited

Yes

Grid

Limited

Yes

Header

No

No

HyperLink

No

Yes

Image

No

Yes

Label

No

Yes

Line

No

Yes

OLEContainer

Limited

Yes

OLEBoundContainer

Limited

Yes

OptionGroup

Limited

Yes

PageFrame

Limited

Yes

Page

Yes

No

ProjectHook

No

Yes

Relation

No

No

Separator

No

Yes

Shape

No

Yes

Timer

No

Yes

ToolBar

Limited

Yes

The above table shows you all of the Visual FoxPro base classes and tells you if they are a container and if they can be used in the Visual Class Designer to built your own subclasses.  Any of the base classes can be in program code to define subclasses, but some of them are not available to design in the Visual Class Designer.

Certain of the base classes arte limited containers, this means they are restricted as to what other base classes they may contain. For example, a Grid may only contain Columns, or a PageFrame may only contain Pages.

The Visual Class Designer

Visual Foxpro provides two ways to create your own classes, one is the Visual Class Designer the other is in program code.  First let’s look at the Visual Class Designer.  This tool is similar to the Form Designer except instead of designing a form you are designing a class.

Most of the FoxPro base classes can be subclassed using the Visual Class Designer. The exceptions are Column, Header, Page, DataEnvironment, Cursor, Relation, and Session. These base classes can only be subclassed in program code.

The Visual Class Designer can be used to write code in the events and methods of your class.  You can also add new properties or methods to the class definition using the Class-New Property or Class-New Method options on the Class menu.

The classes created with the class designer are stored in a VCX file (visual class library).  This file has a sister file with a VCT extension.  The VCX is actually a FoxPro DBF file with fields for all of the information regarding the class definitions.

Defining Classes in Code

Classes can also be defined in program code using the DEFINE CLASS command.  An example is seen below;

 

DEFINE CLASS Employee AS Custom

    cName = “John Smith”

 

    PROCEDURE Launch

       PARAMETERS  pcForm

       DO FORM (pcForm)

       RETURN

    ENDPROC

 

ENDDEFINE

 

 

In this example a class named Employee is being defined as a subclass of the VFP Custom base class.  The line cName = “John Smith” creates a property named cName for this class and assigns it the value of “John Smith”. The PROCEDURE declaration is defining a custom method named Launch.  The code inside of the PROCEDURE is the code that will run when the Launch method is called.

The employee class defined in the example will have all of the properties and methods of the Custom base class because it inherits from that base class.  The cName property and the Launch method will be additional things for this particular class.

You can also subclass your own classes like the following example;

 

DEFINE CLASS FullTimeEmployee AS Employee

 

    PROCEDURE Bonus

       PARAMETERS  pnPay

       RETURN pnPay * 1.1

    ENDPROC

 

ENDDEFINE

In this example we have created a class named FullTimeEmployee and added a bonus method.  This new class will have the cName property and the Launch method, but it will also have a Bonus method.  The behavior of the Launch method will be the same as it is for the Employee class.

Why Subclass?

You may ask, why do I want to create a hierarchy of subclasses?  The reason is somewhat elusive at first. Your first impression may be that having a hierarchy of subclasses creates a complex reservoir of code that will be difficult to maintain and debug.  Well that is partly correct. In a class hierarchy the code that provides the behaviors we see is often scattered around in different places.

However, there is one object oriented programming concept that requires that class hierarchies be used, that is programming to interface.

Programming to interface

This idea is that we should be writing our systems based on the properties, methods and the arguments and return values from those methods rather than on the actual code that implements the behaviors.  This may seem like a mouth full of garbage right now, but rest assured it is not.

Let’s look at an example of this in practice.

DEFINE CLASS frmperson AS form

      Name = "frmperson"

      PROCEDURE ask

            LPARAMETERS pcQuestion

            * Delegate to the person inside

            THIS.Person.Ask(pcQuestion)

      ENDPROC

      PROCEDURE Init

            LPARAMETERS pcName

            * Receive a name for this person

            IF EMPTY(pcName)

                  * If no name is passed

                  pcName = "Who Am I?"

            ENDIF

            THIS.Name = pcName

            THIS.Caption = pcName

            THIS.Visible = .T.

      ENDPROC

ENDDEFINE

DEFINE CLASS frmfemale AS frmperson

      Height = 325

      Width = 274

      Name = "frmfemale"

      ADD OBJECT person AS female WITH ;

            Top = 14, ;

            Left = 20, ;

            Name = "Person", ;

            HEAD.Name = "HEAD", ;

            LeftEye.Name = "LeftEye", ;

            RightEye.Name = "RightEye", ;

            HAIR.Name = "HAIR", ;

            NOSE.Name = "NOSE", ;

            MOUTH.MOUTH.Name = "MOUTH", ;

            MOUTH.Timer1.Name = "Timer1", ;

            MOUTH.Name = "MOUTH", ;

            Label1.Name = "Label1", ;

            tmrBlinker.Name = "tmrBlinker", ;

            tmrYawn.Name = "tmrYawn", ;

            LeftPigTail.Name = "LeftPigTail", ;

            RightPigTail.Name = "RightPigTail"

ENDDEFINE

DEFINE CLASS frmmale AS frmperson

      Height = 325

      Width = 274

      Caption = "Form1"

      Name = "frmmale"

      ADD OBJECT person AS male WITH ;

            Top = 14, ;

            Left = 19, ;

            Name = "Person", ;

            HEAD.Name = "HEAD", ;

            LeftEye.Name = "LeftEye", ;

            RightEye.Name = "RightEye", ;

            HAIR.Name = "HAIR", ;

            NOSE.Name = "NOSE", ;

            MOUTH.MOUTH.Name = "MOUTH", ;

            MOUTH.Timer1.Name = "Timer1", ;

            MOUTH.Name = "MOUTH", ;

            Label1.Name = "Label1", ;

            tmrBlinker.Name = "tmrBlinker", ;

            tmrYawn.Name = "tmrYawn"

ENDDEFINE

In these class definitions you can see that frmFemale and frmMale are both subclasses of frmPerson.  As such both the frmFemale and frmMale classes have an Ask method and the behavior of that method is the same for both of them.

This means that both the frmFemale and frmMale can be used interchangeably without requiring the alteration of code that interacts with their Ask methods.  You see all code that interacts with a frmFemale using the Ask method is programmed to the interface, that is the name of the method and the arguments it takes.  There is no code that is dependent on the implementation of the Ask method.  Because of this, we could substitute the frmMale for the frmFemale without changing any code.

We could even specialize the Ask method for one or both of the subclasses and, as long as we preserve the interface of the method, the two subclasses could have different behaviors without requiring the recoding of any calling code.  The two subclasses now would do different things when their Ask method was called, but they are still interchangeable.

Programming By Exception

The inheritance model used in Visual FoxPro is called programming by exception. In this model a subclass will inherit the code from its parent class unless there is any code in the subclass’s method.  When code is written in the subclass’s method it overrides the otherwise inherited code.  For example;

DEFINE CLASS Widget AS TextBox

PROCEDURE Click

   WAIT WINDOW “OooH!, That tickles.”

ENDPROC

ENDDEFINE

 

DEFINE CLASS BlueWidget AS Widget

PROCEDURE Click

   WAIT WINDOW “I am blue”

ENDPROC

ENDDEFINE

In the example we define a class named widget and give it some click behavior.  We then define a subclass of widget and modify the click procedure.  The BlueWidget class will NOT exhibit the behavior seen in the Widget class as that behavior is overridden in the subclass definition.

If we want both the parent class behavior and the subclass behavior, we must explicitly call the parent class code.  This can be done in one of two ways.  Using the DoDefault() function or using the scope resolution operator (::).  Below are two examples of the BlueWidget class using each of these methods to call the parent class’s code.

DEFINE CLASS BlueWidget AS Widget

PROCEDURE Click

   DoDeafult()

   WAIT WINDOW “I am blue”

ENDPROC

ENDDEFINE

DEFINE CLASS BlueWidget AS Widget

PROCEDURE Click

   Widget::Click() && scope resolution

   WAIT WINDOW “I am blue”

ENDPROC

ENDDEFINE

The preferred method of doing this is to use the DoDefault() call, as it has no binding to the name of the parent class.  With the scope resolution operator it is necessary to hard code the parent class’s name into the subclass’s code.  This could cause problems later if the class structure is modified and BlueWidget becomes a subclass of some child of the Widget class.

Any code, including a comment, in a subclass’s method will override the behavior of its parent.  At first this may seem unusual as inheritance is one of the goals of object oriented programming.  However, you would soon realize that when you are specializing the behavior for a class you need to have control over when the parent class’s code is run.  This programming by exception approach gives you complete control over how and when the parent class code will be done form your subclass.

The NODEFAULT Command

Certain events and methods of the Visual Foxpro base classes have a default behavior associated with them.  For example, a form’s release method will release the form from memory and destroy it or the KeyPress event of a control will process the key pressed.

These default behaviors are not overridden by your coder, they will always execute after your code runs. If you want to suppress the default behavior you can use the NODEFAULT command.  This command tells VFP to not execute the default behavior.  In a form’s release method it will stop the release of the form, in a keypress it will stop the processing of the keystroke.

You can combine the DoDefault() function with the NODEFAULT command to control when the default behavior will occur.  For example;

* Some textbox’s KeyPress

DoDefault() && Process the keystroke

* put your code here

NODEFAULT && stop the automatic processing of the keystroke

The DoDefault() function will call the default VFP behavior as well as any behavior in the parent classes.

Summary

Visual FoxPro is an object oriented development environment.  As such it has the capability of exploiting the full feature set of object oriented languages.  At first, OO may seem overwhelming however given time and experience you will reach the point where you will find it difficult to imagine how you ever built systems in any other fashion.

The concepts of OO can seem academic, but they are important.  The major difference between procedural programming and object oriented programming is how we think about what we do.  Just as there is good and bad procedural code, there is also good and bad object oriented code.  The things that make code good or bad don’t change, just the approach to writing it changes.

The obtuseness of OO development will fall away for you as soon as you begin to think about your systems as collections of objects with each one having specific responsibilities.  Where no object steps on the domain of any other object, rather it calls the other object for services.  An environment where each and every object is capable of standing on its own and doing what it does.  Where no object is dependent on exactly how any other object functions, but only on what it does and how to call it.