Most applications need many objects of the same type. For example, if your business has 500 customers, you need one object to represent each customer. No one would want to design a customer object 500 times; clearly, you need a template that defines all customer objects, so that you can design the template once, and use it often. For example, you would use the template each time you create a new customer object to represent a new customer.

An object's template is called its class. Each object is an instance of a class. In other words, the class defines the type of object. In fact, when you create a class, the class becomes a new data type. Just as you can use a built-in data type, such as integer or alphanumeric, to define a simple variable, you can use a class data type to define an object.

Maintain supports two kinds of data types: built-in data types, and classes that you define yourself. For example, just as you can use the built-in data type alphanumeric to define a customer ID code

DECLARE CustID/A8;

you can use the class RetailCustomer to define an object as a customer:

DECLARE CustSmit8942/RetailCustomer;

You define a class by describing its properties. Classes have two kinds of properties:

• Data, in the form of the variables in the class. Because these variables exist only as members of the class, they are called member variables. (In some object-oriented development environments these are also known as object attributes or instance variables.)

  The member variables in a class determine what the class is (as opposed to what it does). Each object of that class can have different values for its member variables.

• Processes, implemented as functions (which are also known as cases). Because these functions exist only as members of the class, they are called member functions. (In some object-oriented development environments these are also known as methods.)

  The member functions in a class define its behavior—that is, they determine what you can do to objects of that class, and in what ways you can manipulate their data.

An application for a mail-order clothing business has defined a customer class named Customer. The member variables in the class might include the customer's code, phone number, and most recent order number:

DESCRIBE Customer =
(IDcode/A6,
 Phone/I10,
 LastOrder/A15);
 .
 .
 .
ENDDESCRIBE

After declaring a new customer object for the customer Frances Smith

DECLARE CustFrSmith/Customer;

you could assign a value to Frances Smith's IDcode member variable:

DECLARE CustFrSmith.IDcode = GetNewCustCode();

Each object can have different values for its member variables; for example, in this case, each customer will have a different ID code.

An application for a mail-order clothing business has defined a customer class named Customer. The member functions in the class might include a function that adds the customer to a new mailing list, a function that updates the customer's contact information, and a function that places an order for the customer:

DESCRIBE Customer = 
(IDcode/A6,
 Phone/I10,
  .
  .
  .
 LastOrder/A15);

 CASE AddToList TAKES Name/A25, Address/A50, IDcode/A6;
  .
  .
  .
 ENDCASE

 CASE UpdateContact ... 

 CASE PlaceOrder ...

ENDDESCRIBE

After declaring a new customer object for the customer Frances Smith

DECLARE CustFrSmith/Customer;

you could add Frances Smith to the mailing list using the AddToList member function:

CustFrSmith.AddToList();

Each object has the same member functions, and so the same behavior; for example, in this case, each customer will be added to the mailing list using the function.

If you want to create a new class that is a special case of an existing class, you could derive it from the existing class. For example, in a human resources application, a class called Manager could be considered a special case of a more general class called Employee: all managers are employees, and posses all employee attributes, plus some additional attributes unique to managers. The Manager class is derived from the Employee class, so Manager is a subclass of Employee, and Employee is the superclass of Manager.

A subclass inherits all of its superclass's properties (that is, it inherits all of the superclass's member variables and member functions). When you define a subclass, you can choose to override some of the inherited member functions; this means that you can recode them to suit the ways in which the subclass differs from the superclass. You can also add new member functions and member variables that are unique to the subclass.

Before you can declare an object (an instance of a class), your procedure must have a class definition for that type of object. If the class:

• Is already defined in a class library, simply import the library into your procedure. (Class libraries are described in Reusing Classes in Class Libraries.)
• Is already defined in another procedure, simply copy and paste the definition into a class library; you can then import the library into any procedure that needs it.
• Is not yet defined anywhere, you can define it using the DESCRIBE command. Once it is defined, you can use it in that procedure, or copy it into a class library to be imported into multiple procedures.

DESCRIBE classname = ([superclass +] memvar/type [, memvar/type] ...) [;]
[memfunction 
[memfunction] ...
ENDDESCRIBE]

You can define a class once, but use it in multiple Maintain procedures, by storing its definition in a class library. A library is a kind of non-executable procedure in which you can store class definitions (as well as Maintain functions); you then import the library into each Maintain procedure in which you want to use those classes.

MODULE IMPORT (library_name [, library_name] ... );

Once a class definition exists, you can declare objects of that class. This is identical to declaring the simple variables of a built-in data type. You declare objects using the DECLARE command.

DECLARE
[(]  
objectname/class [= expression];
.
.
.
[)]