Object Oriented Programming with Free Pascal and Lazarus/it

Esistono molte guide eccellenti su Pascal, ma questa guida tenta di coinvolgere ulteriormente il principiante , nella programmazione orientata agli oggetti o Object-Oriented Programming, che è un'estensione dello standard pascal, offerta da Turbo pascal, Delphi e FreePascal/Lazarus.

Un Object è un'estensione della struttura standard pascal detta record

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.

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.

Per poter produrre una Graphical User Interface (GUI) usualmente si utilizza una sorta di Metodo di programmazione orientata agli oggetti (spesso facendo uso di C o di una delle sue varianti, o Visual Basic, o una delle OO varianti di Pascal quali FreePascal con o senza Lazarus).

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 Widgets che sono associati con varie azioni quali

• selezioni da menu,
• aperture o salvataggio files ,
• connessioni ad Internet,
• esecuzioni di calcoli numerici, etc.

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.

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.

Oggetti - una analogia con il mondo reale

Consideriamo le analogie di un campione di sangue prelevato in un ospedale o in uno studio medico.

Campione di sangue

Il campione fisico è certamente un oggetto o object; ed ha , associato con esso una quantità di informazioni,documenti ed altri oggetti fisici.

• Provetta, del tipo determinato dal test che si dovrà eseguire.
• Metodica (o metodo, procedura operativa standard) utilizzata dall'infermiera o dal tecnico di laboratorio che prelevano e processano il campione
  • che tipo di provetta si dovrà usare,
  • come processare il campione
  • come conservarlo prima di consegnarlo al laboratorio.
• Etichetta sulla provetta con i dettagli per
  • identificare il campione
  • Nome e cognome e data di nascita del paziente
  • data e ora del prelievo
  • analisi richieste.
• Modulo di richiesta che accompagna il campione per il laboratorio cui il campione è diretto
  • ID Campione
  • ID del medico richiedente
  • quali analisi il medico richiede e
  • anamnesi e dettagli completi del paziente
  • La possibile diagnosi di cui si richiede conferma.

Una copia delle richiesta viene conservata nella cartella clinica per ricordare al medico di attendersi risultati entro un periodo di tempo adeguato.

• In laboratorio - metodi locali per determinare
  • come il campione deve essere analizzato,
  • Quale strumento usare,
  • come lo strumento dovrà operare e come dovrà essere calibrato,
  • come il risultato dovrà essere memorizzato formattato e
  • presentato al medico.

L'effettivo*'risultato*' è un dato che il medico usa per formulare la diagnosi, e una copia dei risultati è archiviata nella cartella clinica del paziente.

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.

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.

I dettagli dei vari processi sonoereditati 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'''.

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à.

Traduzione da completare.....

Un'altro esempio- Automobile

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

• Il veicolo fisico
• 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
• il consumo di carburante
• i conducenti autorizzati ad utilizzare il veicolo, con le loro patenti di guida
• gli interventi di manutenzione registrati presso il garage
• metodi o procedure da seguire per la verifica e la manutenzione di routine
• metodi da seguire per le riparazioni non di routine, ecc
• informazioni di fatturazione per il cliente

Esempi di programmazione

Basta con questa introduzione, fatta di esempi del mondo reale! Dobbiamo procedere con l'obiettivo principale: la programmazione FreePascal

Dobbiamo considerare la creazione di un semplice modulo con pochi controlli per una applicazione in FreePascal / Lazzaro.

Richiamando la IDE di Lazarus, al programmatore viene presentato un modello vuoto "Form" in progettazione, in cui egli dovrà porre oggetti e vari controlli.

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

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 .

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.

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).

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.

Object-Oriented Extensions to standard Pascal

La struttura Pascal di tipo record viene estesa per definire un

Object

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.

Ad esempio, un oggetto può contenere una serie di valori reali, una matrice,unitamente con un metodo di calcolo della media.

Type
  Average = Object
    NumVal: Integer;
    Values: Array [1..200] of Real;
    Function Mean: Real; { calculates the average value of the array }
  End;

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.

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.

Class

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.

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:

{-----------------------------------------}
{example of Class declaration from the LCL}
{-----------------------------------------}
 TPen = class(TFPCustomPen)
 private
   FColor: TColor;
   FPenHandleCached: boolean;
   FReference: TWSPenReference;
   procedure FreeReference;
   function GetHandle: HPEN;
   function GetReference: TWSPenReference;
   procedure ReferenceNeeded;
   procedure SetHandle(const Value: HPEN);
 protected
   procedure DoAllocateResources; override;
   procedure DoDeAllocateResources; override;
   procedure DoCopyProps(From: TFPCanvasHelper); override;
   procedure SetColor
        (const NewColor: TColor; const NewFPColor: TFPColor); virtual;
   procedure SetFPColor(const AValue: TFPColor); override;
   procedure SetColor(Value: TColor);
   procedure SetMode(Value: TPenMode); override;
   procedure SetStyle(Value: TPenStyle); override;
   procedure SetWidth(value: Integer); override;
 public
   constructor Create; override;
   destructor Destroy; override;
   procedure Assign(Source: TPersistent); override;
   property Handle: HPEN read GetHandle write SetHandle; deprecated;
   property Reference: TWSPenReference read GetReference;
 published
   property Color: TColor read FColor write SetColor default clBlack;
   property Mode default pmCopy;
   property Style default psSolid;
   property Width default 1;
 end;

Si noti che questa classe è definita come un istanza di un altra classe madre o antenato ('TFPCustomPen) da cuieredita''' tutte le sue proprietà e metodi.Ha alcuni campi propri, raggruppati sotto

• 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 è daGraphics, 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.
• 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
• public - questo significa che le voci definite qui sono solo disponibili per qualunque unit che includa la unit corrente in essa con la clausula Uses
• 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.

Methods

Un metodo è esattamente come una procedura standard o una funzione, ma può avere qualche directives.

Alcuni dei metodi di definizione di cui sopra sono etichettati con la direttiva virtual; altri sono etichettati con la direttiva override.

• 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.
• 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.

Methods with no virtual or override directive are static methods (the usual kind in Pascal). Those with a virtual or override directive are dynamic.

Special instances of methods are:

• create - a constructor for a class, which takes care of allocating memory, collecting together all the information needed and configuring/initializing the various properties.
• 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.

Properties

Properties are just like ordinary fields in a conventional Pascal record, but they can have read and/or write specifiers.

• 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.
• 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.
• 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.

Further information

This has only scratched the surface of the topic. For more details, readers are strongly recommended to read the FreePascal manuals, especially Chapters 5 (Objects) and 6 (Classes)

--Kirkpatc 11:04, 20 July 2008 (CEST)

Console Mode Pascal

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.