Difference between revisions of "Recital Object-Oriented Programming"

Revision as of 00:46, 11 April 2010

Recital Object-Oriented Programming

Recital is a dynamic programming language particularly well suited to the development of database applications. While Recital still supports standard procedural programming, new extensions to the language give you the power and flexibility of object-oriented programming. Object-oriented design and object-oriented programming represent a change in focus from standard procedural programming. This short primer will give you a good understanding of how to program object-oriented Recital.

Classes and Objects

Classes and objects are closely related, but they are not the same. A class contains information about how an object should look and behave. A class is the blueprint or template for an object.

All of the properties and methods for an object are specified in the class definition. In addition, classes have the following characteristics that make them especially useful for creating reusable, easily maintained code:

• Encapsulation
• Subclasses
• Inheritance
• Interfaces

To define a class use the following syntax.

define class myclass
    // class members
endclass

Then, to create an object based on this class use the following syntax.

myobject = new myclass()

Class members

Class members consists of properties (variables) and methods (procedures) that are encapsulated within the class declaration.

Properties

An object has certain properties, or attributes that are specific to the object. Properties are the equivalent of variables that can only be accessed by referencing them inside an object. By encapsulating the data (variables) and procedures within a class, programming becomes less error prone and applications easier to maintain.

Objects you create in Recital have properties that are determined by the class the object is based on. As Recital is a dynamic language, classes in Recital allow properties and methods to be added at run time.

define class myclass
    myprop = "hello world"
endclass
 
myobject = new myclass()
echo myobject.myprop    // displays "hello world"

Properties defined within classes can be simple variables, fixed arrays, dynamic arrays or objects.

Methods

Methods are procedures that are associated with objects. Methods are different from normal Recital procedures in that they are bound with an object and are called differently from the way normal Recital procedures are called.

define class myclass
    myprop = "hello world"
    public procedure mymethod()
        echo myprop
    endproc
endclass 
 
myobject = new myclass()
myobject.mymethod()    // displays "hello world"

Interface Methods

Interface Methods are template procedure definitions that must be implemented in any derived classes.

class myclass
    myprop = "hello world"
    public procedure mymethod() interface
endclass 
 
myobject = new myclass()
myobject.mymethod()    // throws an error "Interface method not defined"
 
class myclass2 as myclass
    procedure mymethod()
        echo "hello world"
    endproc
endclass
 
myobject = new myclass2()
myobject.mymethod()  // displays "hello world"

Base Methods

All classes created inherit from the object class. The object class has a set of built-in methods that are available to all classes.

Member access control modifiers

You can 'hide' properties and methods using the access control modifiers protected, hidden, private, or static.

class myclass
    private myprop = "hello world"
    public procedure mymethod()
    return myprop
    public static procedure mystaticmethod()
    endproc
endclass
 
myobject = new myclass()
// throws an error as "myprop" is private and can only be accessed by methods inside the class
echo myobject.myprop    
myobject = new myclass()
// this will work. displays "hello world"
echo myobject.mymethod()

Special methods

Several methods hold special significance in a class.

Constructors and Destructors

Recital allows developers to declare constructor and destructor methods for classes. Classes which have a constructor method called init call this method on each newly-created object, so it is suitable for any initialization that the object may need before it is used.

class myclass
    procedure init()
    // insert your own constructor code here
    endproc
endclass
 
obj = new myclass()    // the init() method is called with no arguments

You can pass arguments to the constructor method when the object is created.

class myclass
    public name
    public title
    procedure init(pname, ptitle)
        name = pname
        title = ptitle
    endproc
endclass
 
obj = new myclass("joe", "developer")    // the init() method is called with arguments

Similarly, Recital uses a destructor concept similar to that of other object-oriented languages, such as Java. The destructor method will be called as soon as all references to a particular object are removed or when the object is explicitly destroyed or in any order in shutdown sequence. The Recital destuctor method is called destroy.

class myclass
    procedure destroy()
    // insert your own destructor code here
    endproc
endclass
 
obj = new myclass()
obj = null        // the destroy() method will be called

Class inheritance and subclassing

There are many benefits of inheritance with Recital, the most common is simplifying and reducing instances of redundant code. Recital supports multiple levels of inheritance. A class that inherits a parent class is said to be a 'subclass' of the parent.

class product
    public name
    public price
    procedure init(cName, nPrice)    // constructor
        name = cName
        price = nPrice
    endproc
    procedure display()
        echo "Product name is " + name + ", price is " + price
    endproc
endclass
 
class food extends product
    private weight
endclass
 
class car extends product
    private color
endclass
 
class motorbike extends product
    private size
endclass
 
// now define a vehicle class that inherits from multiple classes (car and motorbike)
class vehicle extends car, motorbike
    public manufacturer = "Ford"
    public yearDesigned
    procedure init(cName, nPrice)    // constructor
        manufacturer = cName
        price = nPrice
    endproc
    procedure display()
        echo "Manufacturer is " + manufacturer + ", price is " + price
    endproc
