Getting started

Select the object-oriented programming paradigm

To undertake object-oriented programming (OOP) with Elan, you should first be reasonably familiar with procedural programming with Elan. Start by switching to the object-oriented paradigm from the menu at the top of the IDE. This will still allow you to do procedural programming, but changes two things:

• The list of demo programs will now show only programs that use OOP - except that Snake is offered in both procedural and object-oriented forms for direct comparison. We will be referring to code within the OOP demo programs within this text.
• It will change some of the options available on the new code menus in the editor:
  • At the global level, it will offer: concrete class and abstract class
  • Within a concrete class or abstract class the new code menu will show an entirely new list of instructions, collectively known as 'members' (plus comment) that may be defined within within them.

In the following section we will describe 10 principles that define the essence of OOP, illustrated with example code - where possible from the demo programs.

Principles of object-oriented programming

Important. Every textbook on OOP differs slightly in the definition of core principles, and every language that supports OOP differs in the rules that it enforces. The following 10 principles are based on widely recognised best practices in OOP. When coding with Elan, in whichever of the supported languages - Python, VB, C#, or Java (or the Elan Reference Language) - these principles are, wherever possible, enforced by the Elan tooling. The resulting code is always valid syntax for the chosen language - but may depend upon common library methods defined in the Elan library. Also, if you go on to write code in any of those languages outside Elan, you will find that the same principles are not necessarily enforced. Though that might appear to offer you more freedom, sticking voluntarily to the principles that you learned in Elan will result in better code and fewer problems.

A class is a user-defined data structure type

In procedural programming with Elan, there is a fixed set of types available to you to represent data - the only exception being enums which offer a very limited form of 'user-defined' type (UDT). OOP makes it easy to define far richer forms of UDTs. The simplest and most common way to do this is to define a concrete class which is one of the new options made available at global (file) level when using Elan with the object-oriented paradigm selected.

In the Snake object-oriented demo you can find three examples of concrete classes. Only the 'signature' of each class is shown here - not the instructions contained within the classes:

+class SnakeName? inheritance?1 +constructor(parameter definitions?) 2 new code end constructor +function toStringname?(parameter definitions?) returns StringType? 3 return "undefined"value or expression?4 end function end class +class AppleName? inheritance?5 +constructor(parameter definitions?) 6 new code end constructor +function toStringname?(parameter definitions?) returns StringType? 7 return "undefined"value or expression?8 end function end class +class SquareName? inheritance?9 +constructor(parameter definitions?) 10 new code end constructor +function toStringname?(parameter definitions?) returns StringType? 11 return "undefined"value or expression?12 end function end class

+class SnakeName? inheritance?: # concrete class1 +def __init__(self: Snake) -> None: 2 new code # end constructor +def toStringname?(self: Snake) -> strType?: # function method3 return "undefined"value or expression?4 # end function method # end class +class AppleName? inheritance?: # concrete class5 +def __init__(self: Apple) -> None: 6 new code # end constructor +def toStringname?(self: Apple) -> strType?: # function method7 return "undefined"value or expression?8 # end function method # end class +class SquareName? inheritance?: # concrete class9 +def __init__(self: Square) -> None: 10 new code # end constructor +def toStringname?(self: Square) -> strType?: # function method11 return "undefined"value or expression?12 # end function method # end class

