Object Oriented Programming with Free Pascal and Lazarus/hu

From Free Pascal wiki
Jump to navigationJump to search

│ English (en) │ español (es) │ français (fr) │ magyar (hu) │ italiano (it) │ 日本語 (ja) │ македонски (mk) │ русский (ru) │ 中文（中国大陆） (zh_CN) │ 中文（臺灣） (zh_TW) │


Objektum-orientált programozás Free Pascal-lal és Lazarus-szal



Bevezetés

Rengeteg kitűnő tananyag található a Pascal-ról, de ennek a leírásnak a célja továbbvinni a kezdőket az objektum-orientált programozás világába, ami a szabványos Pascal kiegészítése. Ezt a kiegészítést a Turbo-Pascal, a Delphi és a Free Pascal / Lazarus tartalmazza.

Az Objektum a szabványos Pascal-ban definiált rekord struktúra kibővítése.

A hagyományos szöveges módú Pascal programozás megfelelő olyan programok készítésére - mint például a hagyományos Unix alkalmazások -, amelyek egy dolgot tudnak csinálni, de azt nagyon jól. Az a bizonyos "egy dolog", amit az alkalmazás csinál elég bonyolult lehet, és akár több menüből elérhető lehetőséget kínálhat a felhasználónak, de alapvetően csak parancsok kiadására szorítkozik, amelyeket a felhasználó kiad a billentyűzet segítségével, és a választ a monitoron vagy a nyomtatón kapja meg.

Ahhoz, hogy egy grafikus felhasználói felületet (GUI) hozzunk létre, általában szükséges bevonni a dolgokba valamilyen objektum-orientált programozási metódust (gyakran a C nyelv vagy valamelyik variánsának használatával, Visual Basic-kel, vagy valamelyik OO variánsával a Pascal-nak, úgymint a Free Pascal a Lazarus-szal vagy nélküle).

Egy GUI-ban a felhasználónak rendelkezésére áll egy képernyő, nagy mennyiségű szervezetten elrendezett képpel és ikonnal, amelyek eszközkészletekből, Widget-ekből állnak, amelyekhez különféle események vannak hozzárendelve, úgy mint

  • kiválasztás egy menüből,
  • fájlok megnyitása, vagy mentése,
  • csatlakozás az internethez,
  • numerikus műveletek végrehajtása, stb.

A felhasználó feladata mozgatni az egeret vagy kijelölő eszközt a képernyőn, hogy eseményeket válasszon ki, amelyek végrehajtódnak egérgomb-, vagy billentyű lenyomására.

Annak ellenére, hogy minden komplex grafikus felhasználói felülettel rendelkező rendszer megírható Pascal-ban, vagy bármely más nyelven, sokkal egyszerűbb objektum-orientált rendszert használni, ahol minden grafikus objektumnak a képernyőn lehetnek saját tulajdonságai és függvényei, így együtt egy összefüggő szerkezetet alkotva.

Már a tárgyalás elején le kell szögeznünk az osztály és az objektum közötti fontos logikai különbséget: az osztály egy leírás, amely alapján a fordító példányosítás segítségével létrehozza az objektumot.

Sajnos Pascal-ban ez az egyszerű logika csorbát szenved, mert object (objektum) és class (osztály) is deklarálható, illetve példányosítható. A kettő között a különbséget a futási időben elfoglalt memóriaterület helye jelenti: az osztály (class) egy objektumra mutató mutató (pointer). Ez azt jelenti, hogy az osztály a program HEAP területén helyezkedik el, míg az objektum a stack-en.

Ennek ellenére - mivel az object típust ritkán alkalmazzuk - nyugodtan használhatjuk az első logikai gondolatmenetet.

Objektumok - a való világ analógiája

Vegyük például a vérminta analógiáját, amit egy kórházban vagy az orvosi rendelőben gyűjtenek be.

Vérminta