endclass
 
// create a new object
myobject = new vehicle("Ford", 20000)
myobject.display()    // displays "Manufacturer is Ford, price is 20000
 
myobject = new motorbike("Honda", 1500)
myobject.display()    // displays "Product name is Honda, price is 1500

Overriding methods

As can be seen by the above example of class inheritance, you can override methods of parent classes that you inherit. If you want to call the parent class method of the same name from within a subclass, then use the dodefault() method. Note that because Recital handles multiple inheritance, and because a subclass can only have one 'parent' the last class inherited is denoted as the parent and is called by dodefault().

// now define a vehicle class that inherits from multiple classes (car and motorbike)
class vehicle extends car,motorbike
    public manufacturer = "Ford"
    public yearDesigned
    proc init(cName, nPrice)    // constructor
        manufacturer = cName
        name = cName
        price = nPrice
    endproc
    proc display()
        dodefault()                   // calls the 'display()' method in the parent class 'product'
        echo "Manufacturer is " + manufacturer + ", price is " + price
    endproc
endclass

Scope resolution operator

The scope resolution operator :: can be used to reference static methods and properties in classes.

class myclasslib
    public static mydata = array()
    public static proc display(arg)
        echo arg
    endproc
endclass

We can call the display method without instantiating an object because it is declared static e.g.

myclasslib::display("hello world")

We can access "mydata" without instantiating an object because it is declared static e.g.

myclasslib::mydata["key"] = "value"

Special variables

There are several special built-in object variables that can be used.

Iterating through object properties

You can iterate over the properties of an object using the foreach command like this.

// create a new object
myobject = new myclass()
 
// iterate over its properties
foreach myobject as name => value
    echo "name=" + name + ", value=" + value    // displays "name=MYPROP, value=hello world"
endfor

Dynamically adding and removing properties runtime

As Recital is a dynamic language, object properties can be added and removed dynamically at runtime.

// create a new object
myobject = new myclass()
 
// extend it by adding a property at runtime
myobject.addproperty("date", date())
 
// now remove it
myobject.removeproperty('date')

Dynamically assigning methods at runtime

As Recital is a dynamic language, methods can be assigned to objects dynamically at runtime.

// create a new object
myobject = new myclass()
 
// dynamically add a method
procedure mynewmethod()
    echo "hello world"
endproc
 
myobject.newmethod = mynewmethod
myobject.newmethod()    // displays "hello world"

Runtime data-type checking

You can restrict what types of data can be assigned to properties using the "as datatype" clause.

class myclass
    public myprop as character = "hello world"
    public procedure mymethod()
    return myprop
    static procedure mystaticmethod()
    endproc
endclass
 
// create a new object
myobject = new myclass()
myobject.myprop = "this is data"      // works ok
myobject.myprop = 10                      // throws an error because we defined "myprop as character"

Understanding member lookup

Recital variables and procedures are declared in a hashed, block structured symbol table. Each procedure, function or method that is executed increases the runtime execution "level". Any variables or procedures that are referenced are looked up in decreasing runtime execution level order until found. In the case of object methods, the Recital runtime engine will first look in the active object for properties and methods. If not found, then it will carry out a standard symbol table lookup in decreasing runtime level order. This technique allows classes to be easily integrated into an existing application, and provides the ability for object methods to reference global variables and call global procedures.

The life of an object

Recital uses object reference counting to handle automatic garbage collection.

When an object is created its reference count is set to 1. All assignments of objects to other variables or procedure/function arguments cause the reference count to be incremented. An object is released from memory (dereferenced) when its reference count reaches zero.

To dereference an object you simply assign another value to it. e.g.

// create a new object (and set its reference count to 1)
myobject = new myclass()
 
// now free up the object. This will decrement the reference count associated with the object.
// When the reference count is 0 then the object will be released from memory (dereferenced).
myobject = null
 
// In this example the object is not released as it is still referenced by 'myvar'
myobject = new myclass()
myvar = myobject
myobject = null
 
// now it will be released
myvar = null

If an object property (variable) is an object reference, when the object containing the property (variable) is released (dereferenced) than the reference count of all object variables is decremented, and when the reference count reaches zero, then that object is released from memory.

Writing and using class libraries

Once you have completed the development of your class library you can use the classes within your programs like this.

require_once("myclasslib")

The require_once( ) function will include the specified class library into your program only if it has not already been included. This will make all classes (also variables, procedures and functions) available to the calling program and all programs or procedures that it calls.

The specified class library is compiled into a Recital object file and loaded into shared global memory. This provides for optimal memory usage and also improved application performance as the class library is only loaded once. When class/procedure libraries (and in fact all Recital web .rsp files) are loaded like this in Recital Web memory usage will be reduced dramatically.