Object Oriented Programming with Free Pascal and Lazarus/it: what changed
Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.
| Old | New | Line | |
|---|---|---|---|
| 1 | 1 | Esistono molte guide eccellenti su Pascal, ma questa guida tenta di coinvolgere ulteriormente il principiante , nella programmazione orientata agli oggetti o [[Glossary|Object-Oriented Programming]], che è un'estensione dello standard pascal, offerta da Turbo pascal, Delphi e FreePascal/Lazarus. | |
| 2 | 2 | ||
| 3 | 3 | Un [[Glossary|Object]] è un'estensione della struttura standard pascal detta [record](http://wiki.lazarus.freepascal.org/Record) | |
| 4 | 4 | ||
| 5 | 5 | La programmazione Pascal in testo standard è adatta alla creazione di applicazioni che, come le applicazioni Unix tradizionali,sono adatte per fare una cosa e per farla molto bene. | |
| 6 | 6 | ||
| 7 | 7 | Ciò che un programma fa può essere un'azione veramente complicata ,e può offrire all'utente molte opzioni di menu, ma è essenzialmente ristretta ad obbedire a comandi che l'utente digita da tastiera e a listare le sue risposte sul terminale o sulla stampante. | |
| 8 | 8 | ||
| 9 | 9 | Per poter produrre una [[Glossary|Graphical User Interface (GUI)]] usualmente si utilizza una sorta di Metodo di programmazione orientata agli oggetti (spesso facendo uso di [[Glossary|C]] o di una delle sue varianti, o Visual Basic, o una delle [[Glossary|OO]] varianti di Pascal quali [[Glossary|FreePascal]] con o senza [[Glossary|Lazarus]]). | |
| 10 | 10 | ||
| 11 | 11 | In una GUI all'utente vengono presentate schermate con un gran numero di immagini organizzate in modo strutturato, consistenti in un'insieme di strumenti o [[Glossary|Widgets]] che sono associati con varie azioni quali | |
| 12 | 12 | ||
| 13 | 13 | - selezioni da menu, | |
| 14 | 14 | - aperture o salvataggio files , | |
| 15 | 15 | - connessioni ad Internet, | |
| 16 | 16 | - esecuzioni di calcoli numerici, etc. | |
| 17 | 17 | ||
| 18 | 18 | L'utente dovrà muovere il mouse o qualche altro puntatore o strumento sullo schermo, per selezionare le azioni che saranno eseguite in risposta al click del mouse o ai tasti premuti. | |
| 19 | 19 | ||
| 20 | 20 | I sistemi per offrire una complessa interfaccia grafica possono essere scritti in Pascal standard o quasi qualsiasi altro linguaggio di programmazione, ma è molto più facile l'utilizzo di un sistema orientato agli oggetti, in cui ogni oggetto grafico sullo schermo può avere tutte le sue proprietà e le sue procedure e funzioni connesse con il suo uso conglobate in una struttura comune. | |
| 21 | 21 | ||
| 22 | 22 | ## Oggetti - una analogia con il mondo reale | |
| 23 | 23 | ||
| 24 | 24 | Consideriamo le analogie di un campione di sangue prelevato in un ospedale o in uno studio medico. | |
| 25 | 25 | ||
| 26 | 26 | ### Campione di sangue | |
| 27 | 27 | ||
| 28 | 28 | Il campione fisico è certamente un oggetto o **object**; ed ha , associato con esso una quantità di informazioni,documenti ed altri oggetti fisici. | |
| 29 | 29 | ||
| 30 | 30 | - **Provetta**, del tipo determinato dal test che si dovrà eseguire. | |
| 31 | 31 | ||
| 32 | 32 | - **Metodica** (o *metodo*, *procedura operativa standard*) utilizzata dall'infermiera o dal tecnico di laboratorio che prelevano e processano il campione | |
| 33 | 33 | - che tipo di provetta si dovrà usare, | |
| 34 | 34 | - come processare il campione | |
| 35 | 35 | - come conservarlo prima di consegnarlo al laboratorio. | |
| 36 | 36 | ||
| 37 | 37 | - **Etichetta** sulla provetta con i dettagli per | |
| 38 | 38 | - identificare il campione | |
| 39 | 39 | - Nome e cognome e data di nascita del paziente | |
| 40 | 40 | - data e ora del prelievo | |
| 41 | 41 | - analisi richieste. | |
| 42 | 42 | ||
| 43 | 43 | - **Modulo di richiesta** che accompagna il campione per il laboratorio cui il campione è diretto | |
| 44 | 44 | - ID Campione | |
| 45 | 45 | - ID del medico richiedente | |
| 46 | 46 | - quali analisi il medico richiede e | |
| 47 | 47 | - anamnesi e dettagli completi del paziente | |
| 48 | 48 | - La possibile diagnosi di cui si richiede conferma. | |
| 49 | 49 | ||
| 50 | 50 | Una copia delle richiesta viene conservata nella cartella clinica per ricordare al medico di attendersi risultati entro un periodo di tempo adeguato. | |
| 51 | 51 | ||
| 52 | 52 | - In laboratorio - **metodi locali** per determinare | |
| 53 | 53 | - come il campione deve essere analizzato, | |
| 54 | 54 | - Quale strumento usare, | |
| 55 | 55 | - come lo strumento dovrà operare e come dovrà essere calibrato, | |
| 56 | 56 | - come il risultato dovrà essere memorizzato formattato e | |
| 57 | 57 | - presentato al medico. | |
| 58 | 58 | ||
| 59 | 59 | L'effettivo*'risultato*' è un dato che il medico usa per formulare la diagnosi, e una copia dei risultati è archiviata nella cartella clinica del paziente. | |
| 60 | 60 | ||
| 61 | 61 | Il campione fisico può essere conservato per riferimento,per test di conferma o ulteriori test, o potrà essere smaltito in ottemperanza alle norme per lo smaltimento dei campioni biologici o mediante incenerimento, ci sarà un metodo per descrivere questo procedimento. | |
| 62 | 62 | ||
| 63 | 63 | Non è necessario che il medico dica tutti i dettagli operativi e le istruzioni di lavoro ogni qualvolta che un campione viene prelevato; anzi,egli può avere ben poche conoscenze di come il campione verrà processato dal laboratorio. | |
| 64 | 64 | ||
| 65 | 65 | I dettagli dei vari processi sono***ereditati** dai precedenti processi dei campione in analisi ,ossia a priori si è stabilito il metodo di processo del campione - ci sarà un piano generico per l'intera sequenza, e insieme abbiamo potuto pensare al campione di sangue,a tutti i suoi documenti e dati, e la metodica di base, come a un complesso* 'oggetto'''. | |
| 66 | 66 | ||
| 67 | 67 | Nella mente del medico, il campione di sangue è visto come un'unica entità, come i suoi risultati, e per gli infermieri e tecnici il campione, la provetta, l'etichetta e le condizioni di conservazione anch'esse sono identificate come se fossero una sola entità. | |
| 68 | 68 | ||
| 69 | 69 | Traduzione da completare..... | |
| 70 | 70 | ||
| 71 | 71 | ### Un'altro esempio- Automobile | |
| 72 | 72 | ||
| 73 | 73 | Se non vi piace l'esempio del campione di sangue,lo stesso tipo di ragionamento può essere applicato all'automobile consegnata al garage per una riparazione. Ciò potrebbe consistere in | |
| 74 | 74 | ||
| 75 | 75 | - Il veicolo fisico | |
| 76 | 76 | - i documenti in possesso del proprietario: Libretto di circolazione (comprese targhe), le assicurazioni, le ricevute per l'acquisto, i pezzi di ricambio, le riparazioni, ecc | |
| 77 | 77 | - il consumo di carburante | |
| 78 | 78 | - i conducenti autorizzati ad utilizzare il veicolo, con le loro patenti di guida | |
| 79 | 79 | - gli interventi di manutenzione registrati presso il garage | |
| 80 | 80 | - metodi o procedure da seguire per la verifica e la manutenzione di routine | |
| 81 | 81 | - metodi da seguire per le riparazioni non di routine, ecc | |
| 82 | 82 | - informazioni di fatturazione per il cliente | |
| 83 | 83 | ||
| 84 | 84 | ## Esempi di programmazione | |
| 85 | 85 | ||
| 86 | 86 | Basta con questa introduzione, fatta di esempi del mondo reale! Dobbiamo procedere con l'obiettivo principale: la programmazione FreePascal | |
| 87 | 87 | ||
| 88 | 88 | Dobbiamo considerare la creazione di un semplice modulo con pochi controlli per una applicazione in FreePascal / Lazzaro. | |
| 89 | 89 | ||
| 90 | - | ||
| 91 | - | ||
| 92 | - | ||
| 93 | - | ||
| 94 | - | ||
| 95 | - | ||
| 96 | - | ||
| 97 | - | ||
| 98 | - | ||
| 99 | - | ||
| 100 | - | ||
| 101 | - | ||
| 102 | - | ||
| 103 | - | ||
| 104 | - | ||
| 90 | + |  | |
| 105 | 91 | ||
| 106 | - | ||
| 92 | + |  | |
| 107 | 93 | ||
| 108 | 94 | Richiamando la IDE di Lazarus, al programmatore viene presentato un modello vuoto "Form" in progettazione, in cui egli dovrà porre oggetti e vari controlli. | |
| 109 | 95 | ||
| 110 | 96 | Si noti che il Form vuoto precostituito è già un oggetto, con le proprie caratteristiche, come la posizione (in alto e sinistra), le dimensioni (altezza e larghezza), il colore, il font di default per l'aggiunta di testo ecc | |
| 111 | 97 | ||
| 112 | 98 | ------------------------------------------------------------------------ | |
| 113 | 99 | ||
| 114 | 100 | Se un controllo Button, un tasto, viene immesso sul Form (tipo TButton), questi avrà una serie di proprietà, che possono essere esaminate nella finestra Object Inspector . | |
| 115 | 101 | ||
| 116 | 102 | Molte delle proprietà hanno nomi simili a quelle del Modulo 'Form', questo è dovuto al fatto che molte proprietà sono*'ereditate*' da parte di alcuni comuni antenati di classe, che definiscono le proprietà come sono definite e gestite dalle classi discendenti. | |
| 117 | 103 | ||
| 118 | 104 | Così come per le proprietà, l'Object Inspector offre una scheda denominata*'Eventi*', che dà accesso ai gestori di eventi 'Event Handlers' che sono metodi per gestire tali eventi, come un clic del mouse su un pulsante (OnClick) o alcuni cambiamento di posizione, le dimensioni o altre proprietà (OnChange). | |
| 119 | 105 | ||
| 120 | 106 | L'immagine fisica del pulsante nel Modulo o Form, insieme con tutte le sue proprietà e metodi di gestione, dovrebbe essere considerato come una singola entità o*'oggetto*' in Pascal. | |
| 121 | 107 | ||
| 122 | - | ||
| 123 | - | ||
| 124 | - | ||
| 125 | - | ||
| 126 | - | ||
| 127 | - | ||
| 128 | - | ||
| 129 | - | ||
| 130 | - | ||
| 131 | - | ||
| 132 | - | ||
| 133 | - | ||
| 134 | - | ||
| 135 | - | ||
| 136 | - | ||
| 137 | - | ||
| 138 | - | ||
| 139 | - | ||
| 140 | - | ||
| 108 | + |  | |
| 141 | 109 | ||
| 142 | - | ||
| 143 | - | ||
| 144 | - | ||
| 145 | - | ||
| 110 | + |  | |
| 146 | 111 | ||
| 147 | - | ||
| 112 | + |  | |
| 148 | 113 | ||
| 149 | 114 | ## Object-Oriented Extensions to standard Pascal | |
| 150 | 115 | ||
| 151 | 116 | La struttura Pascal di tipo record viene estesa per definire un | |
| 152 | 117 | ||
| 153 | 118 | ### Object | |
| 154 | 119 | ||
| 155 | 120 | Un oggetto è uno speciale tipo di record. Il record contiene tutti i campi che sono dichiarati nella definizione dell'oggetto (proprio come un convenzionale record), ma ora le procedure e le funzioni possono essere dichiarate come se fossero parte del record e si richiamano come puntatori ai metodi associati con il tipo di oggetto. | |
| 156 | 121 | ||
| 157 | 122 | Ad esempio, un oggetto può contenere una serie di valori reali, una matrice,unitamente con un metodo di calcolo della media. | |
| 158 | 123 | ||
| 159 | 124 | `Type`\ | |
| 160 | 125 | ` Average = Object`\ | |
| 161 | 126 | ` NumVal: Integer;`\ | |
| 162 | 127 | ` Values: Array [1..200] of Real;`\ | |
| 163 | 128 | ` Function Mean: Real; { calculates the average value of the array }`\ | |
| 164 | 129 | ` End;` | |
| 165 | 130 | ||
| 166 | 131 | Gli oggetti possono "ereditare" campi e metodi da oggetti "madre". Ciò significa che questi campi e metodi possono essere usati come se fossero incluse negli oggetti dichiarati come un oggetto figlio. | |
| 167 | 132 | ||
| 168 | 133 | Inoltre, viene introdotto un concetto di visibilità : i campi, le procedure e le funzioni possono essere dichiarati come pubblici, protetti o privati. Per impostazione predefinita, i campi e metodi sono pubblici, e possono essere esportati al di fuori delle attuali unit. Campi o metodi protetti sono disponibili solo per gli oggetti discendenti dal corrente oggetto antenato. Campi e metodi dichiarati privati sono unicamente accessibili nella unit corrente: il loro scopo è limitato all'implementazione della corrente unit. | |
| 169 | 134 | ||
| 170 | 135 | ### Class | |
| 171 | 136 | ||
| 172 | 137 | Gli oggetti molto spesso non sono usati da se stessi in FreePascal and Lazarus; invece le classi sono largamente usate. La Classe è definita quasi alla stessa stregua di un oggetto, ma è un puntatore ad un oggetto piuttosto che l'oggetto stesso. | |
| 173 | 138 | ||
| 174 | 139 | Tecnicamente, questo significa che la classe è assegnata "on the Heap of a program", mentre l'oggetto viene assegnato in Stack. Ecco un semplice esempio di dichiarazione di una classe: | |
| 175 | 140 | ||
| 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 | Si noti che questa classe è definita come un istanza di un altra classe **madre** o **antenato** (**'TFPCustomPen) da cui**eredita''' tutte le sue proprietà e metodi.Ha alcuni campi propri, raggruppati sotto | |
| 214 | 179 | ||
| 215 | 180 | - **private** - questo significa che gli elementi qui definiti, sono disponibili o visibili da altre classi procedure o funzioni definite all'interno della stessa unit di programma (questo esempio è da*Graphics*, così che una qualsiasi delle altre classi, come *TBitMap*,*TPicture* etc nella stessa unità è in grado di farne uso.Esse sono generalmente variabili locali (eg *FColor*, *FPenHandleCached*) o metodi usati localmente(*GetHandle*, *SetHandle*) ma possono essere usate o possono riferirvi voci dichiarate in sezioni **protected** or **public**. | |
| 216 | 181 | - **protected** - questo significa che le voci definite qui sono solo disponibili o visibili da classi che discendono da quella classe **antenata**,ed eredita le sue proprietà o metodi | |
| 217 | 182 | - **public** - questo significa che le voci definite qui sono solo disponibili per qualunque unit che includa la unit corrente in essa con la clausula [[Glossary|Uses]] | |
| 218 | 183 | - **published** - è simile alla sezione **public**, ma il compilatore genera anche il tipo di informazioni che è necessario per lo streaming automatico di queste classi. Spesso la lista delle voci appare nel Object Inspector di Lazarus; se non compare una lista **published**,tutti i campi **public** appaiono normalmente in the Object Inspector. | |
| 219 | 184 | ||
| 220 | 185 | ### Methods | |
| 221 | 186 | ||
| 222 | 187 | Un metodo è esattamente come una procedura standard o una funzione, ma può avere qualche **directives**. | |
| 223 | 188 | ||
| 224 | 189 | Alcuni dei metodi di definizione di cui sopra sono etichettati con la direttiva **virtual**; altri sono etichettati con la direttiva **override**. | |
| 225 | 190 | ||
| 226 | 191 | - **virtual** significa che il tipo o il grado effettivo di un metodo non è noto al momento della compilazione,ma è stato selezionato in run-time a seconda di ciò che effettivamente richiama il sotto-programma sul momento. 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 | ||
| 244 | 209 | ## Further information | |
| 245 | 210 | ||
| 246 | 211 | This has only scratched the surface of the topic. For more details, readers are strongly recommended to read the [FreePascal](http://lazarus-ccr.sourceforge.net/fpcdoc/ref/ref.html) manuals, especially Chapters 5 (**Objects**) and 6 (**Classes**) | |
| 247 | 212 | ||
| 248 | 213 | --Kirkpatc 11:04, 20 July 2008 (CEST) | |
| 249 | 214 | ||
| 250 | 215 | ------------------------------------------------------------------------ | |
| 251 | 216 | ||
| 252 | 217 | [[Console Mode Pascal]] | |
| 253 | 218 | ||
| 254 | 219 | --- | |
| 255 | 220 | *From the Free Pascal wiki, page "Object Oriented Programming with Free Pascal and Lazarus/it", as it stood on 2015-06-19 after a change by FTurtle, 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).* |