In Maple, method names should be declared with type static.  In most cases, all objects of the same class use the same procedures for their methods. Thus if the method names are not declared static, each object will have a separate copy of the procedure.  For more information on using static with objects, see Creating a New Object.

A static method should not use lexical scoping to refer to non-static local or exported variables within the object. Lexically scoped references need to be updated when an object is copied (new instances created), but since a static method is shared between instances, this is not possible.

Instead, static methods should refer to the local or exported variables of one of the object parameters passed into the method (see the next section), using the object:-variable notation.

Lexical scoping may be used to refer to static variables. As these are shared between all instances of an object, references to them are the same for all instances.

As of Maple 2021, if the method has a formal parameter named _self, references to its object's local or exported variables may be written without prefixing them. That is, _self:-variable may be written as just variable. Maple will add the self:- prefix internally when the method is simplified.

If you declare a method that needs to access the contents of an object, that object must be passed into the method as an argument.  This is in contrast to some object oriented languages which allow access to the contents of an object associated with the current invocation, either through direct access to the object's members or through a self variable. The method will have access to the local variables of any object of the same class that the method was declared in.

As of Maple 2021, a message-passing form of method call can be used, which will automatically pass the object as an argument if the method has a formal parameter named _self.

In the following example, the set and toString methods expect an instance of the StringBuffer class as their first argument.

The special ModuleCopy and ModuleApply methods can be combined to implement an object factory routine.  The ModuleCopy method is used to define what happens when the Object routine is called to create a new object.  The ModuleApply method defines what happens when an object name is applied (that is, used as a function call).

By adding the following methods to the declaration of StringBuffer,  the ModuleApply method becomes a factory routine.

Having defined a ModuleCopy and ModuleApply, we can now call StringBuffer like a function to create new instances.

$\mathrm{sb2}≔\mathrm{Object<<StringBuffer,140617193142400>>}$

$5$

$\mathrm{sb3}≔\mathrm{Object<<StringBuffer,140617193118272>>}$

$5$

$\mathrm{sb4}≔\mathrm{Object<<StringBuffer,140617192607072>>}$

$5$

There are other special method names that can be defined. For a complete list of these methods, see the Overview of Objects in Maple page.

Objects in Maple can implement operator methods.  These methods will be invoked when objects are used with the corresponding operators in Maple. One can implement the = operator for StringBuffer as follows:

$\mathrm{sb1}≔\mathrm{Object<<StringBuffer,140617192579200>>}$

$\mathrm{sb2}≔\mathrm{Object<<StringBuffer,140617192569536>>}$

$\mathrm{sb3}≔\mathrm{Object<<StringBuffer,140617192100928>>}$

$\mathrm{true}$

$\mathrm{false}$

$\mathrm{false}$

Note Checking for the 1 argument case handles the possibility that an object is compared to NULL.

$\mathrm{false}$

There are many operators that can be overloaded.  For a complete list, and more information about overloading operators, see the Objects Overloading Operators page.

Objects can override certain Maple routines of type builtin by defining a method with the same name.  For example, StringBuffer can implement a numelems member as follows.  

When calling the top level numelems routine, we need to use the :- notation to differentiate from StringBuffer's numelems method.  Without this the StringBuffer numelems method would have an infinite recursion.

With the numelems method defined, we can pass StringBuffer objects into numelems, just as we could other Maple structures.

$3$

$5$

$11$

$11$

Not all builtin routines can be overridden.  For a complete list of routines that can be overridden and more discussion of overriding builtin routines, see Objects Overloading builtin Routines.