A minta fizikálisan természetesen egy objektum; létezik - vele összefüggésben - rengeteg információ, dokumentum, és egyéb fizikai objektum.

  • Kémcső, olyan típusú, amelyet a teszt előír.
  • Helyi szabályozás (vagy metódus, szabványos művelet) amely a nővér vagy technikus munkáját irányítja
    • milyen kémcsövet használjon,
    • hogyan dolgozza fel a mintát
    • hogyan tárolja a laborba való szállításig.
  • Címke a kémcsövön a részletekkel:
    • minta azonosító
    • a páciens neve és születési dátuma
    • a mintavétel időpontja
    • a szükséges tesztek.
  • Igénylőlap, amivel a mintát a laborba küldik:
    • minta azonosító
    • az igénylő azonosítója
    • az igényelt vizsgálatok
    • bővebb információk a páciensről
    • a lehetséges diagnózis, amelynek a megerősítését kérik.

Az igénylőlap másolatát elhelyezik a páciens kartonjában, hogy emlékeztesse az orvost arra, hogy adott időn belül eredményeket fog kapni.

  • A laborban - helyi metódusok, amelyek meghatározzák:
    • hogyan kell a mintát analizálni,
    • milyen eszközöket kell használni,
    • hogyan kell az eszközöket kalibrálni, és működtetni,
    • milyen formában kell tárolni az eredményeket, és
    • hogyan kell visszajelenteni az orvosnak.

A tényleges eredmény egy rekord, amelyet az orvos a diagnózis felállításához használ, továbbá egy másolat kerül elhelyezésre a páciens kartonjában.

A fizikai minta megmaradhat referenciának, igazolásnak vagy további tesztekhez, vagy megsemmisítik valamilyen módon; ehhez egy további metódus szükséges, ami ennek a módját meghatározza.

Nincs szükség orvosra, hogy kitalálja az összes részletet és utasítást minden alkalommal, amikor egy mintát begyűjtenek; sőt, lehet, hogy alig van tudomása arról, hogy hogyan értékelnek ki egy mintát a laborban. A különféle eljárások öröklődnek az előző mintavételekből és analízisekből - így lesz egy általános terv az egész folyamatra - és így együtt, az összes dokumentummal, adattal, és a hozzájuk tartozó metódusokkal a vérmintát, egy komplex objektumként tekinthetjük.

Az orvos képzeletében, a vérminta többnyire ugyanannak az entitásnak jelenik meg, mint az eredményei. A nővéreknek és technikusoknak pedig a minta, a kémcső, a címke, és a tárolási feltételek szintén egy entitást jelentenek.

Egy másik példa - az automobil

Ha nem szereted a vért, hasonló okfejtés használható egy autóra is. Ez a példa talán valamivel közérthetőbb. Az autónak a fizikai megjelenésén kívül, egyéb technikai paraméterei is vannak - ezek lesznek az autó objektumunk mezői. Az autónak működnie is kell valamilyen előre meghatározott leírás szerint. A működés több részfolyamatból áll, ezeket a részfolyamatokat nevezzük metódusoknak.

Összefoglalva:

Az autó mezői:

  • szín
  • maximális sebesség
  • sebességfokozatok száma
  • ajtók száma
  • utasok maximális száma
  • az éppen bent ülő utasok száma
  • aktuális sebesség

Az autó metódusai:

  • motor indítás
  • gyorsítás
  • lassítás
  • sebességváltás

Programozási példa

Az elméleti fejtegetés után térjünk rá arra a kérdésre, hogy hogy néz ki programozási szempontból egy objektum! Ez a szekció ugyan fel van osztva részekre, de érdemesebb egyben olvasni a teljes kép megalkotásához.

Deklaráció

