The variables in an object that store the data and procedures are referred to as the object's members.  Procedures associated with an object are called methods.  Object members have access controls which limit where the members can be accessed from, similar to modules.  Members declared exported can be accessed from anywhere.  Members declared local can only be accessed from within the object's methods.  Objects are instances of a class.  A class describes the exports and locals that each instance of the class (the objects) will have.

Benefits of object oriented programming are:

To create a new class of objects, use the named module declaration syntax with option object.

This will create a new object and assign the new object to the module name (NewObject in the example above).  An object created this way will be referred to as a prototype object.  In Maple, any object (prototype or other) can be used as a representative of the class.

When declaring an object the members must be declared as either local to the object, using a local declaration or exported, using an export declaration.  A member that is declared local can only be accessed from the object's methods, or other object's methods of the same class.  A member that is exported, can be accessed anywhere.

By default, the values assigned to the object's members are unique to the object.  That is, two objects of the same class can have different values assigned to their members.  However some members, member procedures in particular, are shared among all objects of a class.  Thus members can also be declared as static.  A static member stores only one value that is common to all objects of a class.

Once a prototype object exists, it can be used to create new objects using the Object routine.  The Object routine creates a new object of the same class as the object passed into Object.

By default, the newly created object will have its members assigned the same values as the object passed to Object.  However by implementing a ModuleCopy routine, the object can perform different actions when new instances are created.  A ModuleCopy routine can accept additional arguments that are passed into the Object routine.

All objects are of type object.  In addition type and :: can be used to determine if an object is a instance of a particular class by passing an object of the expected class as the type.  You can refine this type checking by defining the ModuleType method.

A method belonging to a particular class can access both the local and exported members of any object of that class.  This allows methods to access and manipulate the internal states of their objects without requiring the objects to export accessor procedures.

In Maple, most method names should be declared as static.  In most cases, all objects of the same class use the same procedures for their methods.  If the method name is not declared static, each object will have a separate copy of the procedure.  This can be quite wasteful.

There are some instances where an object will have a non-static method.  However unless you intend different objects to have different procedures assigned to the method, your method should be static.

Some object oriented languages associate method calls with a particular object.  That object is represented via a self variable or by allowing direct access to that object's members.  Maple does not give a particular object special significance in that way.  Instead, all objects that a method needs to manipulate must be passed as parameters.

To call an object's method, call the method as a standard function call and pass the object in as an argument.

When a function call is evaluated and an object is passed in as an argument, the object is searched for an exported procedure with a matching name.  If one is found, that member procedure is called with the given arguments.

This search proceeds from left to right, so the first object with a matching method is used as the class whose method is invoked.

When making an indexed function call (of the form func[index](args)) Maple will also check the indices (index) for a matching object as well as the arguments.  If a matching object is found in the indices, that object will be used before one found in the arguments.

Search an index sequence is also performed from left to right.

There are a set of special methods that a class can define that will automatically be used in various situations.  Not all of these methods make sense for all objects.  See the method specific help pages for complete details.

ModuleCopy: The ModuleCopy method is invoked when a object is copied via the Object routine.

ModuleType: The ModuleType method is invoked when an object is passed into the type routine.  It allows a module to have a more precise type check of objects of a particular class.

ModulePrint: The ModulePrint method is invoked when an object is pretty-printed.

ModuleDeconstruct: The ModuleDeconstruct method is invoked when an object is converted to a 1 dimensional form, usually Maple syntax.

ModuleApply: The ModuleApply method is invoked when an object is used as a function in a function call expression.

ModuleLoad: The ModuleLoad method is invoked when the object class is read in from a library.

ModuleUnload: The ModuleUnload method is invoked when an object is collected.

ModuleIterator: The ModuleIterator method creates an interface that can be used to iterate over the contents of the object.

The following operators can be overloaded by an object:

The following operators, in particular, cannot be overridden:

Note: These lists are not the same as the operators that can and cannot be overridden using a use statement.

In general implementing operators is similar to implementing normal methods.  However particular operators have rules that must be followed if they are to be implemented correctly.

The rules for the various operators are documented on the Object,operators help page.

The following built-in routines can be overloaded by object methods:

Some overloadable built-in routines have a specific interface that must be followed.  The interfaces for the overloadable built-ins can be found on the object,builtins help page.

A object's method will be invoked whenever that object appears in a matching function call, regardless of the object's position in the argument sequence.  Thus when implementing operators and overloading built-in routines, it is important the handle all the cases where the object could appear.

In the following example it might be easy to assume that when member is called the object will be the first argument (the container).  However, it is also possible that the object will appear as the second argument (the element being searched for).

For some possibilities, the correct approach is to simply pass the arguments on to the Maple routine.  When doing so, care must be taken to access the correct version of the routine.

When overloading operators and built-in routines, those overloads will be used within the implementation of the object itself.  This means that care should be taken to call the global version of a routine when it is required.  In the member overload shown earlier, the code invokes the global version of member, by using quotes and :-.  Failing to do so can lead to infinite recursions and other unexpected behavior.

Be careful when assuming that operators and built-in routines will always be passed a certain number of arguments.  Many will accept NULL as an argument, and this may lead to fewer arguments then expected.

Members that are declared as local can only be accessed from within the class's methods.  This means that methods cannot use lexical scoping to pass values to nested procedures.

In this example, we can print the value of a in b because b is a method.  However the map fails because the arrow procedure is not a member and thus does not have access to a.