+class SnakeName? inheritance? {1 +public Snake(parameter definitions?) { 2 new code } // end constructor +public stringType? toStringname?(parameter definitions?) { // function method3 return "undefined"value or expression?;4 } // end function method } // end class +class AppleName? inheritance? {5 +public Apple(parameter definitions?) { 6 new code } // end constructor +public stringType? toStringname?(parameter definitions?) { // function method7 return "undefined"value or expression?;8 } // end function method } // end class +class SquareName? inheritance? {9 +public Square(parameter definitions?) { 10 new code } // end constructor +public stringType? toStringname?(parameter definitions?) { // function method11 return "undefined"value or expression?;12 } // end function method } // end class

+Class SnakeName? inheritance?1 +Sub New(parameter definitions?) 2 new code End Sub +Function toStringname?(parameter definitions?) As StringType? 3 Return "undefined"value or expression?4 End Function End Class +Class AppleName? inheritance?5 +Sub New(parameter definitions?) 6 new code End Sub +Function toStringname?(parameter definitions?) As StringType? 7 Return "undefined"value or expression?8 End Function End Class +Class SquareName? inheritance?9 +Sub New(parameter definitions?) 10 new code End Sub +Function toStringname?(parameter definitions?) As StringType? 11 Return "undefined"value or expression?12 End Function End Class

public class Global {

+class SnakeName? inheritance? {1 +public Snake(parameter definitions?) { 2 new code } // end constructor +public StringType? toStringname?(parameter definitions?) { // function method3 return "undefined"value or expression?;4 } // end function method } // end class +class AppleName? inheritance? {5 +public Apple(parameter definitions?) { 6 new code } // end constructor +public StringType? toStringname?(parameter definitions?) { // function method7 return "undefined"value or expression?;8 } // end function method } // end class +class SquareName? inheritance? {9 +public Square(parameter definitions?) { 10 new code } // end constructor +public StringType? toStringname?(parameter definitions?) { // function method11 return "undefined"value or expression?;12 } // end function method } // end class

} // end Global

Within the definition of each class you will find several property instructions. Each property has unique name (within the class). A class may defined multiple properties of the same type, for example, the SquareSquareSquareSquareSquare class in Snake defines:

Name	type
xxxxx	IntintintIntegerint
yyyyy	IntintintIntegerint

or properties may have different types, for example the TuringMachineTuringMachineTuringMachineTuringMachineTuringMachine class in the Roman Numerals Turing Machine demo has these:

name	type
initialStateinitialStateinitialStateinitialStateinitialState	StringstrstringStringString
currentStatecurrentStatecurrentStatecurrentStatecurrentState	StringstrstringStringString
headPositionheadPositionheadPositionheadPositionheadPosition	IntintintIntegerint
haltStatehaltStatehaltStatehaltStatehaltState	StringstrstringStringString
rulesrulesrulesrulesrules	List<of Rule>list[Rule]List<Rule>List(Of Rule)List<Rule>
tapetapetapetapetape	StringstrstringStringString

Defining a class

Selecting concrete class from the new code menu inserts a template like this:

where the only thing you must provide is a unique name for the class, which must start with a capital letter, followed by other letters, digits or underscores. (We will look at the roles of the constructor, and the toString function later on.)

An object is an instance of a class

Every object in code is an instance of a specific class. The class may be thought of as a 'template' for defining instances. Each instance holds its own specific value for each of the properties defined in the class.

An new object may be created and assigned to a variable definition, for example:

variable applename? set to new Apple()value or expression?33

applename? = Apple()value or expression? # variable definition34

var applename? = new Apple()value or expression?;35

Dim applename? = New Apple()value or expression? ' variable definition36

var applename? = new Apple()value or expression?;37

variable snakename? set to new Snake()value or expression?38

snakename? = Snake()value or expression? # variable definition39

var snakename? = new Snake()value or expression?;40

Dim snakename? = New Snake()value or expression? ' variable definition41

var snakename? = new Snake()value or expression?;42

Note that the type of each variable is determined by the class of the instance so that the appleappleappleappleapple variable may subsequently be reassigned to a different instance of AppleAppleAppleAppleApple but may not be reassigned to an instance of a different class (nor any other type).

A new instance may also be created as part of an expression without having to be assigned to a variable, for example:

Reading properties

Wherever you have a reference to an object, your code may read and make use of the publicly-visible properties of that object using 'dot syntax', for example (from the Pathfinder demo):

is comparing the value of the variable distViaCurrentdistViaCurrentdistViaCurrentdistViaCurrentdistViaCurrent to the property named distFromStartdistFromStartdistFromStartdistFromStartdistFromStart of the object named neighbourneighbourneighbourneighbourneighbour.

The constructor initialises the properties

When coding with Elan every class must define a constructor, the template for which is created when you define a new class, and which may be edited, though not deleted. The role of the constructor is to initialise the properties whenever an instance of that class is created.

The only properties that don't need to be initialised are properties of type IntintintIntegerint, FloatfloatdoubleDoubledouble, or BooleanboolboolBooleanboolean - which are automatically initialised to the default value of each type - 00000, 0.00.00.00.00.0, or falseFalsefalseFalsefalse respectively. All other properties must be explicitly initialised within the constructor. Here is simple example of properties being initialised within the constructor for SquareSquareSquareSquareSquare in the Snake demo:

+class SquareName? inheritance?58 +constructor(x as Int, y as Intparameter definitions?) 59 assign this.xvariableName? to xvalue or expression?60 assign this.yvariableName? to yvalue or expression?61 end constructor property xname? as IntType?62 property yname? as IntType?63 # Methods not shown herecomment? +function toStringname?(parameter definitionsparameter definitions?) returns StringType? 64 return "{this.x}, {this.y}"value or expression?65 end function end class

+class SquareName? inheritance?: # concrete class66 +def __init__(self: Square, x: int, y: intparameter definitions?) -> None: 67 self.xvariableName? = xvalue or expression? # assignment68 self.yvariableName? = yvalue or expression? # assignment69 # end constructor xname?: intType? # property70 yname?: intType? # property71 # Methods not shown herecomment? +def toStringname?(self: Square) -> strType?: # function method72 return "{this.x}, {this.y}"value or expression?73 # end function method # end class

+class SquareName? inheritance? {74 +public Square(int x, int yparameter definitions?) { 75 this.xvariableName? = xvalue or expression?; // assignment76 this.yvariableName? = yvalue or expression?; // assignment77 } // end constructor public intType? xname? {get; private set;} // property78 public intType? yname? {get; private set;} // property79 // Methods not shown herecomment? +public stringType? toStringname?(parameter definitionsparameter definitions?) { // function method80 return "{this.x}, {this.y}"value or expression?;81 } // end function method } // end class

+Class SquareName? inheritance?82 +Sub New(x As Integer, y As Integerparameter definitions?) 83 Me.xvariableName? = xvalue or expression? ' assignment84 Me.yvariableName? = yvalue or expression? ' assignment85 End Sub Property xname? As IntegerType?86 Property yname? As IntegerType?87 ' Methods not shown herecomment? +Function toStringname?(parameter definitionsparameter definitions?) As StringType? 88 Return "{this.x}, {this.y}"value or expression?89 End Function End Class

+class SquareName? inheritance? {90 +public Square(int x, int yparameter definitions?) { 91 this.xvariableName? = xvalue or expression?; // assignment92 this.yvariableName? = yvalue or expression?; // assignment93 } // end constructor public intType? xname?; // property94 public intType? yname?; // property95 // Methods not shown herecomment? +public StringType? toStringname?(parameter definitionsparameter definitions?) { // function method96 return "{this.x}, {this.y}"value or expression?;97 } // end function method } // end class

Note:

• Even properties that are automatically initialised may be explicitly initialised in the constructor.
• It is quite common to initialise strings to an empty string - """""""""" and a list to any empty list of the appropriate member-type, for example new List<of Int>()list[int]()new List<int>()New List(Of Integer)()new List<int>() - though you may choose any value.
• If you don't you want every instance of a class to be initialised with the same value, the specific value for an instance is specified via parameters added into the constructor definition.
• When a new instance is created, arguments for each parameter must be specified (as they would be for a procedure or function), so creating a new SquareSquareSquareSquareSquare for example takes the form variable tailname? set to new Square(20, 15)value or expression?0tailname? = Square(20, 15)value or expression? # variable definition1var tailname? = new Square(20, 15)value or expression?;2Dim tailname? = New Square(20, 15)value or expression? ' variable definition3var tailname? = new Square(20, 15)value or expression?;4
• A property is initialised within the construction using an assignment instruction - since a property may be thought of as a named variable that holds a value specific to each instance of the class.
• the name of the property being reassigned must be prefixed by thisselfMethisMe followed by a dot.

Objects may have associations to other objects

So far we have looked at properties where the type is one of the standard library types. However, a class may define one or more properties where the type is a class - either of the same type as the class in which the property is defined, or - more commonly - of a different class. Each such property is referred to as an 'association' or 'associated object'. If the type of a property is a list, or other data structure, where the member type is a class, then it is often referred to as a 'multiple association' - with the ordinary kind of association referred to as 'single association'. The SnakeSnakeSnakeSnakeSnake class shows both kinds of association (only relevant parts of the class are shown only here):

+class SnakeName? inheritance?98 +constructor(parameter definitionsparameter definitions?) 99 variable tailname? set to new Square(20, 15)value or expression?100 assign this.currentDirvariableName? to Direction.rightvalue or expression?101 assign this.bodyvariableName? to [tail]value or expression?102 assign this.headvariableName? to tail.getAdjacentSquare(this.currentDir)value or expression?103 assign this.priorTailvariableName? to tailvalue or expression?104 end constructor private property currentDirname? as DirectionType?105 private property headname? as SquareType?106 private property bodyname? as List<of Square>Type?107 private property priorTailname? as SquareType?108 +function toStringname?(parameter definitions?) returns StringType? 109 return "undefined"value or expression?110 end function end class

+class SnakeName? inheritance?: # concrete class111 +def __init__(self: Snake) -> None: 112 tailname? = Square(20, 15)value or expression? # variable definition113 self.currentDirvariableName? = Direction.rightvalue or expression? # assignment114 self.bodyvariableName? = [tail]value or expression? # assignment115 self.headvariableName? = tail.getAdjacentSquare(self.currentDir)value or expression? # assignment116 self.priorTailvariableName? = tailvalue or expression? # assignment117 # end constructor currentDirname?: DirectionType? # private property118 headname?: SquareType? # private property119 bodyname?: list[Square]Type? # private property120 priorTailname?: SquareType? # private property121 +def toStringname?(self: Snake) -> strType?: # function method122 return "undefined"value or expression?123 # end function method # end class

+class SnakeName? inheritance? {124 +public Snake(parameter definitionsparameter definitions?) { 125 var tailname? = new Square(20, 15)value or expression?;126 this.currentDirvariableName? = Direction.rightvalue or expression?; // assignment127 this.bodyvariableName? = new [] {tail}value or expression?; // assignment128 this.headvariableName? = tail.getAdjacentSquare(this.currentDir)value or expression?; // assignment129 this.priorTailvariableName? = tailvalue or expression?; // assignment130 } // end constructor private DirectionType? currentDirname? {get; private set;} // private property131 private SquareType? headname? {get; private set;} // private property132 private List<Square>Type? bodyname? {get; private set;} // private property133 private SquareType? priorTailname? {get; private set;} // private property134 +public stringType? toStringname?(parameter definitions?) { // function method135 return "undefined"value or expression?;136 } // end function method } // end class

+Class SnakeName? inheritance?137 +Sub New(parameter definitionsparameter definitions?) 138 Dim tailname? = New Square(20, 15)value or expression? ' variable definition139 Me.currentDirvariableName? = Direction.rightvalue or expression? ' assignment140 Me.bodyvariableName? = {tail}value or expression? ' assignment141 Me.headvariableName? = tail.getAdjacentSquare(Me.currentDir)value or expression? ' assignment142 Me.priorTailvariableName? = tailvalue or expression? ' assignment143 End Sub Private Property currentDirname? As DirectionType?144 Private Property headname? As SquareType?145 Private Property bodyname? As List(Of Square)Type?146 Private Property priorTailname? As SquareType?147 +Function toStringname?(parameter definitions?) As StringType? 148 Return "undefined"value or expression?149 End Function End Class

+class SnakeName? inheritance? {150 +public Snake(parameter definitionsparameter definitions?) { 151 var tailname? = new Square(20, 15)value or expression?;152 this.currentDirvariableName? = Direction.rightvalue or expression?; // assignment153 this.bodyvariableName? = list(tail)value or expression?; // assignment154 this.headvariableName? = tail.getAdjacentSquare(this.currentDir)value or expression?; // assignment155 this.priorTailvariableName? = tailvalue or expression?; // assignment156 } // end constructor private DirectionType? currentDirname?; // private property157 private SquareType? headname?; // private property158 private List<Square>Type? bodyname?; // private property159 private SquareType? priorTailname?; // private property160 +public StringType? toStringname?(parameter definitions?) { // function method161 return "undefined"value or expression?;162 } // end function method } // end class

Note:

• TheSnakeSnakeSnakeSnakeSnake is always initialised to the same values, so the constructor does not need to define any parameters.
• The currentDircurrentDircurrentDircurrentDircurrentDir property is of type DirectionDirectionDirectionDirectionDirection (which is an enum) and is initialised to Direction.rightDirection.rightDirection.rightDirection.rightDirection.right.
• The bodybodybodybodybody property is a multiple association - defined as a list of type SquareSquareSquareSquareSquare
• The constructor defines a variable tailtailtailtailtail used only for the purpose of initialising properties. It is first used to initialise the bodybodybodybodybody as a list containing only the tailtailtailtailtail and is finally used to define the priorTailpriorTailpriorTailpriorTailpriorTail which is a single association of type SquareSquareSquareSquareSquare. In between it is used in an expression to determine the initial value for the headheadheadheadhead property using a function (more on this in the next heading).
• It is thus legitimate to call functions within the constructor. A constructor may not call any procedure, however. And you should avoid doing any work in a constructor other than determining appropriate values for initialising its properties.

Classes provide behaviour through methods

In the last code example tail.getAdjacentSquare(this.currentDir)tail.getAdjacentSquare(self.currentDir)tail.getAdjacentSquare(this.currentDir)tail.getAdjacentSquare(Me.currentDir)tail.getAdjacentSquare(this.currentDir) calls a function method, using 'dot syntax' on the the variable tailtailtailtailtail, which is an instance of class SquareSquareSquareSquareSquare. Defining a function method, or a procedure method, on a class has these advantages:

• they are invoked on an instance using 'dot-syntax' as we shown in the previous example
• they have access to all the properties belonging to that same instance, and can also invoke other methods on the same object, in both cases prefixed by thisselfMethisMe dot.

Properties on a class define the data (or 'state') for each instance of the class; methods define the behaviour for the object.

A function method provides information based on the parameters specified in combination with the object's properties

Function methods defined on a class, are similar to global functions in that they act like 'queries', returning information that is determined by the values of the parameters. The difference is that a function method defined on a class, may additionally make use of information obtained from the properties of the object (directly or indirectly) - to determine the information to be returned. But like a global function, a function method defined on a class may not cause any side effects, which means that it may not update any property. The body of the getAdjacentSquare accesses the objects xxxxx and yyyyy properties and uses this, together with the DirectionDirectionDirectionDirectionDirection parameter to create and return a new instance of SquareSquareSquareSquareSquare with different xxxxx and yyyyy properties:

+function getAdjacentSquarename?(d as Directionparameter definitions?) returns SquareType? 163 variable newXname? set to this.xvalue or expression?164 variable newYname? set to this.yvalue or expression?165 +if d is Direction.leftcondition? then 166 assign newXvariableName? to this.x - 1value or expression?167 elif d is Direction.rightcondition? then168 assign newXvariableName? to this.x + 1value or expression?169 elif d is Direction.upcondition? then170 assign newYvariableName? to this.y - 1value or expression?171 elif d is Direction.downcondition? then172 assign newYvariableName? to this.y + 1value or expression?173 end if return new Square(newX, newY)value or expression?174 end function

+def getAdjacentSquarename?(d: Directionparameter definitions?) -> SquareType?: # function175 newXname? = self.xvalue or expression? # variable definition176 newYname? = self.yvalue or expression? # variable definition177 +if d == Direction.leftcondition?: 178 newXvariableName? = self.x - 1value or expression? # assignment179 elif d == Direction.rightcondition?: # else if180 newXvariableName? = self.x + 1value or expression? # assignment181 elif d == Direction.upcondition?: # else if182 newYvariableName? = self.y - 1value or expression? # assignment183 elif d == Direction.downcondition?: # else if184 newYvariableName? = self.y + 1value or expression? # assignment185 # end if return Square(newX, newY)value or expression?186 # end function

+static SquareType? getAdjacentSquarename?(Direction dparameter definitions?) { // function187 var newXname? = this.xvalue or expression?;188 var newYname? = this.yvalue or expression?;189 +if (d == Direction.leftcondition?) { 190 newXvariableName? = this.x - 1value or expression?; // assignment191 } else if (d == Direction.rightcondition?) {192 newXvariableName? = this.x + 1value or expression?; // assignment193 } else if (d == Direction.upcondition?) {194 newYvariableName? = this.y - 1value or expression?; // assignment195 } else if (d == Direction.downcondition?) {196 newYvariableName? = this.y + 1value or expression?; // assignment197 } // end if return new Square(newX, newY)value or expression?;198 } // end function

+Function getAdjacentSquarename?(d As Directionparameter definitions?) As SquareType? 199 Dim newXname? = Me.xvalue or expression? ' variable definition200 Dim newYname? = Me.yvalue or expression? ' variable definition201 +If d = Direction.leftcondition? Then 202 newXvariableName? = Me.x - 1value or expression? ' assignment203 ElseIf d = Direction.rightcondition? Then204 newXvariableName? = Me.x + 1value or expression? ' assignment205 ElseIf d = Direction.upcondition? Then206 newYvariableName? = Me.y - 1value or expression? ' assignment207 ElseIf d = Direction.downcondition? Then208 newYvariableName? = Me.y + 1value or expression? ' assignment209 End If Return New Square(newX, newY)value or expression?210 End Function

+static SquareType? getAdjacentSquarename?(Direction dparameter definitions?) { // function211 var newXname? = this.xvalue or expression?;212 var newYname? = this.yvalue or expression?;213 +if (d == Direction.leftcondition?) { 214 newXvariableName? = this.x - 1value or expression?; // assignment215 } else if (d == Direction.rightcondition?) {216 newXvariableName? = this.x + 1value or expression?; // assignment217 } else if (d == Direction.upcondition?) {218 newYvariableName? = this.y - 1value or expression?; // assignment219 } else if (d == Direction.downcondition?) {220 newYvariableName? = this.y + 1value or expression?; // assignment221 } // end if return new Square(newX, newY)value or expression?;222 } // end function

The toString function method returns a string that represents the object in some way. It is called automatically whenever you call print with a variable that holds an instance of the class. If you don't need to print an object in text form on the display, it is safe to leave the default implementation toString - that was created when you added the class, and which returns an empty string """""""""". If you do intend to print an object in text form then you can define the string to be returned, incorporating one or more of the object's properties to help identify the particular object. For example, you might edit the method defined on the SnakeSnakeSnakeSnakeSnake class to:

(You might like to try this out, temporarilyadding the instruction print(snake)print(snake)print(snake)print(snake)print(snake) into the main routine.)

A procedure method changes the state of the object, and/or interacts with the system

Procedure methods, like function methods, may define parameters and may also read the values of the object's properties. Like global procedures they may also generate side effects, and this includes changing the values of the object's properties, and may call other procedures, on the same object, or associated objects. For example, the clockTick procedure method defined in the SnakeSnakeSnakeSnakeSnake class, changes the position of various segments, and, if the headheadheadheadhead now covers the same space as the appleappleappleappleapple changes the position of the apple (passed into the method as a parameter) by calling the newRandomPosition procedure method on appleappleappleappleapple:

+procedure clockTickname?(key as String, apple as Appleparameter definitions?) 233 call this.setDirectionprocedureName?(keyarguments?)234 assign this.priorTailvariableName? to this.body[0]value or expression?235 variable bodyname? set to this.bodyvalue or expression?236 call body.appendprocedureName?(this.headarguments?)237 assign this.headvariableName? to this.head.getAdjacentSquare(this.currentDir)value or expression?238 +if this.head.equals(apple.location)condition? then 239 call apple.newRandomPositionprocedureName?(thisarguments?)240 else241 assign this.bodyvariableName? to this.body.subList(1, this.body.length())value or expression?242 end if end procedure

+def clockTickname?(key: str, apple: Appleparameter definitions?) -> None: # procedure243 self.setDirectionprocedureName?(keyarguments?) # procedure call244 self.priorTailvariableName? = self.body[0]value or expression? # assignment245 bodyname? = self.bodyvalue or expression? # variable definition246 body.appendprocedureName?(self.headarguments?) # procedure call247 self.headvariableName? = self.head.getAdjacentSquare(self.currentDir)value or expression? # assignment248 +if self.head.equals(apple.location)condition?: 249 apple.newRandomPositionprocedureName?(selfarguments?) # procedure call250 else:251 self.bodyvariableName? = self.body.subList(1, self.body.length())value or expression? # assignment252 # end if # end procedure

+static void clockTickname?(string key, Apple appleparameter definitions?) { // procedure253 this.setDirectionprocedureName?(keyarguments?); // procedure call254 this.priorTailvariableName? = this.body[0]value or expression?; // assignment255 var bodyname? = this.bodyvalue or expression?;256 body.appendprocedureName?(this.headarguments?); // procedure call257 this.headvariableName? = this.head.getAdjacentSquare(this.currentDir)value or expression?; // assignment258 +if (this.head.equals(apple.location)condition?) { 259 apple.newRandomPositionprocedureName?(thisarguments?); // procedure call260 } else {261 this.bodyvariableName? = this.body.subList(1, this.body.length())value or expression?; // assignment262 } // end if } // end procedure

+Sub clockTickname?(key As String, apple As Appleparameter definitions?) ' procedure263 Me.setDirectionprocedureName?(keyarguments?) ' procedure call264 Me.priorTailvariableName? = Me.body(0)value or expression? ' assignment265 Dim bodyname? = Me.bodyvalue or expression? ' variable definition266 body.appendprocedureName?(Me.headarguments?) ' procedure call267 Me.headvariableName? = Me.head.getAdjacentSquare(Me.currentDir)value or expression? ' assignment268 +If Me.head.equals(apple.location)condition? Then 269 apple.newRandomPositionprocedureName?(Mearguments?) ' procedure call270 Else271 Me.bodyvariableName? = Me.body.subList(1, Me.body.length())value or expression? ' assignment272 End If End Sub

+static void clockTickname?(String key, Apple appleparameter definitions?) { // procedure273 this.setDirectionprocedureName?(keyarguments?); // procedure call274 this.priorTailvariableName? = this.body[0]value or expression?; // assignment275 var bodyname? = this.bodyvalue or expression?;276 body.appendprocedureName?(this.headarguments?); // procedure call277 this.headvariableName? = this.head.getAdjacentSquare(this.currentDir)value or expression?; // assignment278 +if (this.head.equals(apple.location)condition?) { 279 apple.newRandomPositionprocedureName?(thisarguments?); // procedure call280 } else {281 this.bodyvariableName? = this.body.subList(1, this.body.length())value or expression?; // assignment282 } // end if } // end procedure

Objects should represent the principal nouns in the application domain

The word 'encapsulation' is often used in descriptions of object-oriented programming. But that word has two rather different meanings in plain English. Fortunately, both of the meanings of 'encapsulation' apply.

The first meaning of encapsulation is similar to 'represents' - as in 'Our school motto encapsulates the ethos and culture of the school'. (The second meaning will be addressed in the next principle.) Thus, objects should represent, or encapsulate, the principal concepts in the application domain. A rule of thumb is that the classes defined in a program should correspond to the main nouns used when describing the purpose and operation of the program in plain English. You can see this in the Snake demo, where the code defines three classes, named SnakeSnakeSnakeSnakeSnake, AppleAppleAppleAppleApple, and SquareSquareSquareSquareSquare - all nouns that would be recognised by anyone who understands how to play the game Snake, but who does not necessarily know anything about programming.

One of the claimed benefits of this is that it makes programs easier to read, and to update in response to new requirements, because the structure of the code corresponds more closely to the language of the application domain. If the user, or the business customer that owns the game, says that they want the snake to be a different colour, or for there to be two apples at once (in different positions) - it will be easier for the programmer to identity where within the program the code must be changed that in a procedural implementation. You can try this for yourself, by asking a user to specify similar small changes to the presentation and/or game rules, and testing how long it takes you to update the procedural, and object-oriented, versions of the Snake program as required.

Importantly, the class does not just represent all the information associated with the noun - it also encapsulates the behaviour needed from that thing, in the form of methods. This is sometimes stated as representing the know-whats for the thing (as properties), and the know how-to's as methods.

Objects should hide state behind methods, where possible

This principle corresponds to the second meaning of 'encapsulation': sealing. Think of the related word: 'capsule'. You can only access the capabilities of an object through its public members. All the 'members' defined on a class (that is: its properties and methods) are public - although properties are public only for reading, not for modifying. However, it is possible to make any property or method private - such that it can be accessed from code within the class, but not from outside. To do this, you bring up the context menu on the instruction (by right-mouse-click or Ctrl-m) and select make private (a change that can be reversed with make public).A method might be made private because it just provides help to one or more public methods, but is not expected to be useful in its own right. However, a property is often made private to implement the principle of 'information' hiding.

Some textbooks suggest that every property - for example dateOfBirthdateOfBirthdateOfBirthdateOfBirthdateOfBirth - should be private, and that access should be via a 'getter' - a function method typically named getDateOfBirth, and a 'setter' - a procedure method typically named setDateOfBirth. But that idea is not really hiding the information. Real information hiding is to prevent external code from accessing the data and instead provide them with public methods that provide more useful services. For example, in the Snake demo, all the headheadheadheadhead and bodybodybodybodybody properties are private, but the function method bodyCovers allows external code to test whether the snake (body or head) covers a given square, passed in as a parameter. This method is called from within the newRandomPosition defined by the AppleAppleAppleAppleApple class, to ensure that the next apple is not created directly underneath the snake.

A concrete class may optionally inherit from an abstract class

In many applications two or more of the classes will be seen as having quite a lot in common. When this situation identified, there might be a case for making them inherit from a common 'abstract' class. For example, in a school administration system, you might define classes named Pupil, Teacher, and Parent, but these might all inherit from a common abstract class named Individual. The Person class can then be described as the 'superclass' of the other three, and they as the 'subclasses' of Individual.

An abstract class is created, at global level, with an abstract class instruction, and the template requires a name (beginning with a capital letter) to be specified.

The main differences between an abstract and a concrete super-class are:

• an abstract class cannot be instantiated. If, using the example above, you were to write: new Individual()Individual()new Individual()New Individual()new Individual() you will get a compile-error message: Individual must be concrete to create instance.
• an abstract class has no constructor (it also does not need toString because every concrete class must define one.
• the new code menus, as well as offering the property, procedure method, and function method options as in a concrete class, also offer abstract procedure method, and abstract function method. A concrete class must provide a concrete (normal) implementation of each abstract member defined in its superclass, or any abstract class above it in the hierarchy.

Earlier we learned about association between objects. Association may be characterised by the 'has a' relationship, as in a 'Student has a personal tutor' (meaning that the Student class defines a property named 'tutor' - which is of type Teacher. Bt contrast inheritance may be characterised as an 'is a' relationship, as in 'a Student is an Individual'.

There are two principal motivations from making two or more classes inherit from a common abstract class:

• To reduce repetition of common properties and methods - which may be defined on the abstract superclass and then not repeated in the subclasses. For example it might be that Individual define a (string) property named 'emailAddress' and define a common procedure method named 'sendMessage'.
• To allow instances of any of the subclasses to be handled by external code without having to know the individual subclass of each instance. This principle is known as 'type substitutability' and is a form of a more general principle know as 'polymorphism' - meaning 'of multiple forms'. For example, the user might define a special interest group that included some pupils, parents, and teachers, and so would be defined as a list of type Individual. This then makes it easy to send a message to all the members of the group, by invoking the method 'sendMessage' on each member in turn, without having to identify the type each member.

Some textbooks emphasise the first of those two motivations, but it is the second one that is far more important. Indeed, inheritance is the most over-used, and the most frequently abused, concepts in OOP. For that reason, irrespective of the programming language being used, Elan deliberately enforces principles of good OOP from the outset. For example:

• Each class may inherit from one superclass only
• The superclass must be an abstract class - no class may inherit from another concrete class.
• A abstract class may inherit from another abstract class - to form a 'hierarchy' of abstraction, if desired.
• A concrete class may inherit concrete (ordinary) members from its superclass, but it may not override them.

The last point is controversial - since all the supported programming languages allow overriding. But overriding (of concrete methods) breaks the 'O' of the widely-quoted 'SOLID' principles of OOP: that classes should be 'Open for extension, but closed for modification'.

Application logic should be well-distributed across classes

In Elan, an object-oriented program still needs a procedural main method to execute.

The Java language is unusual in that even the main routine must defined within a class - Elan handles this by including a class named Global as part of the file boilerplate, but treats the instructions directly within this class as being 'global' in nature. Any user-defined classes are added within this, and Elan does not allow properties to be added directly within that Global class since these would be, effectively, just global variables in disguise.

In general good OOP design means aiming to keep the functionality well-distributed among the user-defined classes. Inevitably, some classes are going to define more methods, and/or more-complex methods, than others. But you should be wary of a situation where one class is doing most of the work, and the other classes act as little more than data structures without encapsulated behaviour. All too often that one big class is instantiated only once (this pattern is known as a 'singleton'), by the main routine. While singletons are not always a bad idea, a singleton that does most of the work of the program - sometimes irreverently referred to as a 'god class' - is really just a procedural program in disguise.

A useful check on your design is to look at the distribution of instructions in the program (not counting instructions within tests, which are not part of the executable program). For example, the Snake - object-oriented demo has a total of 96 instructions (excluding tests), of which just 12 are not in a user-defined class (they are all in the main routine). The allocation of the other instructions is as follows:

class	properties	methods (excl. constructor & toString)	No. of instructions	Notes
SnakeSnakeSnakeSnakeSnake	4	6	57	singleton - but an extended version of the game might have multiple instances.
AppleAppleAppleAppleApple	1	2	16	ditto
SquareSquareSquareSquareSquare	2	2	22	Many instances created in the game. Both Snake and Apple have associations to one or more Squares