- Abstract Class
- A class which does not act as a creator of instance objects. Abstract
classes implement behavior for their subclasses.
- A technique for utilizing the functionality of other objects without using
inheritance. An aggregate object is a container for the objects whose
functionality it wants to use, and delegates messages to the appropriate
receivers. Aggregation is often used with object models which do not support
inheritance, such as OLE.
For example, an OLE automation server which wants to provide
OrderedCollection functionality can create its own OrderedCollection object, and
implement "add" and "at" methods which simply delegate these
functions to the OrderedCollection.
- The data encapsulated by an object. The only data which should be declared
as part of an object's attributes is the data required to describe the object's
state at any particular time.
For example, the attributes of a circle are its radius and the coordinates
of its center. The actual code for implementing circle objects might require
other data items for calculations, but these would not be considered part of the
attributes for that object.
- The root class of the Object COBOL Class Library. All other Object COBOL
programs supplied with this system inherit their fundamental behavior from Base.
- An object of class Callback stores a reference to an object and the name of
a method implemented by that object. When the Callback object is sent the "invoke"
message, it executes the named method in the object it has stored.
One use of Callback objects is to handle GUI event processing. For example,
the Phonebook GUIController has an Add method for adding new records. A Callback
to this method in GUIController is attached to the pushbutton object for Add,
and whenever the pushbutton is clicked it invokes this Callback.
- An Object COBOL program which contains the code and data descriptions for a
class object and its instance objects. It is also known as the class program.
A class consists of nested COBOL programs, which correspond to class object
and instance object methods. Each class starts with an identifier naming the
class and the class from which it inherits. When a class is loaded at run-time,
the OO run-time system creates the class object.
- Class-Control paragraph
- Lists all the classes the program is going to use. The Class-Control
paragraph is part of the Object Section, in the Environment Division. Each entry
links a class name to the filename of the class executable file. The class-names
are the object references which the program uses for sending messages to the
class object at run-time.
If the program itself is an Object COBOL class, the Class-Control paragraph
also lists its superclass, and the class itself.
- Class Object
- An object which is a template for the creation of instance objects of the
same type. For example, the the OrderedCollection class object creates instances
The class object itself does not have the same behavior and methods as the
instance objects which it creates. By analogy, a biscuit cutter is a template
for creating biscuits; however, you can't eat a biscuit cutter and you can't
stamp a biscuit from another biscuit.
In Object COBOL, all the methods and data for a class object and the
instance objects which it creates are represented by a class program.
The class object is created at run-time when a class is loaded.
- Class Library
- The set of classes supplied with Object COBOL. The root class of the Class
Library, Base, implements basic behavior for all classes, and provides a
superclass for your own classes.
There are also classes to implement collections, exception handlers,
Callbacks, and GUI interfaces.
- Class Program
- See Class.
- An object which can send and receive signals. Any object can be made into a
component by sending it the "makeComponent" message. Components
operate in a way analogous to microchips; they define a set of inputs and
outputs. A component can send output signals regardless of whether or not there
is another component receiving those signals, without causing a run-time error.
- Dynamic Binding
- The object which will receive a message is unknown when an Object COBOL
program is compiled. The Object COBOL system determines the receiver at
- You can only access or manipulate an object's data through the methods it
provides. To invoke a particular method, you send the object a message. The
object's data is said to be encapsulated.
- Something done by a user, such as pressing a key, which causes a message to
be sent to an object.
- A processing error at run-time. Objects should be designed to raise
exceptions whenever they encounter an error condition. The supplied Class
Library provides a default exception handling mechanism which reports the error
and shuts down the application. You can attach your own exception handling
mechanisms to any class or instance object if you want a more sophisticated way
of responding to exceptions.
- A protocol used by several different types of object cooperating to
implement a particular function. An individual class or instance object has a
public interface which describes the way you communicate with that object. A
framework describes the way in which different types of object interact
For example, the public interface to an OrderedCollection describes how you
can add, retrieve and remove elements. The Collection framework describes how
OrderedCollections (and other types of collection) communicate with the objects
they are storing as elements.
- Guard page
- A memory page (4096 bytes on Intel processors) that has special permissions
set on it so that it cannot be read or written to. By placing guard pages before
or after pages assigned to object storage, the run-time system can catch
attempts to read or write beyond the ends of object data.
- See Object handle.
- The mechanism by which a subclass has access to the functionality in its
superclass. A subclass always inherits all the methods of its superclass, which
it can override if necessary. A subclass can also inherit the data of its
superclass, although this depends on the settings in the CLASS-ID header of both
the subclass and the superclass. By identifying different types of objects which
have common functionality, you can implement the common methods for that
functionality in a single class and inherit it in any number of subclasses.
Each class inherits all the methods of its superclass, so a class ultimately
inherits all methods all the way up to a root class. A class object inherits the
class methods of its superclass, and an instance object inherits the instance
methods of its superclass. In this Object COBOL implementation, a class has only
one immediate superclass. The superclass is named in the INHERITS clause of the
- Input socket
- Defines a set of signals which a component can receive. A single component
can have many input sockets, and use each each socket to connect to a different
- See Instance Object.
- Instance object
- A single occurrence of an object of a particular class. Instance objects
are created by sending an appropriate message (usually "new") to a
class object. For example, to create a window for display on the desktop, you
send the "new" message to the Window class object.
The methods and data for instance objects are defined in the object program,
which is nested within the class program. The object program starts with the
header OBJECT and finishes with END OBJECT.
- Intrinsic Class
- A class corresponding to a COBOL intrinsic data type. These classes are
used as templates so that you can send messages to COBOL intrinsic data using
the INVOKE ... AS... construct. For more information, see the chapter Intrinsic
- Logical event
- An event defined for a particular object, and raised by the object as a
result of an event from the end-user. For example, a dialog box might define
logical events to represent OK and Cancel, raising OK when the OK button is
clicked and Cancel when the Cancel button is clicked. The parent of the dialog
box can register interest in the OK and Cancel logical events, so that it can
act on these events without knowing the details of the dialog box controls.
- Memory leak
- Memory no longer needed, but not deallocated by the OO system. An
application should finalize an object when it is no longer required. When an
application no longer has a handle to an object which still exists, the object
is effectively unreachable, and can no longer be finalized. This is a memory
- Invokes a method when sent to an object. The method invoked matches the
message sent. The text of the message is known as the method selector.
invoke verb enables you to send messages. For example:
invoke anOrange "peel"
The method selector "peel" invokes the peel method in anOrange.
Data is returned from the method in data item SEGMENTS.
- Message Binding
- Ensuring that each message is delivered to the right object. Binding can be
dynamic or static. In a statically bound object-oriented programming system
(OOPS), the receiver of a message is determined at compile-time. In a
dynamically bound OOPS, the receiver of a message is determined at run-time.
This release of Object COBOL supports dynamic binding only.
- Enables the creation of class objects. All class objects are instances of
the metaclass object. In Object COBOL, the metaclass is Behavior, which is part
of the Class Library.
- Code manipulating or interrogating the data within an object. In Object
COBOL, each method is coded as a nested program within a class.
- An encapsulation of data and methods. The only way to access an object's
data is by sending it messages. You can also think of an object as intelligent
data, which includes implementations for the operations (methods) appropriate to
There are two types of object: classes and instances. A class object is
created when you register a class; an instance is created whenever you send an
appropriate message to the class object which defines that instance. The Object
COBOL run-time system allocates each object its own data area in memory. There
can be many instance objects of the same type within a run-unit, but there can
only be one class object of each type.
- Object Handle
- An ID or reference by which you can access a particular object. Every
object is assigned a handle when it gets created at run-time.
You always give the object handle when you send a message; the OO RTS uses
the handle to find the object which should receive the message. You store object
handles in data items of type OBJECT REFERENCE.
- 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
- Object reference
- A COBOL data item, declared as OBJECT REFERENCE which can hold an object
handle. You can pass object references as parameters when you send a message or
make a COBOL CALL, in effect enabling you to pass objects between different
parts of an application. Object references are untyped, so the same data item
can hold an object reference for any class or instance object. That is, there is
no distinction between the type of object reference declared to hold an instance
of one class or another.
- OLE Automation
- Enables an object to expose a set of methods which can be invoked through
Microsoft OLE, which is built into the Windows 95 and Windows NT operating
- A type of collection. You can either "add" elements to the end of
an OrderedCollection, or "atPut" them to a particular indexed
location. As you "add" elements, an OrderedCollection grows in size to
- A run unit that has created another run unit or a window that has opened
- The ability of the Object COBOL run-time system to remember the state of
all objects in the system between runs. It does this by storing all objects in
an indexed file.
- The method invoked by a particular message depends on the object which
receives it. For example, you could implement several different classes of bank
account object (checking, savings, high rate). All bank account objects would
respond to the message"printStatement". However, each different type
of account would implement "printStatement" differently, in a way
appropriate to itself savings accounts show interest paid, but checking
Polymorphism enables you to send the same message ("printStatement")
to any type of account object and get appropriate results.
- Public interface
- A subset of an object interface, listing only the methods which should be
used from outside the object. The public interface does not list any of the
object's private or protected methods, which are only intended for use from
inside the object or from its subclasses.
- Reserved variable which contains the object handle of the object in which
it occurs. Used to enable objects to send messages to themselves. If you send a
message to SELF from object A, object A is the receiver of the message; if you
send a message to self from object C, object C is the receiver of the message.
SELF always refers to the object currently executing, even if the method is one
which is being inherited. For example, imagine two objects, A' and B', instances
of classes A and B where B inherits from A. A implements instance method, "calculateValue".
The "calculateValue" method sends the message "getObjectConstant"
to self. If B' gets sent the "calculateValue" message, the method is
inherited from class A. When "calculateValue" sends a message "getObjectConstant",
the message actually gets sent to B'. If A' were to be sent the "calculateValue"
message, then the send to SELF would send the message to A'.
You can use SELF exactly like any data item of type Object Reference, so you
can also pass it as a parameter to other methods.
- Reserved variable which contains an object handle for the class object for
this current object. Enables an instance to send a message to the class object
which created it. You can use SELFCLASS exactly like any data item of type
Object Reference, so you can also pass it as a parameter to other methods.
- The way components communicate. When a component sends a signal, it is
received by all components connected to the sender. The receiving component only
acts on the signal if it has an input socket and method defined for that signal.
A component which sends a signal event when there are no components connected
does not cause a run-time error.
Contrast with a message, which is sent to a single specific object. if the
object does not understand the message it raises a run-time exception.
- IBM's System Object Model. Enables objects written in different languages
to interoperate. Distributed SOM also enables objects to interoperate across
different processes on the same or different machines.
- A class descended from another one, inheriting its methods and data. In the
Class Library supplied with Object COBOL all class are ultimately subclasses of
- Reserved word which behaves like an object reference when used in an INVOKE
statement. Like SELF, it enables an object to send a message to itself, but the
search for a matching method starts in the code of the method's superclass. If
used from an instance, the run-time system searches for a method beginning with
the instance code of the superclass, and works its way up through the instance
methods of all the superclasses until it finds a method matching the message. If
used from a class method, the run-time system searches for a class method
beginning with the class object code of the superclass and works its way up
through the class methods of all the superclasses until it finds a method
matching the message.
Unlike SELF, and SELFCLASS, SUPER is not a data item containing an object
handle; you can't pass SUPER as a parameter to a method.
- The parent of a class. Every class has a single superclass immediately
above it in the inheritance hierarchy, with the exception of those at the top of
the hierarchy. In the supplied Class Library there is only one root class, Base,
from which all other classes are descended.
Copyright © 1999 Micro Focus Limited. All rights reserved.
This document and the proprietary marks and
names used herein are protected by international law.