Object Oriented Programming with Free Pascal and Lazarus: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Introduction
2	2
3	3		There are many excellent tutorials about Pascal, but this tutorial attempts to take the beginner further, into [[Glossary\|Object-Oriented Programming]] with [[Object Pascal]], which is an extension to standard [[Pascal]], offered by [[Turbo Pascal]], [[Delphi]] and [[Free Pascal]] / [[Lazarus]].
4	4
5	5		An [[Glossary\|Object]] is an extension of the standard Pascal [record](http://wiki.lazarus.freepascal.org/Record) structure
6	6
7	7		Standard text-based Pascal programming is good for creating applications which, like traditional Unix applications, do one thing and do it very well. The 'one thing' that a program does might be a very complicated action, and might offer the user several menu-driven options, but it is essentially restricted to obeying commands that the user types at the keyboard and listing its responses on the terminal or a printer.
8	8
9	9		In order to provide a [[Glossary\|Graphical User Interface (GUI)]] it is usual to invoke some sort of Object-Oriented Programming method (often making use of [[Glossary\|C]] or one of its variants, or Visual Basic, or one of the [[Glossary\|OO]] variants of Pascal such as [[Glossary\|Free Pascal]] with or without [[Glossary\|Lazarus]]).
10	10
11	11		In a GUI the user is presented with a screen with a large number of images arranged in a structured way, consisting of a set of tools or [[Glossary\|Widgets]] that are associated with various actions such as
12	12
13	13		- selecting from a menu,
14	14		- opening or saving files,
15	15		- connecting to the Internet,
16	16		- performing numerical computations, etc.
17	17
18	18		The user is expected to move a mouse or other pointer/selection tool over the screen, to select actions which are to be performed in response to a mouse button click or a key-press.
19	19
20	20		While systems to deal with a complex graphical user interface could be written in standard Pascal or almost any other programming language, it is much easier to use an object-oriented system, in which each graphical object on the screen can have all its properties and the procedures and functions associated with its use kept together in a common structure.
21	21
22	22		## Objects - a real-world analogy
23	23
24	24		Consider the analogy of a blood sample collected in a hospital or a doctor's office.
25	25
26	26		### Blood Sample
27	27
28	28		The physical sample is certainly an object; it has, associated with it, a lot of information, documents and other physical objects.
29	29
30	30		- Sample tube, of a type determined by the test that the physician wants performed.
31	31
32	32		- Local rule (or method, standard operating procedure) to direct the nurse or technician collecting the sample
33	33		- which type of tube to use,
34	34		- how to process the sample
35	35		- how to store it before transfer to the lab.
36	36
37	37		- Label on the tube with details of the
38	38		- sample identifier
39	39		- patient's name and birthdate
40	40		- date and time of collection
41	41		- tests required.
42	42
43	43		- Request form that accompanies the sample to the lab, directing
44	44		- sample ID
45	45		- ID of requesting physician
46	46		- what test the physician requests and
47	47		- giving fuller details of the patient
48	48		- the possible diagnosis for which confirmation is sought.
49	49
50	50		A copy of the request form is placed in the patient's notes, to remind the physician to expect results within an appropriate time.
51	51
52	52		- In the lab - local methods to determine
53	53		- how the sample is to be analysed,
54	54		- what machines to use,
55	55		- how the machines are to be calibrated and operated,
56	56		- how the results are to be stored, formatted and
57	57		- reported back to the physician.
58	58
59	59		The actual results are a record that the physician uses to assist the diagnosis, and a copy of the results is filed in the patient notes.
60	60
61	61		The physical sample might be retained for reference, confirmation or further tests, or might be disposed of by pouring down the sink or by incineration; there will be a method to describe this.
62	62
63	63		There is no need for a physician to spell out all the details and instructions every time a sample is collected; indeed, he may have very little knowledge of how the sample is processed in the lab. The details of the various processes are inherited from previous sample collections and analyses - there will be a generic plan for the whole sequence, and together we could think of the blood sample, all its documents and data, and the underlying methods, as a complex object.
64	64
65	65		In the physician's mind, the blood sample is seen as almost the same entity as its results, and to the nurses and technicians the sample, the tube, the label and the storage conditions again form a single entity.
66	66
67	67		### Another Example - Automobile
68	68
69	69		If you don't like blood, the same sort of reasoning could be applied to a car taken to a garage for repair. It might consist of:
70	70
71	71		- the physical vehicle
72	72		- documents held by the owner: registration or license (including license plates), insurance, receipts for purchase, parts, repairs etc
73	73		- the fuel consumption history
74	74		- the drivers allowed to use the vehicle, with their license particulars
75	75		- service records held by the garage
76	76		- methods or procedures to be followed for routine checking and maintenance
77	77		- methods to be followed for non-routine repairs etc
78	78		- billing information for the customer
79	79
80	80		## Programming Example
81	81
82	82		Enough of this pre-occupation with Real-World examples! Let us proceed to the main purpose: programming in [[Object Pascal]].
83	83
84	84		Let us consider the creation of a simple Form with a few controls for an application in Free Pascal/Lazarus.
85	85
86		-	~~<div class="floatleft">~~
87		-
88		-	~~<figure>~~
89		-	~~<img src="ObjectInspector-TForm.png" title="ObjectInspector-TForm.png" />~~
90		-	~~<figcaption>ObjectInspector-TForm.png</figcaption>~~
91		-	~~</figure>~~
92		-
93		-	~~</div>~~
94		-
95		-	~~<div class="floatright">~~
96		-
97		-	~~<figure>~~
98		-	~~<img src="BlankForm.png" title="BlankForm.png" />~~
99		-	~~<figcaption>BlankForm.png</figcaption>~~
100		-	~~</figure>~~
	86	+	![](/wiki-images/2/25/ObjectInspector-TForm.png)
101	87
102		-	~~</div>~~
	88	+	![](/wiki-images/e/e2/BlankForm.png)
103	89
104	90		On invoking the Lazarus IDE, the programmer is presented with a blank template Form design, on which he is encouraged to place various controls or objects.
105	91
106	92		Note that the pre-made blank Form is already an Object, with its own properties such as position (Top and Left), size (Height and Width), colour, default font for adding text etc.
107	93
108	94		------------------------------------------------------------------------
109	95
110	96		If a Button control is placed on the Form (type TButton), it will have its own series of properties, which can be examined in the Object Inspector window.
111	97
112	98		Several of the properties have names similar to those for the Form; this is because many properties are Inherited from some common Ancestor class, which lays out how properties are to be defined and handled by the descendant classes.
113	99
114	100		As well as properties, the Object Inspector offers a tab called Events, which gives access to Event Handlers which are methods instructing the application how to deal with things such as a mouse click on a button (OnClick) or some change in the position, size or other properties (OnChange).
115	101
116	102		The physical image of the Button on the Form, together with all its properties and Event Handler methods, should be regarded as a single entity or Object in Pascal.
117	103
118		-	~~<div class="floatleft">~~
119		-
120		-	~~<figure>~~
121		-	~~<img src="ObjectInspector-TButton.png" title="ObjectInspector-TButton.png" />~~
122		-	~~<figcaption>ObjectInspector-TButton.png</figcaption>~~
123		-	~~</figure>~~
124		-
125		-	~~</div>~~
126		-
127		-	~~<div class="floatright">~~
128		-
129		-	~~<figure>~~
130		-	~~<img src="FormWithButton.png" title="FormWithButton.png" />~~
131		-	~~<figcaption>FormWithButton.png</figcaption>~~
132		-	~~</figure>~~
133		-
134		-	~~</div>~~
135		-
136		-	~~<div class="floatright">~~
	104	+	![](/wiki-images/f/f5/ObjectInspector-TButton.png)
137	105
138		-	~~<figure>~~
139		-	~~<img src="Source_FormWithButton1.png‎" title="Source_FormWithButton1.png‎" />~~
140		-	~~<figcaption>Source_FormWithButton1.png‎</figcaption>~~
141		-	~~</figure>~~
	106	+	![](/wiki-images/e/e8/FormWithButton.png)
142	107
143		-	~~</div>~~
	108	+	![](/wiki-images/4/4d/Source_FormWithButton1.png%E2%80%8E)
144	109
145	110		## Object-Oriented Extensions to standard Pascal
146	111
147	112		The Pascal record structure is extended by defining an
148	113
149	114		### Object
150	115
151	116		An Object is a special kind of record. The record contains all the ﬁelds that are declared in the object's deﬁnition (just like a conventional record), but now procedures and functions can be declared as if they were part of the record and are held as pointers to the methods associated with the object's type.
152	117
153	118		For example, an object could contain an array of real values, together with a Method for calculating the average.
154	119
155	120		``` pascal
156	121		Type
157	122		Average = Object
158	123		NumVal: Integer;
159	124		Values: Array [1..200] of Real;
160	125		Function Mean: Real; { calculates the average value of the array }
161	126		End;
162	127		```
163	128
164	129		Objects can ”inherit” ﬁelds and methods from ”parent” objects. This means that these ﬁelds and methods can be used as if they were included in the objects declared as a ”child” object.
165	130
166	131		Furthermore, a concept of visibility is introduced: ﬁelds, procedures and functions can be declared as public, protected or private. By default, ﬁelds and methods are public, and can be exported outside the current unit. Protected fields or methods are available only to objects descended from the current ancestor object. Fields or methods that are declared private are only accessible in the current unit: their scope is limited to the implementation of the current unit.
167	132
168	133		### Class
169	134
170	135		Objects are not used very often by themselves in Free Pascal and Lazarus; instead, Classes are used very widely. A Class is defined in almost the same way as an Object, but is a pointer to an Object rather than the Object itself. Technically, this means that the Class is allocated on the Heap of a program, whereas the Object is allocated on the Stack.
171	136
172	137		Here is a simple example of a typical Class declaration:
173	138
174	139		``` pascal
175	140		{-------------------------------------------}
176	141		{ Example of Class declaration from the LCL }
177	142		{-------------------------------------------}
178	143		TPen = class(TFPCustomPen)
179	144		private
180	145		FColor: TColor;
181	146		FPenHandleCached: boolean;
182	147		FReference: TWSPenReference;
183	148		procedure FreeReference;
184	149		function GetHandle: HPEN;
185	150		function GetReference: TWSPenReference;
186	151		procedure ReferenceNeeded;
187	152		procedure SetHandle(const Value: HPEN);
188	153		protected
189	154		procedure DoAllocateResources; override;
190	155		procedure DoDeAllocateResources; override;
191	156		procedure DoCopyProps(From: TFPCanvasHelper); override;
192	157		procedure SetColor
193	158		(const NewColor: TColor; const NewFPColor: TFPColor); virtual;
194	159		procedure SetFPColor(const AValue: TFPColor); override;
195	160		procedure SetColor(Value: TColor);
196	161		procedure SetMode(Value: TPenMode); override;
197	162		procedure SetStyle(Value: TPenStyle); override;
198	163		procedure SetWidth(value: Integer); override;
199	164		public
200	165		constructor Create; override;
201	166		destructor Destroy; override;
202	167		procedure Assign(Source: TPersistent); override;
203	168		property Handle: HPEN read GetHandle write SetHandle; deprecated;
204	169		property Reference: TWSPenReference read GetReference;
205	170		published
206	171		property Color: TColor read FColor write SetColor default clBlack;
207	172		property Mode default pmCopy;
208	173		property Style default psSolid;
209	174		property Width default 1;
210	175		end;
211	176		```
212	177
213	178		Note that this class is defined as an instance of another parent or ancestor class (TFPCustomPen) from which it inherits all its properties and methods. It has some fields of its own, grouped under
214	179
215	180		- private - this means that items defined here are only available or visible to other classes or procedures/function defined within the same program unit (this example is from Graphics, so any of the other classes such as TBitMap, TPicture etc in the same unit can use them). They are essentially local variables (eg FColor, FPenHandleCached) or locally used methods (GetHandle, SetHandle) but can be used or referred to in items declared in the protected or public sections.
216	181		- protected - this means that items defined here are only available or visible to classes that are descended from this ancestor class, and inherit its properties or methods
217	182		- public - this means that items defined here are available to any programming unit that includes the current unit in its [[Glossary\|Uses]] clause
218	183		- published - is the same as a public section, but the compiler also generates type information that is needed for automatic streaming of these classes. Often the list of published items appear in the Object Inspector of Lazarus; if there is no published list, all the public fields usually appear in the Object Inspector.
219	184
220	185		### Methods
221	186
222	187		A method is just like a standard procedure or function, but can have some additional directives.
223	188
224	189		Some of the methods defined above are labelled with the directive virtual; others are labelled with the override directive.
225	190
226	191		- virtual means that the type or actual instance of a method is not known at compile-time, but is selected at run-time depending on what sub-program actually calls the method. It could be considered a place-holder in the definition of the class.
227	192		- override means that at run-time the locally given definition can take the place of a definition inherited from an ancestor class, particularly if it was virtual. If you particularly want to use the method defined in the ancestor class, it is sometimes necessary to call it specifically with the inherited clause.
228	193
229	194		Methods with no virtual or override directive are static methods (the usual kind in Pascal). Those with a virtual or override directive are dynamic.
230	195
231	196		Special instances of methods are:
232	197
233	198		- create - a constructor for a class, which takes care of allocating memory, collecting together all the information needed and configuring/initializing the various properties.
234	199		- destroy - a destructor for a class, which removes all the parts of the class from the system in an orderly and logical way, and returns all its resources for the system to re-use.
235	200
236	201		### Properties
237	202
238	203		Properties are just like ordinary fields in a conventional Pascal record, but they can have read and/or write specifiers.
239	204
240	205		- read specifier is a field, or a function that returns a result of the correct type for the property. In the example above, the property Color has a read specifier FColor, which is a local variable containing the value to be used. If a property has a read but no write specifier, it is read-only.
241	206		- write specifier is a field, or a procedure that will store the value of the property in a specific location. In the example above, Color has a write specifier SetColor that is a procedure (defined in the protected section) for writing the color value to some specified location. If a property has a write but no read specifier, it is write-only.
242	207		- default - note that it is possible to set a default value for a property. For example, Color here is given the default value clBlack, or black, at the time of creation. It could subsequently be given a different value, by a programming assignment statement, or in the Object Inspector.
243	208		- index specifier is an integer that the read or write methods, shared between properties, can use to identify which property is desired. Note that if index is used the read or write specifiers must be a function or a procedure respectively and cannot be a normal field/variable.
244	209
245	210		#### Examples
246	211
247	212		``` pascal
248	213		TFooClass = class
249	214		private
250	215		FIntProp: Integer;
251	216		public
252	217		property IntProp: Integer read FIntProp write FIntProp;
253	218		end;
254	219		```
255	220
256	221		``` pascal
257	222		TFooClass = class
258	223		private
259	224		function GetListProp(AIndex: Integer): String;
260	225		procedure SetListProp(AIndex: Integer; AValue: String);
261	226		public
262	227		// this type of property may not be in the published section of a class
263	228		property ListProp[AIndex: Integer]: String read GetListProp write SetListProp;
264	229		end;
265	230		```
266	231
267	232		``` pascal
268	233		TFooClass = class
269	234		private
270	235		function GetValue(const AIndex: Integer): Integer;
271	236		procedure SetValue(const AIndex: Integer; AValue: Integer);
272	237		public
273	238		// note that the read and write methods are shared
274	239		property Value1: Integer index 1 read GetValue write SetValue;
275	240		property Value2: Integer index 2 read GetValue write SetValue;
276	241		property Value3: Integer index 3 read GetValue write SetValue;
277	242		property Value4: Integer index 4 read GetValue write SetValue;
278	243		// index may be a const or a number or you can even use an enumerated type
279	244		// for example:
280	245		// property Value: Integer index ord(seSomeEnum) read SomeFunction write SomeProcedure;
281	246		end;
282	247		```
283	248
284	249		## Free Pascal Language Extensions
285	250
286	251		FPC includes several language extensions to its "standard" Pascal syntax to support object oriented programming.
287	252
288	253		- Objects (chapter 5) [[Programming Using Objects]]
289	254		- Classes (chapter 6) [[Programming Using Classes]]
290	255		- Interfaces (chapter 7) [[Programming Using Interfaces]]
291	256		- Generics (chapter 8) [[Programming Using Generics]]
292	257
293	258		These extensions are described in the indicated chapters of the FPC Language Reference Guide: <http://www.freepascal.org/docs.var>. Links to tutorial pages for each concept are included above as well. The Language Reference Guide includes syntax diagrams and further details not contained in this introductory tutorial. Of the four language features listed above, Objects and Classes form the basis of object oriented programming (OOP) in FPC and Lazarus. For those new to OOP, the Objects section includes more introductory concepts and the Classes section minimizes repetition by emphasizing the similarities and differences to the Objects syntax. In general, the Classes implementation seems to be more widely in use including Delphi Lazarus developers. Often the word "objects" is used to refer to what is actually a "class" in the Classes dialect of OOP in FPC. These documents will be worded to minimize any terminology confusion, but outside of this document, the term "object" oftentimes refers to objects created from a Class. In fact, the FPC run time library (RTL) includes a class library with a base class called TObject.
294	259
295	260		Users familiar with the older Turbo Pascal OOP implementation may initially want to skip the section on Classes since the Objects implementation is based on the older Turbo Pascal dialect. The section on Classes should be familiar to Delphi users since it is based on Delphi syntax. Be aware that some of the writeup in the Classes section may refer to concepts from the Objects section. For Macintosh developers familiar with the various Apple, THINK and MPW Object Pascal dialects, neither the FPC Objects or Classes dialects provide a direct migration path. As of March 2009, there are discussions on the Mac Pascal Mailing list about potentially providing some compiler support (new syntax) for accessing Apple's Objective C / Cocoa framework.
296	261
297	262		### General Concepts of Object Oriented Pascal
298	263
299	264		OOP provides different ways to manage and encapsulate data and to manage program flow compared with other available programming language features and constructs. OOP often lends itself to modeling certain applications such as Graphic User Interfaces (GUI's) and physical systems in a more natural feeling manner. However OOP is not appropriate for all applications. Program control is not as explicit as the more basic Pascal procedural constructs. To obtain the most benefit from OOP, understanding of large class libraries is often required which can entail a steep learning curve. Maintaining large OOP application code has its advantages and disadvantages compared to maintaining strictly procedural code. There are many sources for learning OO analysis, design and programming techniques which are beyond the scope of this guide.
300	265
301	266		There are numerous programming languages which incorporate OOP features as extensions or the basis of their language. As such, there are many different terms for describing OO concepts. Even within FPC, some of the terminology overlaps. In general, OOP usually consists of the concept of a programming object (or information unit) which explicitly combines and encapsulates a related set of data and procedures which act on the data. This data is usually persistent during program execution but with mechanisms to reduce some of the problems inherent in declaring global variables. In addition, OOP languages enable objects to be incrementally modified and/or extended based on previously defined objects. This feature is usually referred to by the terms inheritance and polymorphism. Many OOP languages use the terms method or message referring to procedures which belong to an object. Much of the power of OOP is realized by late (run time) dynamic binding of methods rather than compile binding. This dynamic binding of methods is similar to using procedural variables and procedural parameters but with greater syntactic cohesion, encapsulation with the data it is related to and also inheritance of behavior of previously defined methods. The following wiki pages provide a starting point for discovering more about analysis, design and programming in an object orient manner.
302	267
303	268		## Further information
304	269
305	270		This has only scratched the surface of the topic. For more details, readers are strongly recommended to read the [Free Pascal](http://lazarus-ccr.sourceforge.net/fpcdoc/ref/ref.html) manuals, especially Chapters 5 (Objects) and 6 (Classes)
306	271
307	272		Borland was also kind enough to release the Object Oriented Programming chapter from the original Turbo Pascal manuals in PDF form. This chapter is from when Borland introduced this new language feature into Turbo Pascal. The chapter might be old, but the OOP theory is still very relevant today. You can download a copy from the following [link](http://geldenhuys.co.uk/articles/) under the "Other" category.
308	273
309	274		## See also
310	275
311	276		- [[Programming Using Classes]]
312	277		- [[Free Pascal videos\|Free Pascal video tutorials]]
313	278		- [[Lazarus videos\|Lazarus video tutorials]]
314	279		- [[Pascal and Lazarus Books and Magazines]]
315	280
316	281		## External Links
317	282
318	283		- <https://castle-engine.io/modern_pascal_introduction.html> - FPC mode ObjFPC
319	284		- <http://newpascal.org/assets/modern_pascal_introduction.html> - FPC mode Delphi
320	285
321	286		- <http://en.wikipedia.org/wiki/Object-oriented_programming>
322	287		- <http://en.wikipedia.org/wiki/OOAD>
323	288		- <http://en.wikipedia.org/wiki/Object_oriented_design>
324	289
325	290		---
326	291		From the Free Pascal wiki, page "Object Oriented Programming with Free Pascal and Lazarus", as it stood on 2021-04-14 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history