Object Oriented Programming with Free Pascal and Lazarus/fr: 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		Il y a beaucoup d'excellents tutoriels sur Pascal, mais ce tutoriel-ci tente d'amener le débutant plus loin, dans (la programmation orienté objet) [[Glossary\|Object-Oriented Programming]], qui est une extension de la norme Pascal standard, offert par Turbo-pascal, Delphi et FreePascal/Lazarus.
4	4
5	5		Un objet [[Glossary\|Object]] est une extension de la structure record du Pascal [record](http://wiki.lazarus.freepascal.org/Record)
6	6
7	7		La programmation Pascal standard en mode texte est bien adaptée à la création d'applications qui, comme les applications Unix, font une chose, et la font très bien. Un programme peut réaliser une tâche très compliquée, et offrir à l'utilisateur plusieurs options accessibles par menus ; mais, essentiellement, cela se résume à obéir à des commandes tapées au clavier par l'utilisateur et à afficher les réponses sur le terminal ou l'imprimante.
8	8
9	9		Pour pouvoir founir une Interface Utilisateur Graphique ([[Glossary\|Graphical User Interface (GUI)]]), il est habituel d'invoquer une méthode de Programmation Orientée Objet ou une autre (en utilisant souvent [[Glossary\|C]], ou l'une de ses variantes, ou Visual Basic, ou l'une des variantes [[Glossary\|OO]] de Pascal telle que [[Glossary\|FreePascal]] avec ou sans [[Glossary\|Lazarus]]).
10	10
11	11		Dans un(e) GUI, l'utilisateur est confronté à un écran présentant une grande quantité d'images, disposées de façon structurée, et consistant en un ensemble d'outils ou de [[Glossary\|Widgets]] qui sont associés à diverses actions telles que :
12	12
13	13		- sélection depuis un menu ;
14	14		- ouverture ou sauvegarde d'un fichier ;
15	15		- connection à Internet ;
16	16		- réalisation de calculs numériques ;
17	17		- etc.
18	18
19	19		L'utilisateur doit alors déplacer une souris ou un autre périphérique de pointage et de sélection, pour sélectionner à l'écran les actions à réaliser en réponse à un clic de souris ou à une pression de touche sur le clavier.
20	20
21	21		Alors que les systèmes prenant en charge une interface utilisateur graphique complexe peuvent être écrits en Pascal, ou quasiment n'importe quel autre langage de programmation, il est bien plus aisé d'utiliser un système orienté objet, dans lequel les propriétés, les procédures et les fonctions relatives à l'utilisation de chaque objet graphique présent à l'écran peuvent être rassemblées dans une structure commune.
22	22
23	23		## Objets - analogie avec le monde réel
24	24
25	25		Considérons l'analogie avec un prélèvement sanguin dans un hôpital ou le cabinet d'un médecin.
26	26
27	27		### Prélèvement sanguin
28	28
29	29		Le résultat physique du prélèvement est certainement un objet ; des informations lui sont associées, ainsi que des documents et plusieurs autres objets physiques.
30	30
31	31		- Tube à essai, d'un type déterminé par le test que le médecin souhaite faire ;
32	32
33	33		- Règle locale (ou méthode, procédure opérationnelle standard) pour guider l'infirmière ou le technicien chargé du prélèvement :
34	34		- quel type de tube utiliser ;
35	35		- comment traiter le prélèvement ;
36	36		- comment le conserver avant son transfert au laboratoire ;
37	37
38	38		- Etiquette sur le tube avec :
39	39		- l'identifiant du prélèvement ;
40	40		- le nom et la date de naissance du patient ;
41	41		- la date et l'heure de la prise de sang ;
42	42		- les tests demandés ;
43	43
44	44		- Formulaire de demande qui accompagne le prélèvement jusqu'au laboratoire, indiquant :
45	45		- l'ID du prélèvement ;
46	46		- l'ID de médecin requérant ;
47	47		- quels tests le médecin demande et
48	48		- donnant de plus d'information sur le patient ;
49	49		- le diagnostic que l'on souhaite confirmer.
50	50
51	51		Une copie du formulaire de demande est placée dans le dossier du patient, pour rappeler au médecin de vérifier la réception des résultats en temps voulu.
52	52
53	53		- Au laboratoire - méthodes locales pour établir :
54	54		- comment le prélèvement doit être analysé ;
55	55		- quelles machines utiliser ;
56	56		- de quelle façon calibrer et utiliser les machines ;
57	57		- comment formater et enregistrer les résultats, et
58	58		- comment les transmettre au médecin.
59	59
60	60		Les résultats sont des données que le médecin exploite pour conforter le diagnostic, et une copie en est classée dans le dossier du patient.
61	61
62	62		Le produit physique du prélèvement peut être conservé pour référence, confirmation ou tests complémentaires, ou bien jeté ou incinéré ; il y aura une méthode décrivant l'action à mener.
63	63
64	64		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.
65	65
66	66		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.
67	67
68	68		### Un autre exemple - L'automobile
69	69
70	70		Si vous n'aimez pas le sang, le même raisonnement peut être appliqué à une voiture déposée dans un garage pour une réparation. Il pourrait s'agir :
71	71
72	72		- Du véhicule physique
73	73		- Des documents du propriétaire: le permis de conduire, carte grises (les plaques d'immatriculation), les assurances, les factures d'entretien, réparations, etc
74	74		- l'histoirique de consommation de carburant
75	75		- les conducteurs autorisés à utiliser le véhicule, avec les numéros des permis de conduire
76	76		- le service des documents détenus par le garage
77	77		- des méthodes ou procédures à suivre pour les contrôles de routine et de maintenance
78	78		- des méthodes à suivre pour les réparations exceptionnelles, etc ...
79	79		- des factures pour le client
80	80
81	81		## Exemple de programmation
82	82
83	83		Assez de ces pré-occupation sur le monde réel! Passons à l'objectif principal: la programmation en FreePascal.
84	84
85	85		Considérons la création d'une simple Fiche (Form) avec quelques contrôles pour une application en FreePascal/Lazarus.
86	86
87		-	~~<div class="floatleft">~~
88		-
89		-	~~<figure>~~
90		-	~~<img src="ObjectInspector-TForm.png" title="ObjectInspector-TForm.png" />~~
91		-	~~<figcaption>ObjectInspector-TForm.png</figcaption>~~
92		-	~~</figure>~~
93		-
94		-	~~</div>~~
95		-
96		-	~~<div class="floatright">~~
97		-
98		-	~~<figure>~~
99		-	~~<img src="BlankForm.png" title="BlankForm.png" />~~
100		-	~~<figcaption>BlankForm.png</figcaption>~~
101		-	~~</figure>~~
	87	+	![](/wiki-images/2/25/ObjectInspector-TForm.png)
102	88
103		-	~~</div>~~
	89	+	![](/wiki-images/e/e2/BlankForm.png)
104	90
105	91		Au lancement de l'IDE Lazarus, le programmeur fait face à un modèle de Fiche vierge sur lequel il est invité à placer des contrôles ou objets divers.
106	92
107	93		Remarquez que cette Fiche préfabriquée est déjà un Objet, avec ses propres propriétés telles que la position (Top et Left), la taille (Height et Width), la couleur, la police par défaut pour l'ajout de texte, etc., ...
108	94
109	95		------------------------------------------------------------------------
110	96
111	97		Si un contrôle "Bouton" est placé sur cette fiche (type TButton), il aura ses propres séries de propriétés, qui pourront être examinées dans la fenêtre de l'inspecteur d'objets.
112	98
113	99		Plusieurs propriétés ont des noms similaires à celles de la fiche. C'est parcequ'elles sont héritées d'ancètres communs qui indiquent comment les propriétés doivent être définies et manipulées par les classes descendantes.
114	100
115	101		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).
116	102
117	103		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.
118	104
119		-	~~<div class="floatleft">~~
120		-
121		-	~~<figure>~~
122		-	~~<img src="ObjectInspector-TButton.png" title="ObjectInspector-TButton.png" />~~
123		-	~~<figcaption>ObjectInspector-TButton.png</figcaption>~~
124		-	~~</figure>~~
125		-
126		-	~~</div>~~
127		-
128		-	~~<div class="floatright">~~
129		-
130		-	~~<figure>~~
131		-	~~<img src="FormWithButton.png" title="FormWithButton.png" />~~
132		-	~~<figcaption>FormWithButton.png</figcaption>~~
133		-	~~</figure>~~
134		-
135		-	~~</div>~~
136		-
137		-	~~<div class="floatright">~~
	105	+	![](/wiki-images/f/f5/ObjectInspector-TButton.png)
138	106
139		-	~~<figure>~~
140		-	~~<img src="Source_FormWithButton1.png‎" title="Source_FormWithButton1.png‎" />~~
141		-	~~<figcaption>Source_FormWithButton1.png‎</figcaption>~~
142		-	~~</figure>~~
	107	+	![](/wiki-images/e/e8/FormWithButton.png)
143	108
144		-	~~</div>~~
	109	+	![](/wiki-images/4/4d/Source_FormWithButton1.png%E2%80%8E)
145	110
146	111		## Object-Oriented Extensions to standard Pascal
147	112
148	113		The Pascal record structure is extended by defining an
149	114
150	115		### Object
151	116
152	117		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.
153	118
154	119		For example, an object could contain an array of real values, together with a Method for calculating the average.
155	120
156	121		``` pascal
157	122		Type
158	123		Average = Object
159	124		NumVal: Integer;
160	125		Values: Array [1..200] of Real;
161	126		Function Mean: Real; { calculates the average value of the array }
162	127		End;
163	128		```
164	129
165	130		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.
166	131
167	132		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.
168	133
169	134		### Class
170	135
171	136		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.
172	137
173	138		Here is a simple example of a typical Class declaration:
174	139
175	140		``` pascal
176	141		{-------------------------------------------}
177	142		{ Example of Class declaration from the LCL }
178	143		{-------------------------------------------}
179	144		TPen = class(TFPCustomPen)
180	145		private
181	146		FColor: TColor;
182	147		FPenHandleCached: boolean;
183	148		FReference: TWSPenReference;
184	149		procedure FreeReference;
185	150		function GetHandle: HPEN;
186	151		function GetReference: TWSPenReference;
187	152		procedure ReferenceNeeded;
188	153		procedure SetHandle(const Value: HPEN);
189	154		protected
190	155		procedure DoAllocateResources; override;
191	156		procedure DoDeAllocateResources; override;
192	157		procedure DoCopyProps(From: TFPCanvasHelper); override;
193	158		procedure SetColor
194	159		(const NewColor: TColor; const NewFPColor: TFPColor); virtual;
195	160		procedure SetFPColor(const AValue: TFPColor); override;
196	161		procedure SetColor(Value: TColor);
197	162		procedure SetMode(Value: TPenMode); override;
198	163		procedure SetStyle(Value: TPenStyle); override;
199	164		procedure SetWidth(value: Integer); override;
200	165		public
201	166		constructor Create; override;
202	167		destructor Destroy; override;
203	168		procedure Assign(Source: TPersistent); override;
204	169		property Handle: HPEN read GetHandle write SetHandle; deprecated;
205	170		property Reference: TWSPenReference read GetReference;
206	171		published
207	172		property Color: TColor read FColor write SetColor default clBlack;
208	173		property Mode default pmCopy;
209	174		property Style default psSolid;
210	175		property Width default 1;
211	176		end;
212	177		```
213	178
214	179		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
215	180
216	181		- 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.
217	182		- 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
218	183		- public - this means that items defined here are available to any programming unit that includes the current unit in its [[Glossary\|Uses]] clause
219	184		- 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.
220	185
221	186		### Methods
222	187
223	188		A method is just like a standard procedure or function, but can have some additional directives.
224	189
225	190		Some of the methods defined above are labelled with the directive virtual; others are labelled with the override directive.
226	191
227	192		- 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.
228	193		- 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.
229	194
230	195		Methods with no virtual or override directive are static methods (the usual kind in Pascal). Those with a virtual or override directive are dynamic.
231	196
232	197		Special instances of methods are:
233	198
234	199		- create - a constructor for a class, which takes care of allocating memory, collecting together all the information needed and configuring/initializing the various properties.
235	200		- 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.
236	201
237	202		### Properties
238	203
239	204		Properties are just like ordinary fields in a conventional Pascal record, but they can have read and/or write specifiers.
240	205
241	206		- 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.
242	207		- 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.
243	208		- 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.
244	209		- 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.
245	210
246	211		#### Examples
247	212
248	213		``` pascal
249	214		TFooClass = class
250	215		private
251	216		FIntProp: Integer;
252	217		public
253	218		property IntProp: Integer read FIntProp write FIntProp;
254	219		end;
255	220		```
256	221
257	222		``` pascal
258	223		TFooClass = class
259	224		private
260	225		function GetListProp(AIndex: Integer): String;
261	226		property SetListProp(AIndex: Integer; AValue: String);
262	227		public
263	228		// this type of property may not be in the published section of a class
264	229		property ListProp[AIndex: Integer]: String read GetListProp write SetListProp;
265	230		end;
266	231		```
267	232
268	233		``` pascal
269	234		TFooClass = class
270	235		private
271	236		function GetValue(const AIndex: Integer): Integer;
272	237		procedure SetValue(const AIndex: Integer; AValue: Integer);
273	238		public
274	239		// note that the read and write methods are shared
275	240		property Value1: Integer index 1 read GetValue write SetValue;
276	241		property Value2: Integer index 2 read GetValue write SetValue;
277	242		property Value3: Integer index 3 read GetValue write SetValue;
278	243		property Value4: Integer index 4 read GetValue write SetValue;
279	244		// index may be a const or a number or you can even use an enumerated type
280	245		// for example:
281	246		// property Value: Integer index ord(seSomeEnum) read SomeFunction write SomeProcedure;
282	247		end;
283	248		```
284	249
285	250		## Extensions du langage Free Pascal
286	251
287	252		FPC inclut plusieurs extensions dans son langage par rapport à la syntaxe Pascal "standard" pour supporter la Programmation Orientée Objet (POO).
288	253
289	254		- Les objets (chapitre 5) [[Programming Using Objects]]
290	255		- Les classes (chapitre 6) [[Programming Using Classes]]
291	256		- Les interfaces (chapitre 7) [[Programming Using Interfaces]]
292	257		- Generics (chapitre 8) [[Programming Using Generics]]
293	258
294	259		Ces extensions sont décrites dans les chapitres indiqués du guide de référence du langage FPC: <http://www.freepascal.org/docs.var>. Des liens vers les pages de tutoriel pour chaque concept sont de même inclus ci-dessus. Le Guide de référence du langage comprend des diagrammes sur la syntaxe et d'autres détails ne figurant pas dans ce tutoriel d'introduction. Parmi les quatre caractéristiques du langage mentionnées ci-dessus, Objets et Classes forment la base de la Programmation Orientée Objet (POO) dans FPC et Lazarus. Pour les nouveaux avec la POO, le paragraphe Objets comprend plus d'introduction sur les concepts et le paragraphe Classes minimise la répétition en mettant l'accent sur les similitudes et les différences avec la syntaxe Objets. En général, l'implémentation Classes semble être plus largement utilisée, y compris par les développeurs Delphi et Lazarus. Souvent, le mot "objets" est utilisé pour se référer à ce qui est en fait une "classe" dans le dialecte Classes de la POO dans FPC. Ces documents seront libellés de telle manière à réduire au minimum toute confusion de terminologie, mais en dehors de ce document, souvent, le terme "objet" se réfère à des objets créés à partir d'une Classe. En fait, la bibliothèque d'exécution de FPC (RTL) comprend une bibliothèque de classes avec une classe de base appelée TObject.
295	260
296	261		Les utilisateurs familiers avec l'ancienne implémentation de la POO de Turbo Pascal peuvent initialement souhaitez sauter la section sur les classes puisque l'implémentation des objets est basée sur l'ancien dialecte de Turbo Pascal. La section sur les Classes devrait être familière pour les utilisateurs de Delphi car elle est fondée sur la syntaxe Delphi. Soyez conscient que certaines des descriptions dans la section Classes peuvent se rapporter à des concepts de la section Objets. Pour les développeurs Macintosh familiarisés avec les différents dialectes en pascal objet d'Apple, THINK et MPW, ni le dialecte des classes ni celui des objets de FPC ne fournissent une voie de migration directe. À partir de Mars 2009, il y a des discussions sur la Liste de diffusion du Pascal pour Mac dans le but de potentiellement fournir quelque soutien du compilateur (nouvelle syntaxe) pour accéder au framework en langage objet C/Cocoa d'Apple.
297	262
298	263		### Concepts généraux du Pascal orienté objet
299	264
300	265		La POO propose différentes façons de gérer et d'encapsuler les données et de gérer les flux de programmes comparé à d'autres caractéristiques et constructions de langage de programmation. La POO souvent, se prête à la modélisation de certaines applications tels que les interfaces Graphiques utilisateur(GUI's) et les systèmes physiques dans une manière de penser plus naturelle. Cependant la POO n'est pas approprié pour toutes les applications. Le contrôle de programme n'est pas aussi explicite que les plus élémentaires construction de procédure en Pascal. Pour obtenir le plus grand bénéfice de la POO, la compréhension de grandes bibliothèques de classes est souvent nécessaire ce qui peut entraîner une rude voie d'apprentissage. le maintien d'un grand code d'application avec la POO a ses avantages et ses inconvénients comparativement à maintenir du code procédural strict. Il existe de nombreuses sources d'apprentissage pour l'analyse, la conception et les techniques de programmation en POO qui sont au-delà de la portée de ce guide.
301	266
302	267		Il existe de nombreux langages de programmation qui incorporent des fonctionnalités de la POO comme des extensions ou bien comme base de leur langue. En tant que tel, il y a beaucoup de termes différents pour décrire les concepts de POO. Même dans le langage FPC, certains des termes de recoupent. En général, la POO consiste habituellement en la notion de programmation objet(ou unité d'information) qui associe explicitement et encapsule un ensemble de données et de procédures qui agissent sur les données. Ces données sont généralement persistantes au cours de l'exécution du programme mais avec des mécanismes visant à réduire certains des problèmes inhérents à la déclaration des variables globales. En outre, les langages de POO permettent à des objets une modification progressive et/ou une extension basée sur des objets défini précédemment. Cette fonctionnalité est généralement appelé par les termes héritage et polymorphisme. Beaucoup de langages de POO utilisent les termes méthode ou message se référant à des procédures qui appartiennent à un objet. Une grande partie de la puissance de la POO est réalisée par (au moment de l'exécution) la liaison dynamique tardive des méthodes plutôt que la liaison à la compilation. Cette liaison dynamique des méthodes est similaire à l'utilisation de variables procédurales et de paramètres procéduraux mais avec une plus grande cohésion syntaxique, l'encapsulation des données auxquelles il est lié et aussi l'héritage du comportement des méthodes précédemment définies. Les pages wiki suivantes fournissent un point de départ pour en découvrir plus au sujet de l'analyse, la conception et la programmation d'une manière orientée objet.
303	268
304	269		## Information complémentaire
305	270
306	271		Ceci n'a fait qu'effleurer le sujet. Pour de plus amples détails, il est fortement conseillé au lecteur de se reporter aux manuels [FreePascal](http://lazarus-ccr.sourceforge.net/fpcdoc/ref/ref.html), et en particulier aux chapitres 5 (Objets) et 6 (Classes).
307	272
308	273		## Voir aussi
309	274
310	275		- [[Console Mode Pascal]]
311	276
312	277		## Liens externes
313	278
314	279		- [Programmation orientée objet](http://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_objet)
315	280		- [Méthode d'analyse et de conception d'applications orientées objet](http://fr.wikipedia.org/wiki/M%C3%A9thode_d%27analyse_et_de_conception_d%27applications_orient%C3%A9es_objet)
316	281		- [Object-oriented design](http://en.wikipedia.org/wiki/Object_oriented_design)
317	282
318	283		---
319	284		From the Free Pascal wiki, page "Object Oriented Programming with Free Pascal and Lazarus/fr", as it stood on 2020-02-21 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