Șabloane în Delphi
Modele în programarea DelphiShablony (Design Patterns) - este frecvent utilizat în procesul de structura de programare, dependențe și de comunicare într-un design orientat pe obiect. Știind cum să folosești șabloanele corect și mai util vă poate ajuta să vă proiectați mai bine aplicațiile, folosiți un cod mai reușit și mai compact, structurat. De asemenea, va contribui la dezvoltarea sistemelor mari și complexe.
Delphi - un limbaj orientat pe obiect, în care există un set de clase (obiecte) și unele dependențe care au fost deja puse în aplicare și sunt gata de utilizare, care ajută la simplificarea și să faciliteze dezvoltarea de aplicații. Dar cea mai importantă relație în lumina șabloanele de obiecte ale modelului sunt: clasa de moștenire, virtuale (virtuale) și abstratknye (abstracte) metode, folosind un sistem sigur (protejat) și publice (publice) definiții metoda. Toate acestea vă permite să creați șabloane de programare care pot fi folosite de mai multe ori și extinde cu ușurință capacitățile lor. La fel ca orice limbaj orientat pe obiect, Delphi vă permite să îmbunătăți funcționalitatea și stabilitatea modelelor prin izolarea proprietăților fundamentale și metodele de omologii lor care pot fi supuse modificării.
Și cel mai simplu exemplu - este ea însăși Delphi, mediu de dezvoltare extensibila, datorită arhitecturii de pachete, mediu de dezvoltare de interfață pentru interfețele sale (IDE) și instrumente (unelte). Aceste interfețe definesc un set de constructori și operații (metode) abstracte și virtuale, care sunt utilizate pe scară largă atât în software-ul scris și extinderea mediului de dezvoltare în sine (scris al componentelor sale, de masterat, experți).
Constat că în acest articol, multe dintre denumirile și definițiile sunt furnizate „ca atare“. Am găsit-o mai convenabil decât a face cu numele de șabloane de traducere și alți termeni în limba rusă, nu este întotdeauna posibil să se transfere determinarea exactă a traducerii, dar semnificația termenului nu ar dori să-și piardă. Așa că denumite în continuare toate numele de modele rămase în limba engleză, pentru care contează, și exemple de cod sursă, deși recunosc că, probabil, în alte surse, altele decât a mea, numele și termenii pot varia. Dar nu lăsa asta enigmatic, din moment ce descrierea va deveni clar cu privire la scopul fiecărui model în parte. De asemenea, șabloane enumerate nu pretind a fi o listă completă de șabloane. Ele reflectă pur și simplu cunoștințele mele în acest domeniu din sursele care sunt enumerate mai jos.
În tabel este prezentată o listă a unor șabloane utilizate frecvent (mai mult de patruzeci în total).
Se verifică dacă această clasă are doar o singură instanță. Oferă informații globale pentru a accesa clasa.
Convertește interfața clasei într-o interfață diferită înțeleasă de clientul șablon. Adaptorul permite claselor cu interfețe diferite să colaboreze, ceea ce este imposibil în condiții normale din cauza diferențelor de interfețe.
Definește scheletul algoritmului sau al componentelor acestuia într-o operație globală, permițându-vă să întrerupeți execuția în mai mulți pași, trecând-o în subclase. Adică, subclasele sunt capabile să redefinească niște pași ai algoritmului fără a schimba întreaga structură a algoritmului.
Separă crearea unui obiect din reprezentarea sa practică, astfel încât un constructor să poată crea diferite reprezentări ale obiectului.
Oferă un mecanism pentru crearea unei familii de obiecte legate sau dependente, fără a fi nevoie de descrierea anumitor clase.
Definește o interfață care vă permite să creați un obiect, dar permite subclaselor să decidă ce clasă să implementeze. Metoda Factory permite ca clasa să aibă subclase, adică copii.
utilizări
Windows, Mesaje, SysUtils, Clase, Grafică, Controale, Formulare, Dialoguri;
tip
TCSingleton = clasă (TComponent)
privat
protejat
public
constructor Creator (AOwner: TComponent); suprascrie; // Înlocuiți constructorul
destructor Destroy; suprascrie; // Override the destructor
var Global_CSingleton: TCSingleton;
Global_OSingleton: TOSingleton;
registru de proceduri;
începe
RegisterComponents ("Modele", [TCSingleton, TOSingleton]); // componentele descrise vor fi înregistrate și plasate pe fila Modele.
se încheie;
constructorul TCSingleton.Create (AOwner: TComponent);
începe
dacă Global_CSingleton <> nil apoi // verificați unicitatea componentei create
începe
ShowMessage ("Componenta există deja! Nu puteți crea mai mult de o astfel de componentă."); // dacă există deja, utilizatorul este refuzat să creeze o altă instanță
Abort // întrerupe execuția fără notificări de eroare
capăt
Altceva începe
moștenit crea (AOwner); // altfel vom crea un obiect
Global_CSingleton: = Self; // și treceți linkul la el
se încheie;
se încheie;
destructor TCSingleton.Destroy;
începe
dacă Global_CSingleton = Self = // dacă există un obiect care trebuie distrus
Global_CSingleton: = zero; // apoi distruge-o
moștenit Distruge; / / sunați-l pe distrugătorul extern
se încheie;
constructorul TOSingleton.Create (AOwner: TComponent);
începe
dacă Global_OSingleton <> nil atunci
începe
ShowMessage ('Obiectul există deja! Nu puteți crea mai mult de un astfel de obiect.');
avorta
capăt
Altceva începe
moștenit crea (AOwner);
Global_OSingleton: = Self;
se încheie;
se încheie;
destructor TOSingleton.Destroy;
începe
dacă Global_OSingleton = Auto atunci
Global_OSingleton: = nil;
moștenit Distruge;
se încheie;
utilizează SysUtils, Classes;
FCustomerID: Longint;
FFirstName: șir;
Numele de bare: șir;
FDOB: TDateTime;
funcția GetCustomerID: Longint; virtuale;
funcția GetFirstName: șir; virtuale;
funcția GetLastName: șir; virtuale;
funcția GetDOB: TDateTime; virtuale;
constructorul Creator (CustID: Longint); virtuale;
ID-ul de identificare a proprietatii: Longint citit GetCustomerID;
proprietate FirstName: șir citit GetFirstName;
proprietate LastName: string citiți GetLastName;
proprietate DOB: TDateTime citi GetDOB;
funcția GetCustomer (Nume client: Longint): TNewCustomer;
constructor TNewCustomer.Create (CustID: Longint);
începe
FCustomerID: = CustID;
FFirstName: = 'A';
Numele de parola: = 'New_Customer';
FDOB: = Acum;
END;
funcție TNewCustomer.GetCustomerID: Longint;
funcție TNewCustomer.GetFirstName: șir;
începe
Rezultat: = FFirstName;
se încheie;
funcție TNewCustomer.GetLastName: șir;
începe
Rezultat: = nume de grup;
se încheie;
funcția TNewCustomer.GetDOB: TDateTime;
începe
Rezultat: = FDOB;
se încheie;
TOldDOB = înregistrare
Ziua: 0..31;
Luna: 1..12;
An: 0..99;
se încheie;
FCustomerID: Integer;
FName: șir;
FDOB: TOldDOB;
Constructor Creare (CustID: Integer);
ID-ul de identificare a proprietății: Integer citire FCustomerID;
proprietate Nume: șir citit FName;
proprietate DOB: TOldDOB citi FDOB;
constructor TOldCustomer.Create (CustID: Integer);
începe
FCustomerID: = Codul de client;
FName: = 'Un client vechi';
cu FDOB să înceapă
Ziua: = 1;
Lună: = 1;
An: = 1;
se încheie;
se încheie;
funcția GetCustomerID: Longint; suprascrie;
funcția GetFirstName: șir; suprascrie;
funcția GetLastName: șir; suprascrie;
funcția GetDOB: TDateTime; suprascrie;
constructorul Creator (CustID: Longint); suprascrie;
destructor Destroy; suprascrie;
constructorul TadaptedCustomer.Create (CustID: Longint);
începe
moștenit crea (CustID);
FOldCustomer: = TOldCustomer.Create (CustID);
se încheie;
destructor TadaptedCustomer.Destroy;
începe
FOldCustomer.Free;
moștenit Distruge;
se încheie;
funcția TadaptedCustomer.GetCustomerID: Longint;
funcția TadaptedCustomer.GetFirstName: șir;
var SpacePos: integer;
funcția TadaptedCustomer.GetLastName: șir;
var SpacePos: integer;
funcția TadaptedCustomer.GetDOB: TDateTime;
var FullYear: Cuvânt;
funcția GetCustomer (Nume client: Longint): TNewCustomer;
începe
dacă numele clientului> Last_OldCustomer_In_Database atunci
Rezultat: = TNewCustomer.Create (CustomerID)
altfel
Rezultat: = TadaptedCustomer.Create (CustomerID) ca TNewCustomer;
se încheie;
Astfel, clasa TadaptedCustomer există ca un strat între două alte clase, asigurând interacțiunea lor normală - transformarea datelor într-un format înțeles de noua clasă.
Acesta este unul dintre cele mai simple șabloane. Așa cum am scrie acest lucru, există aproximativ 40 de ani, dar nu sunt atât de răspândit, și în articolul următor ne vom uita la câteva template-uri, mai complexe decât cele de mai sus. Cu toate acestea, cu cât sunt mai complexe acestea, cu atât mai utile ar putea să le aducă la folosirea dvs. în dezvoltarea dvs. Și cu cât învățați mai curând să folosiți aceste cunoștințe cu profit, cu atât mai ușor și mai ușor va fi pentru dvs. să lucrați și să programați.
Denis Migachev AKA Denver