Ehhez vegyük alapul az automobilunkat; először is leírást kell készítenünk a mezőkről és a metódusokról: 

 type
   TAutoMobil = class

     { Mezők: }

     FSzin: String;                  { Az autó színe. }
     FMaxSebesseg: Real;             { Maximális sebesség. }
     FMaxUtasok: Integer;            { Utasok maximális száma. }
     FAktualisSebesseg: Real;        { Az aktuális sebesség. }
     FAktualisUtasok: Integer;       { A bent ülő utasok maximális száma. }

     { Metódusok: }

     constructor Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer);
     procedure Gyorsit;
     procedure Lassit;
   end;

Implementáció

Az előző példában jól látható a rekordhoz való hasonlóság, illetve az eltérés is abban, hogy itt már metódusok is lettek definiálva. A metódusokat és mezőket szintén a pont operátorral érhetjük el. Azonban ez a deklaráció még nem teljes! A metódusokat - akár a unit-oknál - ki kell fejtenünk a főprogram szekciójának megkezdése előtt: 

{ ...deklarációs rész... }

constructor TAutoMobil.Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer);
begin
  Self.FSzin := aSzin;
  Self.FMaxSebesseg := aMaxSebesseg;
  Self.FMaxUtasok:= aMaxUtasok;
end;

procedure TAutoMobil.Gyorsit;
begin
end;

procedure TAutoMobil.Lassit;
begin
end;

{ ...további programrészek... }

Vegyük észre a Self saját magára mutató objektumot. Ennek a haszna az, hogy az aktuális objektum egy mezőjére hivatkozhatunk vele. A létjogosultsága abban rejlik, hogy a metódusokon belül deklarálható létező mezővel megegyező azonosítójú változó, illetve függvény; így azonban megkülönböztethetjük őket.

Példányosítás (konstruktor)

Ne felejtsük el, hogy a deklaráció és a kifejtés még csak egy leírás - tervnek is tekinthetjük - az autóról. Ez azt jelenti, hogy még le kell gyártani - példányosítani kell. Erre szolgál az eddig talán ismeretlen constructor (konstruktor). Mint látható, nincs hozzá definiálva visszatérési érték, mégis értékadásra használjuk. Ennek az az oka, hogy alapértelmezetten egy pointer-rel és csak azzal térhet vissza. A pointer arra az objektumra mutat, amelyet létrehoztunk a konstruktorral. Talán kicsit bonyolultan hangzik elsőre, de lássuk a példát: 

var
  Auto: TAutoMobil;

begin
  Auto := TAutoMobil.Create('Fekete', 160, 5);
end;

Ezzel az egy sorral létrehoztuk az autónkat, amely fekete színű, 160 km/h a végsebessége, és 5 utas fér el benne. Ezek után már beindíthatjuk, gyorsíthatunk, lassíthatunk vele, stb.: 

var
  Auto: TAutoMobil;

begin
  Auto := TAutoMobil.Create('Fekete', 160, 5);

  Auto.Gyorsitas;
  Auto.Lassitas;
end;

Megsemmisítés (destruktor)

Mielőtt továbbmennénk, el kell fogadnunk, hogy az autó egy veszélyes hulladék. Ezért a szabályos megsemmisítésről gondoskodnunk kell. Ez a megsemmisítés szintén egy metódus, amely leírja, hogy mi a teendő megsemmisítés esetén. Ezt a metódust hívjuk destruktornak (destructor). A destruktort szintén deklarálni kell, majd pedig kifejteni. Ezzel kibővítve a deklarációnkat: 

 type
   TAutoMobil = class

     { Mezők: }

     FSzin: String;                  { Az autó színe. }
     FMaxSebesseg: Real;             { Maximális sebesség. }
     FMaxUtasok: Integer;            { Utasok maximális száma. }
     FAktualisSebesseg: Real;        { Az aktuális sebesség. }
     FAktualisUtasok: Integer;       { A bent ülő utasok maximális száma. }

     { Metódusok: }

     constructor Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer);
     destructor Destroy;
     procedure Gyorsit;
     procedure Lassit;
   end;

