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?40 +constructor(parameter definitions?) 41 new code end constructor +function toStringname?(parameter definitions?) returns StringType? 42 return "undefined"value or expression?43 end function end class

+class SnakeName? inheritance?: # concrete class44 +def __init__(self: Snake) -> None: 45 new code # end constructor +def toStringname?(self: Snake) -> strType?: # function method46 return "undefined"value or expression?47 # end function method # end class

+class SnakeName? inheritance? {48 +public Snake(parameter definitions?) { 49 new code } // end constructor +public stringType? toStringname?(parameter definitions?) { // function method50 return "undefined"value or expression?;51 } // end function method } // end class

+Class SnakeName? inheritance?52 +Sub New(parameter definitions?) 53 new code End Sub +Function toStringname?(parameter definitions?) As StringType? 54 Return "undefined"value or expression?55 End Function End Class

+class SnakeName? inheritance? {56 +public Snake(parameter definitions?) { 57 new code } // end constructor +public StringType? toStringname?(parameter definitions?) { // function method58 return "undefined"value or expression?;59 } // end function method } // end class

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?80

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

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

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

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

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

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

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

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

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

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?105 +constructor(x as Int, y as Intparameter definitions?) 106 assign this.xvariableName? to xvalue or expression?107 assign this.yvariableName? to yvalue or expression?108 end constructor property xname? as IntType?109 property yname? as IntType?110 # Methods not shown herecomment? +function toStringname?(parameter definitionsparameter definitions?) returns StringType? 111 return "{this.x}, {this.y}"value or expression?112 end function end class

+class SquareName? inheritance?: # concrete class113 +def __init__(self: Square, x: int, y: intparameter definitions?) -> None: 114 self.xvariableName? = xvalue or expression? # assignment115 self.yvariableName? = yvalue or expression? # assignment116 # end constructor xname?: intType? # property117 yname?: intType? # property118 # Methods not shown herecomment? +def toStringname?(self: Square) -> strType?: # function method119 return "{this.x}, {this.y}"value or expression?120 # end function method # end class

+class SquareName? inheritance? {121 +public Square(int x, int yparameter definitions?) { 122 this.xvariableName? = xvalue or expression?; // assignment123 this.yvariableName? = yvalue or expression?; // assignment124 } // end constructor public intType? xname? {get; private set;} // property125 public intType? yname? {get; private set;} // property126 // Methods not shown herecomment? +public stringType? toStringname?(parameter definitionsparameter definitions?) { // function method127 return "{this.x}, {this.y}"value or expression?;128 } // end function method } // end class

+Class SquareName? inheritance?129 +Sub New(x As Integer, y As Integerparameter definitions?) 130 Me.xvariableName? = xvalue or expression? ' assignment131 Me.yvariableName? = yvalue or expression? ' assignment132 End Sub Property xname? As IntegerType?133 Property yname? As IntegerType?134 ' Methods not shown herecomment? +Function toStringname?(parameter definitionsparameter definitions?) As StringType? 135 Return "{this.x}, {this.y}"value or expression?136 End Function End Class

+class SquareName? inheritance? {137 +public Square(int x, int yparameter definitions?) { 138 this.xvariableName? = xvalue or expression?; // assignment139 this.yvariableName? = yvalue or expression?; // assignment140 } // end constructor public intType? xname?; // property141 public intType? yname?; // property142 // Methods not shown herecomment? +public StringType? toStringname?(parameter definitionsparameter definitions?) { // function method143 return "{this.x}, {this.y}"value or expression?;144 } // 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 paramaters 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 a reassign variable 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?145 +constructor(parameter definitionsparameter definitions?) 146 variable tailname? set to new Square(20, 15)value or expression?147 assign this.currentDirvariableName? to Direction.rightvalue or expression?148 assign this.bodyvariableName? to [tail]value or expression?149 assign this.headvariableName? to tail.getAdjacentSquare(this.currentDir)value or expression?150 assign this.priorTailvariableName? to tailvalue or expression?151 end constructor private property currentDirname? as DirectionType?152 private property headname? as SquareType?153 private property bodyname? as List<of Square>Type?154 private property priorTailname? as SquareType?155 +function toStringname?(parameter definitions?) returns StringType? 156 return "undefined"value or expression?157 end function end class

+class SnakeName? inheritance?: # concrete class158 +def __init__(self: Snake) -> None: 159 tailname? = Square(20, 15)value or expression? # variable definition160 self.currentDirvariableName? = Direction.rightvalue or expression? # assignment161 self.bodyvariableName? = [tail]value or expression? # assignment162 self.headvariableName? = tail.getAdjacentSquare(self.currentDir)value or expression? # assignment163 self.priorTailvariableName? = tailvalue or expression? # assignment164 # end constructor currentDirname?: DirectionType? # private property165 headname?: SquareType? # private property166 bodyname?: list[Square]Type? # private property167 priorTailname?: SquareType? # private property168 +def toStringname?(self: Snake) -> strType?: # function method169 return "undefined"value or expression?170 # end function method # end class

+class SnakeName? inheritance? {171 +public Snake(parameter definitionsparameter definitions?) { 172 var tailname? = new Square(20, 15)value or expression?;173 this.currentDirvariableName? = Direction.rightvalue or expression?; // assignment174 this.bodyvariableName? = new [] {tail}value or expression?; // assignment175 this.headvariableName? = tail.getAdjacentSquare(this.currentDir)value or expression?; // assignment176 this.priorTailvariableName? = tailvalue or expression?; // assignment177 } // end constructor private DirectionType? currentDirname? {get; private set;} // private property178 private SquareType? headname? {get; private set;} // private property179 private List<Square>Type? bodyname? {get; private set;} // private property180 private SquareType? priorTailname? {get; private set;} // private property181 +public stringType? toStringname?(parameter definitions?) { // function method182 return "undefined"value or expression?;183 } // end function method } // end class

+Class SnakeName? inheritance?184 +Sub New(parameter definitionsparameter definitions?) 185 Dim tailname? = New Square(20, 15)value or expression? ' variable definition186 Me.currentDirvariableName? = Direction.rightvalue or expression? ' assignment187 Me.bodyvariableName? = {tail}value or expression? ' assignment188 Me.headvariableName? = tail.getAdjacentSquare(Me.currentDir)value or expression? ' assignment189 Me.priorTailvariableName? = tailvalue or expression? ' assignment190 End Sub Private Property currentDirname? As DirectionType?191 Private Property headname? As SquareType?192 Private Property bodyname? As List(Of Square)Type?193 Private Property priorTailname? As SquareType?194 +Function toStringname?(parameter definitions?) As StringType? 195 Return "undefined"value or expression?196 End Function End Class

+class SnakeName? inheritance? {197 +public Snake(parameter definitionsparameter definitions?) { 198 var tailname? = new Square(20, 15)value or expression?;199 this.currentDirvariableName? = Direction.rightvalue or expression?; // assignment200 this.bodyvariableName? = list(tail)value or expression?; // assignment201 this.headvariableName? = tail.getAdjacentSquare(this.currentDir)value or expression?; // assignment202 this.priorTailvariableName? = tailvalue or expression?; // assignment203 } // end constructor private DirectionType? currentDirname?; // private property204 private SquareType? headname?; // private property205 private List<Square>Type? bodyname?; // private property206 private SquareType? priorTailname?; // private property207 +public StringType? toStringname?(parameter definitions?) { // function method208 return "undefined"value or expression?;209 } // 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? 210 variable newXname? set to this.xvalue or expression?211 variable newYname? set to this.yvalue or expression?212 +if d is Direction.leftcondition? then 213 assign newXvariableName? to this.x - 1value or expression?214 elif d is Direction.rightcondition? then215 assign newXvariableName? to this.x + 1value or expression?216 elif d is Direction.upcondition? then217 assign newYvariableName? to this.y - 1value or expression?218 elif d is Direction.downcondition? then219 assign newYvariableName? to this.y + 1value or expression?220 end if return new Square(newX, newY)value or expression?221 end function

+def getAdjacentSquarename?(d: Directionparameter definitions?) -> SquareType?: # function222 newXname? = self.xvalue or expression? # variable definition223 newYname? = self.yvalue or expression? # variable definition224 +if d == Direction.leftcondition?: 225 newXvariableName? = self.x - 1value or expression? # assignment226 elif d == Direction.rightcondition?: # else if227 newXvariableName? = self.x + 1value or expression? # assignment228 elif d == Direction.upcondition?: # else if229 newYvariableName? = self.y - 1value or expression? # assignment230 elif d == Direction.downcondition?: # else if231 newYvariableName? = self.y + 1value or expression? # assignment232 # end if return Square(newX, newY)value or expression?233 # end function

+static SquareType? getAdjacentSquarename?(Direction dparameter definitions?) { // function234 var newXname? = this.xvalue or expression?;235 var newYname? = this.yvalue or expression?;236 +if (d == Direction.leftcondition?) { 237 newXvariableName? = this.x - 1value or expression?; // assignment238 } else if (d == Direction.rightcondition?) {239 newXvariableName? = this.x + 1value or expression?; // assignment240 } else if (d == Direction.upcondition?) {241 newYvariableName? = this.y - 1value or expression?; // assignment242 } else if (d == Direction.downcondition?) {243 newYvariableName? = this.y + 1value or expression?; // assignment244 } // end if return new Square(newX, newY)value or expression?;245 } // end function

+Function getAdjacentSquarename?(d As Directionparameter definitions?) As SquareType? 246 Dim newXname? = Me.xvalue or expression? ' variable definition247 Dim newYname? = Me.yvalue or expression? ' variable definition248 +If d = Direction.leftcondition? Then 249 newXvariableName? = Me.x - 1value or expression? ' assignment250 ElseIf d = Direction.rightcondition? Then251 newXvariableName? = Me.x + 1value or expression? ' assignment252 ElseIf d = Direction.upcondition? Then253 newYvariableName? = Me.y - 1value or expression? ' assignment254 ElseIf d = Direction.downcondition? Then255 newYvariableName? = Me.y + 1value or expression? ' assignment256 End If Return New Square(newX, newY)value or expression?257 End Function

+static SquareType? getAdjacentSquarename?(Direction dparameter definitions?) { // function258 var newXname? = this.xvalue or expression?;259 var newYname? = this.yvalue or expression?;260 +if (d == Direction.leftcondition?) { 261 newXvariableName? = this.x - 1value or expression?; // assignment262 } else if (d == Direction.rightcondition?) {263 newXvariableName? = this.x + 1value or expression?; // assignment264 } else if (d == Direction.upcondition?) {265 newYvariableName? = this.y - 1value or expression?; // assignment266 } else if (d == Direction.downcondition?) {267 newYvariableName? = this.y + 1value or expression?; // assignment268 } // end if return new Square(newX, newY)value or expression?;269 } // 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(snakearguments?)5print(snakearguments?)6Console.WriteLine(snakearguments?); // print statement7Console.WriteLine(snakearguments?) ' print statement8System.out.println(snakearguments?); // print statement9 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?) 280 call this.setDirectionprocedureName?(keyarguments?)281 assign this.priorTailvariableName? to this.body[0]value or expression?282 variable bodyname? set to this.bodyvalue or expression?283 call body.appendprocedureName?(this.headarguments?)284 assign this.headvariableName? to this.head.getAdjacentSquare(this.currentDir)value or expression?285 +if this.head.equals(apple.location)condition? then 286 call apple.newRandomPositionprocedureName?(thisarguments?)287 else288 assign this.bodyvariableName? to this.body.subList(1, this.body.length())value or expression?289 end if end procedure

+def clockTickname?(key: str, apple: Appleparameter definitions?) -> None: # procedure290 self.setDirectionprocedureName?(keyarguments?) # procedure call291 self.priorTailvariableName? = self.body[0]value or expression? # assignment292 bodyname? = self.bodyvalue or expression? # variable definition293 body.appendprocedureName?(self.headarguments?) # procedure call294 self.headvariableName? = self.head.getAdjacentSquare(self.currentDir)value or expression? # assignment295 +if self.head.equals(apple.location)condition?: 296 apple.newRandomPositionprocedureName?(selfarguments?) # procedure call297 else:298 self.bodyvariableName? = self.body.subList(1, self.body.length())value or expression? # assignment299 # end if # end procedure

+static void clockTickname?(string key, Apple appleparameter definitions?) { // procedure300 this.setDirectionprocedureName?(keyarguments?); // procedure call301 this.priorTailvariableName? = this.body[0]value or expression?; // assignment302 var bodyname? = this.bodyvalue or expression?;303 body.appendprocedureName?(this.headarguments?); // procedure call304 this.headvariableName? = this.head.getAdjacentSquare(this.currentDir)value or expression?; // assignment305 +if (this.head.equals(apple.location)condition?) { 306 apple.newRandomPositionprocedureName?(thisarguments?); // procedure call307 } else {308 this.bodyvariableName? = this.body.subList(1, this.body.length())value or expression?; // assignment309 } // end if } // end procedure

+Sub clockTickname?(key As String, apple As Appleparameter definitions?) ' procedure310 Me.setDirectionprocedureName?(keyarguments?) ' procedure call311 Me.priorTailvariableName? = Me.body(0)value or expression? ' assignment312 Dim bodyname? = Me.bodyvalue or expression? ' variable definition313 body.appendprocedureName?(Me.headarguments?) ' procedure call314 Me.headvariableName? = Me.head.getAdjacentSquare(Me.currentDir)value or expression? ' assignment315 +If Me.head.equals(apple.location)condition? Then 316 apple.newRandomPositionprocedureName?(Mearguments?) ' procedure call317 Else318 Me.bodyvariableName? = Me.body.subList(1, Me.body.length())value or expression? ' assignment319 End If End Sub

+static void clockTickname?(String key, Apple appleparameter definitions?) { // procedure320 this.setDirectionprocedureName?(keyarguments?); // procedure call321 this.priorTailvariableName? = this.body[0]value or expression?; // assignment322 var bodyname? = this.bodyvalue or expression?;323 body.appendprocedureName?(this.headarguments?); // procedure call324 this.headvariableName? = this.head.getAdjacentSquare(this.currentDir)value or expression?; // assignment325 +if (this.head.equals(apple.location)condition?) { 326 apple.newRandomPositionprocedureName?(thisarguments?); // procedure call327 } else {328 this.bodyvariableName? = this.body.subList(1, this.body.length())value or expression?; // assignment329 } // 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

Global Instructions

Coding with Elan using the object-oriented paradigm offers all the global instructions uses in the procedural paradigm plus two new ones: concrete class and abstract class