Object oriented programming in SOUL: Difference between revisions
Jump to navigation
Jump to search
No edit summary |
|||
| Line 29: | Line 29: | ||
<dt>[[Collections|Collection]] | <dt>[[Collections|Collection]] | ||
<dd>A special class that, as the name suggests, is used to manage collections or groups of variables. A collection provides the same functionality as an array, though with much more flexibility. The term | <dd>A special class that, as the name suggests, is used to manage collections or groups of variables. A collection provides the same functionality as an array, though with much more flexibility. The term <strong>collection</strong> is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way, and it is a concept present in most object-oriented programming languages. | ||
<div id="constructor"></div> | <div id="constructor"></div> | ||
<dt>[[Classes and Objects#Method declarations and method types|Constructor]] | <dt>[[Classes and Objects#Method declarations and method types|Constructor]] | ||
<dd>A method that processes an object immediately after the object is instantiated (created). The term | <dd>A method that processes an object immediately after the object is instantiated (created). The term <strong>constructor</strong> is standard object-oriented programming terminology, but although it does in <var class="product">SOUL</var>, it does not appear as an actual keyword in most object-oriented programming languages. | ||
<dt>[[Object variables#Discarding objects|Discard]] | <dt>[[Object variables#Discarding objects|Discard]] | ||
| Line 46: | Line 46: | ||
<dt>[[Methods|Function]] | <dt>[[Methods|Function]] | ||
<dd>A method that returns a value and cannot be set, that is, appear on the left side of an assignment. The term | <dd>A method that returns a value and cannot be set, that is, appear on the left side of an assignment. The term <strong>function</strong> is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way. | ||
<dt>[[Intrinsic classes|Intrinsic]] method | <dt>[[Intrinsic classes|Intrinsic]] method | ||
| Line 58: | Line 58: | ||
<dt>[[Methods|Method]] | <dt>[[Methods|Method]] | ||
<dd>A block of code that performs a particular operation in a particular class. In <var class="product">SOUL</var> OOP, there are four kinds of methods: subroutines, functions, properties, and constructors. Methods can be | <dd>A block of code that performs a particular operation in a particular class. In <var class="product">SOUL</var> OOP, there are four kinds of methods: subroutines, functions, properties, and constructors. Methods can be <strong>shared</strong> that is, perform work independent of any instance of a class; or they can be <strong>non-shared</strong>, that is, perform work on an object, a specific instance of a class. | ||
<dt>[[Classes and Objects|Object]] | <dt>[[Classes and Objects|Object]] | ||
<dd>A collection of information that describes some entity, often some "real world" entity such as a customer or an order or a part. Objects have state, that is, information contained in the object can change over time, usually as a result of methods (actions) performed against the object. Objects are never accessed directly but are accessed via | <dd>A collection of information that describes some entity, often some "real world" entity such as a customer or an order or a part. Objects have state, that is, information contained in the object can change over time, usually as a result of methods (actions) performed against the object. Objects are never accessed directly but are accessed via <strong>references</strong>. Most important among these references are [[Object variables|object variables]] that, in <var class="product">SOUL</var>, look very much like regular %variables. The specific information held in an object and the methods (actions) available on an object are described by the object's class. | ||
<div id="methobj"></div> | <div id="methobj"></div> | ||
| Line 68: | Line 68: | ||
<dt>[[Methods#props|Property]] | <dt>[[Methods#props|Property]] | ||
<dd>A method that reflects the state of an object (class instance) or, in the case of a shared property, the state of the class as a whole. Properties can be | <dd>A method that reflects the state of an object (class instance) or, in the case of a shared property, the state of the class as a whole. Properties can be <strong>read-only</strong> or <strong>settable</strong>, that is, valid on the left side of an assignment statement. Properties appear to users of a class to be almost identical to class variables, but they actually have code behind them that is run when the property value is set or retrieved. The term <strong>property</strong> is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way. | ||
<dt>[[Structures|Structure]] | <dt>[[Structures|Structure]] | ||
| Line 74: | Line 74: | ||
<dt>[[Methods|Subroutine]] | <dt>[[Methods|Subroutine]] | ||
<dd>A method that does not return a value and cannot be set, that is, appear on the left side of an assignment. The term | <dd>A method that does not return a value and cannot be set, that is, appear on the left side of an assignment. The term <strong>subroutine</strong> is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way, though in VB subroutines are denoted by the word Sub. | ||
<dt>Variable | <dt>Variable | ||
Revision as of 20:02, 11 November 2014
In version 7.5 of Model 204, User Language became SOUL, and SOUL was enhanced to include Object-Oriented Programming (sometimes abbreviated OOP) concepts that are implemented in many languages. These languages include Visual Basic .Net (often called VB.Net), Java, Eiffel, Perl, C++, C#, Smalltalk, Python, and Ruby. While most languages differ in the implementation details of OO concepts, especially in syntax, the basic concepts are incorporated in all these languages, and once a programmer understands these concepts, it is usually relatively easy to move between the languages.
SOUL OOP supports many but not all the concepts discussed in books about object-oriented programming. Specifically there is no explicit support for interfaces, though multiple inheritance provides all the functionality provided by interfaces with more flexibility. Overloading is also not supported, but optional parameters provide much more easily most of what overloading is used for, and named parameters enhance this capability.
SOUL without OOP generally corresponds to a procedural programming language.
If you are an experienced User Language programmer, you are likely to benefit from Getting started with OOP for User Language programmers.
Object-oriented terminology
One of the difficulties of learning new programming concepts is that if they are sufficiently complex, like those of object orientation, their explication can seem circular: the explanation of concept A refers to concept B, which refers to concept C, which refers back to concept A. In the introductory stages, you may may have little choice but to understand that this problem exists, use this understanding to avoid getting "stuck" on a concept that is not fully understood, and move on until the complex web of concepts become clear.
To facilitate the initial learning process and to provide a quick reference for when the concepts become clearer, brief definitions of key object-oriented terms are described here, and most of the terms are links to more detailed descriptions:
- Class
- A description of the information held in a particular type of object and the methods (actions) that can be performed on the object. There may be many instances of objects for any given class.
- Collection
- A special class that, as the name suggests, is used to manage collections or groups of variables. A collection provides the same functionality as an array, though with much more flexibility. The term collection is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way, and it is a concept present in most object-oriented programming languages.
- Constructor
- A method that processes an object immediately after the object is instantiated (created). The term constructor is standard object-oriented programming terminology, but although it does in SOUL, it does not appear as an actual keyword in most object-oriented programming languages.
- Discard
- A method that removes an existing object explicitly. Object discarding may also be implicit, and a DeepDiscard method is available to discard an object and the objects it references.
- Enumeration
- A special class that is used to denote a group of names with a limited set of values like, for example, "True" and "False". The term "enumeration" is not standard object-oriented programming terminology and, in fact, appears in many object-oriented languages as a procedural-language leftover often called "Enum".
- Exception
- A class used to describe an error situation that is detected during the execution of a method. The method's code uses a Throw statement to output an exception object (which must be specified in the method declaration). If the code that invokes the method is within a Try block, it can use a Catch block, following the invocation and within the Try block, to respond to an exception and thereby to prevent request cancellation.
- Function
- A method that returns a value and cannot be set, that is, appear on the left side of an assignment. The term function is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way.
- Intrinsic method
- A method which is applied not to an object, but rather to a string or number, providing the benefits of object-oriented syntax when operating on strings and numbers.
- Instantiation
- The process of the creation of an object, that is, an instance of a class.
- Member
- A method or variable in a class. A class is completely defined by its members, that is, its variables and methods.
- Method
- A block of code that performs a particular operation in a particular class. In SOUL OOP, there are four kinds of methods: subroutines, functions, properties, and constructors. Methods can be shared that is, perform work independent of any instance of a class; or they can be non-shared, that is, perform work on an object, a specific instance of a class.
- Object
- A collection of information that describes some entity, often some "real world" entity such as a customer or an order or a part. Objects have state, that is, information contained in the object can change over time, usually as a result of methods (actions) performed against the object. Objects are never accessed directly but are accessed via references. Most important among these references are object variables that, in SOUL, look very much like regular %variables. The specific information held in an object and the methods (actions) available on an object are described by the object's class.
- Method object
- In a SOUL statement that invokes a method into operation, the object variable that references the object on which the method operates.
- Property
- A method that reflects the state of an object (class instance) or, in the case of a shared property, the state of the class as a whole. Properties can be read-only or settable, that is, valid on the left side of an assignment statement. Properties appear to users of a class to be almost identical to class variables, but they actually have code behind them that is run when the property value is set or retrieved. The term property is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way.
- Structure
- A standard layout of variables. A structure is similar to an image, except a structure can have many instances while an image can only have one. Structure variables have the layout indicated by the structure definition, and they can be assigned to each other. Structures are different from objects in that structures are passed by value rather than by reference. Structures can be thought of as composite datatypes.
- Subroutine
- A method that does not return a value and cannot be set, that is, appear on the left side of an assignment. The term subroutine is not standard object-oriented programming terminology, but it is used in Visual Basic in almost exactly the same way, though in VB subroutines are denoted by the word Sub.
- Variable
- A container for a value. In addition to the standard SOUL variables, SOUL OOP provides class variables. A class variable can be shared (accessed via a class reference and not associated with a specific object) or non-shared (accessed via an object reference and associated with that object).