A destruktor programozástechnikai jelentősége abban rejlik, hogy az objektum által lefoglalt memóriaterületet felszabadítja. Ez a Pascal-nál (és C++-nál is) nagyon fontos, mivel nincs beépített szemétgyűjtő (mint pl. Java esetén), tehát a már nem szükséges objektumokat "kézzel" kell felszabadítanunk. Természetesen óvatosan kell eljárnunk, nehogy valahol még hivatkozzunk rá. A felszabadított objektumra való hivatkozás a program összeomlásával jár (SIGSEGV hiba), mivel nem létező objektumra mutatunk a hivatkozás során.

Ha idáig nem megy készség szinten, ne is folytasd az olvasást, inkább próbáld értelmezni az előzőeket! :)

Tulajdonságok (property-k)

Ha eddig minden érthető volt, akkor a dolgokat tovább kell bonyolítanunk azzal, hogy az autó, mint objektum, több egyéb objektumból áll - ezek például: motor, sebességváltó. Ha végig gondoljuk mindegyiknek vannak ugyanúgy mezői és metódusai. A motort, és a sebességváltót készen kapják az autógyárak, és beszerelik az autóba. Azonban ahhoz, hogy be tudják őket szerelni, helyet kell nekik biztosítani: mezőket kell létrehozni a deklarációban: 

 type
   TAutoMobil = class

     { Mezők: }

     FSzin: String;                  { Az autó színe. }
     FMaxSebesseg: Real;             { Maximális sebesség. }
     FMaxUtasok: Integer;            { Utasok maximális száma. }
     FAktualisSebesseg: Real;        { Az aktuális sebesség. }
     FAktualisUtasok: Integer;       { A bent ülő utasok maximális száma. }
     FMotor: TMotor;                 { Az autóba szerelt motor. }
     FSebessegValto: TSebessegValto; { Az autóba szerelt sebességváltó. }

     { Metódusok: }

     constructor Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer; aMotor: TMotor; aSebessegValto: TSebessegValto);
     destructor Destroy;
     procedure Gyorsit;
     procedure Lassit;
   end;

Ez megjelenik a konstruktorban is paraméterként. Így már többféle modell legyártható pl. a motor megváltoztatásával. A sebességváltó vagy a motor cseréje szükséges lehet később is, de amit be szeretnénk szerelni, nem biztos, hogy kompatibilis! Ha kompatibilitási problémánk lehet, akkor nem célszerű közvetlenül az objektum mezőjének értéket adni, mert később komoly, és nehezen visszakövethető hibát okozhatunk vele. Ennek a kiküszöbölésére használhatjuk az objektum metódusait is, ahol értékadás előtt vizsgálatot hajtunk végre, illetve a Pascal-ban egy elegáns megoldás a tulajdonságok (property-k) használata, amelyek ezt megold(hat)ják helyettünk. Deklarálhatunk írható-olvasható, és csak olvasható tulajdonságokat is. Egy autó kapcsán szinte minden cserélhető egymással, de most kivételesen vegyük az alvázszámot nem megváltoztathatónak (mivel tilos megváltoztatni). Ezt a gyárban egyszer beütik, és onnantól a megsemmisítésig ugyanaz az érték marad. Ehhez a property, a read, és a write kulcsszókat kell használnunk: 

 type
   TAutoMobil = class

     { Mezők: }

     FSzin: String;                  { Az autó színe. }
     FMaxSebesseg: Real;             { Maximális sebesség. }
     FMaxUtasok: Integer;            { Utasok maximális száma. }
     FAktualisSebesseg: Real;        { Az aktuális sebesség. }
     FAktualisUtasok: Integer;       { A bent ülő utasok maximális száma. }
     FAlvazSzam: String;             { A gyárban beütött alvázszám. }
     FMotor: TMotor;                 { Az autóba szerelt motor. }
     FSebessegValto: TSebessegValto; { Az autóba szerelt sebességváltó. }

     { Metódusok: }

     constructor Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer; aMotor: TMotor; aSebessegValto: TSebessegValto);
     destructor Destroy;
     procedure Gyorsit;
     procedure Lassit;
     procedure SetMotor(aMotor: TMotor);
     procedure SetSebessegValto(aSebessegValto: TSebessegValto);

     { Tulajdonságok: }

     property AlvazSzam: String read FAlvazSzam;             { Csak olvasható tulajdonság. }
     property Motor: TMotor read FMotor write SetMotor;      { Olvasható és írható tulajdonság. }
     property SebessegValto: TSebessegValto read FSebessegValto write SetSebessegValto;
   end;

