• Names of messages are the names of the methods, that the object must find and invoke on behalf of the programmer
• Message operator ("twiddle") is the tilde character: ~
  • "ABC"~REVERSE yields: CBA
• "Cascading" messages, two twiddles: ~~
  • "ABC"~~REVERSE yields (attention!): ABC
  • Sent messages activate the respective methods of the receiving object, however, upon return the interpreter changes the result to be always the receiving object!
    • Therefore multiple messages intended for the same object can be "cascaded" one after the other ("cascading messages) by using two tildes (~~)
• Execution (resolution) of messages: from left to right

Object Rexx implementation of the ADT Birthday

/**/
g1 = .Birthday~New
g1~Date= "20320901"
g1~Time= "16:00"
g2=.Birthday~New~~"Date="("20360229")~~"Time="("19:19")
SAY g1~date g2~date g1~time g2~time

::CLASS Birthday
::ATTRIBUTE date
::ATTRIBUTE time

Output:

20320901 20360229 16:00 19:19

Object Rexx implementation of the ADT Birthday

/**/
g1 = .Birthday~New
g1~Date= "20320901"
g1~Time= "16:00"
g2=.Birthday~New    ~~"Date="("20360229")  ~~"Time="("19:19")
SAY g1~date g2~date g1~time g2~time

::CLASS Birthday
::ATTRIBUTE date
::ATTRIBUTE time

Output:

20320901 20360229 16:00 19:19

• Determines, which variables of the caller are visible (accessible) from within the called internal routine (procedure/function)
  • Internal routines (labels), without a PROCEDURE statement
    • All variables of the calling part of the program are accessible
  • Internal routines (labels), followed by a PROCEDURE statement
    • Variables of the calling part of the program are not accessible (are hidden)
      • "Local scope"
        However: with the help of the EXPOSE subkeyword on a PROCEDURE statement one can deliberately define direct access to variables of the calling part of the program

• Determines that all classes and routines defined in a program are accessible
  • Local classes and routines cannot be hidden/overwritten
  • Classes and routines can be defined to be public
• In addition, this scope determines, that public classes and public routines of called or required (::REQUIRES directive) programs become accessible
  • Attention!
    • If different programs are called one after the after, and contain public classes or public routines with the same names, then those classes/routines are accessible that are defined in the last called program

• Defines its own scope for
  • Labels ("standard scope") and
  • Variables ("procedure scope")
• Accessing classes and routines is determined by the "program/package scope"

• Defines its own scope for
  • Labels ("standard scope") and
  • Variables ("procedure scope")
• Accessing classes and routines is determined by the "program/package scope"
• Direct access to attributes
  • Within a method it is possible to use the EXPOSE statement (must be the first statement in the method routine) to list those attributes of the class which should be made directly available for access from within the method routine

• Determines which attributes can be accessed directly from within a method
• There are two types of methods which determine the accessibility of attributes
  • Methods that are assigned to classes
    • Method and attribute directives defined after a class directive get assigned to that class
    • Expose and share the same set of instance/object attributes
  • "Floating methods" (advanced concept, can be used for dynamic programming)
    • Methods which are defined before a class directive are called "floating methods"
    • All floating methods can expose and share the same attributes with each other
    • Hint: accessing floating methods is possible via the environment symbol .METHODS from within the program where they are defined

• The NEW method will create the new object (instance, value) and will send it the message INIT to allow it to initialise
  • If the NEW message has arguments, they get forwarded with the INIT message in the same order
• The NEW method returns the reference to the newly created object (instance, value) as its result

• If there is a method named UNINIT defined for a class, then this method will be invoked, right before the unreferenced object gets deleted by the garbage collector by sendig it the UNINIT message.

• The DROP statement allows the explicit deletion of a variable
• If a variable is destroyed its reference to an existing object is removed
  • There is still the possibility that there are other variables that reference such an object

• Allows classification of instances (Objects), e.g. from biology
• Ordering of classes in superclasses and subclasses (schemata)
  • Subordered classes ("subclasses") inherit all properties of all superclasses up to and including the root class
  • Subclasses specialize in one way or the other the superclass(es)
    • "Defining of differences"
• Sometimes it may make sense, that a subclass specializes directly more than one superclass at the same time ("multiple inheritance")
  • Example: Classes representing landborne and waterborne animals, where there exists a class "amphibians", which inherits directly from the landborne and waterborne animals

• "Animal SIG" keeping dogs
  • Normal dogs
  • Little dogs
  • Big dogs
• All dogs possess a name and are able to bark
  • Normal dogs bark "Wuff Wuff"
  • Little dogs bark "wuuf"
  • Big dogs bark "WUFFF! WUFFF!! WUFFF!!!"
• Define appropriate classes taking advantage of inheritance (search order)

Definition of a class "Dog", which possess all properties which are common to all types of dogs

/**/
h1 = .Dog ~NEW ~~"NAME="("Sweety") ~~Bark

::CLASS  Dog
::ATTRIBUTE Name
::METHOD Bark
  SAY self~Name":" "Wuff Wuff"

Output:

Sweety: Wuff Wuff

Definition of a class "BigDog", which possesses all properties common to all big dogs

/**/
h1 = .Dog    ~NEW ~~"NAME="("Sweety")  ~~Bark
     .BigDog ~NEW ~~"NAME="("Grobian")  ~Bark
::CLASS  Dog    SUBCLASS Object
::ATTRIBUTE Name
::METHOD Bark
  SAY self~Name":" "Wuff Wuff"
::CLASS  BigDog SUBCLASS dog
::METHOD Bark
  SAY self~Name":" "WUFFF! WUFFF!! WUFFF!!!"

Output:

Sweety: Wuff Wuff
Grobian: WUFFF! WUFFF!! WUFFF!!!

Definition of a class "LittleDog", which possesses all properties common to all little dogs

/**/
.Dog~NEW       ~~"NAME="("Sweety")  ~Bark
.BigDog~NEW    ~~"NAME="("Grobian") ~Bark
.LittleDog~NEW ~~"NAME="("Arnie")   ~Bark
::CLASS  Dog
::ATTRIBUTE Name
::METHOD Bark
  SAY self~Name":" "Wuff Wuff"
::CLASS  BigDog    SUBCLASS dog
::METHOD Bark
  SAY self~Name":" "WUFFF! WUFFF!! WUFFF!!!"
::CLASS  LittleDog SUBCLASS dog
::METHOD Bark
  SAY self~Name":" "wuuf"

Output:

Sweety: Wuff Wuff
Grobian: WUFFF! WUFFF!! WUFFF!!!
Arnie: wuuf

Definition of a class "LittleDog", which possesses all properties common to all little dogs

/**/
.Dog~NEW       ~~"NAME="("Sweety")  ~Bark
.BigDog~NEW    ~~"NAME="("Grobian") ~Bark
.LittleDog~NEW ~~"NAME="("Arnie")   ~Bark
::CLASS  Dog         SUBCLASS Object
::ATTRIBUTE Name
::METHOD Bark
  SAY self~Name":" "Wuff Wuff" "-" self
::CLASS  BigDog      SUBCLASS dog
::METHOD Bark
  SAY self~Name":" "WUFFF! WUFFF!! WUFFF!!!" "-" self
::CLASS  "LittleDog" SUBCLASS dog
::METHOD Bark
  SAY self~Name":" "wuuf" "-" self

Output:

Sweety: Wuff Wuff - a DOG
Grobian: WUFFF! WUFFF!! WUFFF!!! - a BIGDOG
Arnie: wuuf - a LittleDog