PreviousClass Browser Tutorial (Windows & OS/2) Writing a Class Program Tutorial (Windows & OS/2)Next"

Chapter 5: Objects and Messages Tutorial (Windows & OS/2)

This tutorial is a gentle introduction to Object COBOL programming, using a class with some simple behavior. We will call this the Parrot class. In the tutorial you will create instances of the Parrot class. An instance of the Parrot class is a parrot object, and having created parrots, you can send messages to them.

This tutorial consists of the following sessions:

  1. The Parrot Class Interface

  2. Sending Messages

Time to complete: 20 minutes.

5.1 The Parrot Class Interface

This section introduces you to the Parrot class, describing its behavior and public object interface. The object interface is the list of methods implemented by an object, together with descriptions of the parameters passed to and from the object by each method.

The public object interface is a censored list of this information; it does not describe the object's private methods. A private method is one used by the object itself; it should not be invoked from outside the object.

The interface for the Parrot is split in two:

A class is an object in its own right; it can have behavior and data of its own, which is different to the behavior and data of instances of the class. The main function of most classes is to implement the behavior needed to create and initialize new instances.

Instances of the Parrot class are windows displayed on your desktop. Parrot windows are numbered sequentially, with the number shown in the title bar. You can't resize or close Parrot windows from the desktop; they are controlled purely by the application which creates them.

A parrot instance traps any message sent that it doesn't understand, and echoes it back. The default behavior when an object receives a message it doesn't understand, is to display an error message and then terminate the application.

The Parrot class public object interface is listed below.

Class method
"new" returning anObject Returns an instance of the Parrot class, with the reference in anObject
"howMany" returning aNumber Returns the number of parrot instances created so far.
"sayHello" using aName Display "Hello aName" in the Response field of the Parrot window. You must terminate the string in aName with a space.
"whatNumber" returning aNumber Return the number of this parrot instance (all parrots are numbered sequentially as they are created).

In addition to these methods, the Parrot class inherits all those implemented by its superclass (Window). The superclass is the parent from which this class inherits its basic behavior.

The Parrot class inherits all the class methods of Window, and its instances inherit all the instance methods of Window. This means that Parrot responds to all the messages given in the Window public interface as well as its own. Inheritance is explained in more detail in the tutorial Inheritance.

The Window class is part of the class library supplied with Object COBOL. If you want to look at the Window public interface, it is in your on-line Object COBOL Class Library Reference.

You can now move on to the next session, which uses Animator V2 to show you message sending.

5.2 Sending Messages

In this section you will create instances of the Parrot class, and send messages to the instances, using the supplied program, hello.cbl.

Program hello.cbl is not an Object COBOL class; it is a piece of procedural code which uses Object COBOL objects. To communicate with the objects hello.cbl uses the following Object COBOL syntax:

You will now animate hello to see some simple object behavior. The code demonstrates the following points:

>>To animate hello

  1. Start the icon labeled Objects and Messages in the Object COBOL Tutorials group.

    This starts the on-line tutorial Objects and Messages.

  2. Select the hotspot marked Animate hello below the heading Using This Tutorial.

    This starts Animator V2 and loads hello.cbl.

  3. Select Check Program from the COBOL menu.

    Animator V2 syntax-checks the program and prepares it for execution.

    The line below tag H001 is highlighted ready for execution.

  4. Step the line of code (invoke Parrot "new" ...).

    This sends the "new" message to the Parrot class, which creates an instance of itself, returning an object handle to it in aParrot. The new instance opens the Parrot 01 window on your desktop.

  5. Look at the contents of data-item aParrot with the Examine function (short-cut - double-click on aParrot).

    This data item is declared with usage object reference, which is a new COBOL datatype introduced for Object COBOL programming. It now holds a handle to the object you have created.

    32-bit environments:
    When you examine it on 32-bit Object COBOL systems, an Object Inspector window appears. This tells you that the object is an instance of the class parrot.

    16-bit environments:
    When you examine it on 16-bit Object COBOL systems, the Animator V2 monitor window just displays the value of the object handle.

    When programming in Object COBOL, you use the object handle as an address to send messages to the object. You can pass object handles between different programs or objects as parameters, in effect enabling you to pass an object between different parts of an application.

  6. Close the APARROT monitor window.

  7. Step the line below tag H003 (invoke aParrot "sayHello").

    Parrot 01 displays "Hello Polly" in the Response field, and "sayHello" in the message field. Parrots always repeat the messsage sent.

  8. Step the line below tag H004 (invoke aParrot "saySomethingElse").

    Parrots don't understand this message; "saySomethingElse" is not a method implemented by the Parrot class, or any of its superclasses. The parrot traps this error and redisplays the message it didn't understand.

    The default behavior when you send an object a message it doesn't understand is that it displays an error message and terminates the application. The Parrot class program overrides this behavior by reimplementing the "doesNotUnderstand" method which objects otherwise inherit from Base (part of the Class Library).

  9. Step the line below tag H005 (invoke aParrot "whatNumber").

    This returns the ID of the parrot in parrotNumber. If you examine this data item, you can see it has a value of 1.

  10. Step the line below tag H006.

    This creates a new instance of the Parrot class, and puts the object handle into aParrot. The first parrot you created, Parrot 01, still exists. But you have now overwritten the only data item you had giving you its object handle, so you can no longer send messages to it.

    This is something you must be careful about when programming with Object COBOL; once you lose the object handle to an object, you have no easy way of sending it messages and no way of destroying it. You can get a collection of all the handles for the instances of a particular class by sending the message "allInstances" to the class object. However, in most real applications you would not know who had created each particular instance, and there would be no safe way of knowing which ones you could destroy.

  11. Step the lines below tag H007.

    These send messages to the new instance of Parrot.

  12. Step the line below tag H008

    This queries the class data of Parrot. If you examine parrotNumber you can see that it contains the value 2, the number of parrot instances so far created.

  13. Step the line below tag H009.

    Sending the "finalize" message to an object deallocates its storage. You should finalize any object your application has finished with. Once you have finalized an object, you should no longer try to send messages to its object handle, as the results are unpredictable.

    The proposed ANSI standard for Object-Oriented COBOL includes automatic garbage-collection. With garbage-collection, it is the run-time system's responsibility to dispose of objects that are no longer in use. When the ANSI standard is fixed and Micro Focus implement it, you will no longer need to include code to finalize objects.

  14. Select Exit from the Animator V2 File menu.

  15. Select Exit from the on-line File menu to close the on-line tutorial.

5.3 Summary

This completes the tutorial on creating objects and sending messages. You have seen:

Copyright © 1999 MERANT International Limited. All rights reserved.
This document and the proprietary marks and names used herein are protected by international law.

PreviousClass Browser Tutorial (Windows & OS/2) Writing a Class Program Tutorial (Windows & OS/2)Next"