Ezek után nézzük, hogy mit is csinál pl. a SetSebessegValto fuggvény: 

{ ...deklarációs rész... }

procedure TAutoMobil.SetSebessegValto(aSebessegValto: TSebessegValto);
begin
  if (IsCompatibleSebessegValto(aSebessegValto) = True) then
  begin
    Self.FSebessegValto := aSebessegValto;
  end
  else Self.FSebessegValto := null;
end;

procedure TAutoMobil.Lassit;
begin
end;

{ ...további programrészek... }

A példában használt IsCompatibleSebessegValto függvény valahol az osztályon kívül definiált. A tartalmával nem fontos a példa szempontjából foglalkozni. A lényeg, hogy megállapítja, hogy a beszerelni kívánt sebességváltó kompatibilis-e az autóval. Ha igen, akkor bekerül, ha nem, akkor nem kerül be sebességváltó (feltételezzük, hogy a régi sebességváltó már ki lett szerelve).

Virtuális metódusok

Megállapíthatjuk, hogy egy adott gyártó egy adott típusú automobilból gyárt többféle változatot, pl. mechanikus és elektromos gázpedállal is. Ebben az esetben az alapvető funkciók megegyeznek, de kicsi eltérések vannak. Ilyen alapvető funkciók pl. a gyorsítás, a lassítás, stb. Ezért ezeket a különböző példányokban különbözőképpen kell megvalósítani. Erre valók a virtuális metódusok, amelyeket a virtual kulcsszóval deklarálhatunk. Alapul véve az előbbi gondolatmenetet, így fog kinézni a TAutoMobil osztályunk: 

 type
   TAutoMobil = class

     { Mezők: }

     FSzin: String;                  { Az autó színe. }
     FMaxSebesseg: Real;             { Maximális sebesség. }
     FMaxUtasok: Integer;            { Utasok maximális száma. }
     FAktualisSebesseg: Real;        { Az aktuális sebesség. }
     FAktualisUtasok: Integer;       { A bent ülő utasok maximális száma. }
     FAlvazSzam: String;             { A gyárban beütött alvázszám. }
     FMotor: TMotor;                 { Az autóba szerelt motor. }
     FSebessegValto: TSebessegValto; { Az autóba szerelt sebességváltó. }

     { Metódusok: }

     constructor Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer; aMotor: TMotor; aSebessegValto: TSebessegValto);
     destructor Destroy;
     procedure Gyorsit; virtual;
     procedure Lassit; virtual;
     procedure SetMotor(aMotor: TMotor);
     procedure SetSebessegValto(aSebessegValto: TSebessegValto);

     { Tulajdonságok: }

     property AlvazSzam: String read FAlvazSzam;             { Csak olvasható tulajdonság. }
     property Motor: TMotor read FMotor write SetMotor;      { Olvasható és írható tulajdonság. }
     property SebessegValto: TSebessegValto read FSebessegValto write SetSebessegValto;
   end;

A virtual kulcsszóval deklarált függvényeket később az öröklődés során létrehozott gyerek osztályok metódus implementációiban módunkban áll módosítani. Ha nem tesszük meg, akkor automatikusan a szülő osztályban implementált metódus fog lefutni.

Absztrakt metódusok

Az automobilról mindenkinek ugyanaz a kép jut eszébe, azonban különböző gyártók különböző modelleket gyártanak, amelyek működésben is eltérhetnek egymástól. Úgy is fogalmazhatnánk, hogy attól még, hogy mi magunk is tudjuk, hogy nagyjából hogyan néz ki és működik egy autó, legyártani nem tudnánk. Tehát az automobilt egy absztrakt fogalomként kell értelmezni. Erre való az abstract kulcsszó használata: 

 type
   TAutoMobil = class

     { Mezők: }

     FSzin: String;                  { Az autó színe. }
     FMaxSebesseg: Real;             { Maximális sebesség. }
     FMaxUtasok: Integer;            { Utasok maximális száma. }
     FAktualisSebesseg: Real;        { Az aktuális sebesség. }
     FAktualisUtasok: Integer;       { A bent ülő utasok maximális száma. }
     FAlvazSzam: String;             { A gyárban beütött alvázszám. }
     FMotor: TMotor;                 { Az autóba szerelt motor. }
     FSebessegValto: TSebessegValto; { Az autóba szerelt sebességváltó. }

     { Metódusok: }

     constructor Create(aSzin: String; aMaxSebesseg: Real; aMaxUtasok: Integer; aMotor: TMotor; aSebessegValto: TSebessegValto); virtual; abstract;
     destructor Destroy; virtual; abstract;
     procedure Gyorsit; virtual; abstract;
     procedure Lassit; virtual; abstract;
     procedure SetMotor(aMotor: TMotor); virtual; abstract;
     procedure SetSebessegValto(aSebessegValto: TSebessegValto); virtual; abstract;

     { Tulajdonságok: }

     property AlvazSzam: String read FAlvazSzam;             { Csak olvasható tulajdonság. }
     property Motor: TMotor read FMotor write SetMotor;      { Olvasható és írható tulajdonság. }
     property SebessegValto: TSebessegValto read FSebessegValto write SetSebessegValto;
   end;

Erre a célra azonban megfelelőbb az interfészek használata.

Öröklődés

A gyártók azonban a birtokában vannak az absztrakt fogalmak mögött rejlő tudásnak, ezért a saját elképzeléseik és tudásuk hozzáadásával egyedi automobilokat hoznak létre. Ezt nevezzük öröklődésnek (inheritance). Ennek megértéséhez be kell vezetnünk a szülő (parent) és gyerek (child) fogalmakat. Ez programozási szempontból a következőképpen néz ki, ha pl. a Mercedes gyárról beszélünk: 

 type
   TMercedesAutoMobil = class(TAutoMobil)

     FLegzsakokSzama: Integer; 
   
     procedure Gyorsit; override;
     procedure Lassit; override;
   end;

A class kulcsszó utáni zárójelben adjuk meg a szülő osztály nevét. Tehát a szülő osztály a TAutoMobil, a gyerek pedig a TMercedesAutoMobil lesz, amely örökölni fogja a szülő mezőit, metódusait és tulajdonságait. Ebben az esetben a Mercedes gyárnak kell meghatározni (programozási szempontból kifejteni) az abstract kulcsszóval ellátott metódusokat. Ehhez a deklarációs részben a metódusok után az override kulcsszót kell használni. Az absztrakt metódusok kifejtése mellett további mezők is kerülnek a gyerek objektumba, pl. a légzsákok száma - ami ugye nem feltétlenül része egy autónak (gondoljunk a régebbi modellekre). Ez az eljárás magával hozza azt a kérdést is, hogy mégis milyen tulajdonságokat, metódusokat örököljön majd a gyerek? Hogyan lehetne ezt definiálni? Erre valók a láthatóságot (visibility) definiáló kulcsszavak.


Folytatás hamarosan...

Free Pascal Language Extensions

FPC includes several language extensions to its "standard" Pascal syntax to support object oriented programming.

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.

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.

General Concepts of Object Oriented Pascal

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.

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.

Further information

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

See Also

External Links

Retrieved from "https://wiki.freepascal.org/index.php?title=Object_Oriented_Programming_with_Free_Pascal_and_Lazarus/hu&oldid=132765"