Delphi: základy OOP poprvé

Dnes si vysvětlíme a objasníme objektově orientované programování v Delphi.

Celý systém kompilovaných aplikaci je postaven na OOP, proto se i my podívejme, jak se s OOP pracuje v Delphi.

Každá třída musí být definována. Definice jsou buď celé námi vytvořené, nebo můžeme naprogramovat pouze část třídy (rozšířit již nějakou hotovou) a v této chvíli využíváme tzv. dědočnosti. Třídy jsou tedy základním stavebním kamenem. Jedna třída může být proměněna v několik prvků, tyto prvky pak nazýváme instancemi třídy nebo objekty - jedná se o totéž. Definice třídy vypadá následovně:

type
...
TMojeNovaTrida = class
  //definice vlastností
end;
...

Je zažitou a vhodnou konvencí používat před názvem každé třídy písmeno "T"! Získáte potom mnohem větší přehed o použitývh identifikátorech.

Vytvoření objektu probíhá potom následovně: vytvoření proměnné, která je typu úpožadovaného objektu; vytvoření objektu;

...
        novaPromenna: TMojeNovaTrida;

...

        novaPromenna := TMojeNovaTrida.Create();
...

Z objektu nyní můžeme volat všechny funkce a procedury námi definované. Velkou výhodou, a samozřejmostí, je dědičnost. Tu budeme v našich komponentech hojně využívat. Abychom nemuseli potřebný balast, a spoustu již hotových funkcí, psát sami, oddědíme potomka od námi vybraného předka (rodiče) a funkce zveřejníme případně poupravíme. Dědění probíhá následovně:

...
TMojeNovaTrida = class(TPredekNoveTridy)
  //definice vlastností
end;
...

V posledním příkladu jsme získaly děděním veškeré proměnné a metody (funkce a procedury). Hezké šetření práce, že?

A teď zkusíme něco prakticky. Vytvoříme třídu s jednou funkcí, kterou následně oddědíme a trochu pozměníme.

Zadání zní: třída "TNasob" vrací definovanou funkcí "nasobek" násobek hodnot předaných jako parametr. Třída "TNasobPricti" vrací ve funkci "nasobek" výsledek funkce "nasobek" s přičteným číslem 2.

Znalejší mávají rukou a my, začínající, si to předvedeme prakticky. Nejdříve definujeme naši novou třídu "TNasob"

TNasob = class
public //důležité: funkce a proměnné za tímto slovem budou veřejné
  function nasobek(a,b: integer):integer;
end;

// nyní klasická deklarace funkce v třídě

TNasob.nasobek(a,b: integer):integer;
begin
  result:= a * b;   //funkce vrací násobek předaných hodnot;
end;

Doufám, že zatím nikdo nemá problémy s pochopením posledního příkladu.

Za zmínku stojí pouze modifikátor public. Zde je seznam používaných modifikátorů a jejich popis.

Modifikátory
› private - funkce a proměnné jsou soukromé, nejsou přístupny od jinud, než ze vnitř komponenty.
› protected - funkce a proměnné jsou chráněné, přístup je povolen pouze třídě samotné, či jejím potomkům.
› public - funkce a proměnné jsou přístupné v celé aplikaci, pokud je zde sama třída přístupná.
› published - funkce a proměnné jsou přístupné nejen v aplikaci, ale také jejím návrhu. Tento modifikátor je využíván především pro tvorbu properity (vlastností), které měníte v Object Inspectoru.

Této problematice se budeme věnovat později. Pro teď je důležité, že funkce je definována veřejně a je tedy možné ji volat z programu.

Nyní vytvoříme potomka třídy TNasobek:

TNasobPricti = class(TNasob)
public //důležité: funkce a proměnné za tímto slovem budou veřejné
  function nasobek(a,b: integer):integer;
end;

// nyní klasická deklarace funkce v třídě

TNasobPricti.nasobek(a,b: integer):integer;
begin
  result:= inherited nasobek(a,b);
  result:= result + 2;   //funkce vrací násobek předaných hodnot s přičteným číslem dva;
end;

V tomto příkladě jsme využili možnosti dědění. Pomocí slůvka inherited jsme zdědili výsledek funkce rodiče ("nasobek"). Této funkci rodiče jsme taky předali parametry, které naše nová funkce obdržela.
result:= inherited nasobek(a,b); Poslední řádek znamená: Zděď výsledek funkce "nasobek" od mého rodiče a ulož ho do proměnné result;

Pro dnešek je toho myslím až dost. Na závěr přikládám celý zdrojový kód i s ukázkou využití.

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  TNasob = class
  public
    function nasobek(a,b: integer):integer;
  end;

  TNasobPricti = class(Tnasob)
  public
    function nasobek(a,b :integer):integer;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function TNasob.nasobek(a,b: integer):integer;
begin
 result := (a*b);
end;

function TNasobPricti.nasobek(a,b: integer):integer;
begin
 result := inherited nasobek(a,b);
 result := result + 2;
end;


procedure TForm1.Button1Click(Sender: TObject);
var trida: TNasobPricti;
begin
trida := TNasobPricti.Create;

edit3.Text := inttostr(
  trida.nasobek( strtoint( edit1.text ),
                 strtoint( edit2.Text ))
                      );
end;

end.

Zksete si: Vytvořte projekt v delphi a v něm třídu TPricti, která bude potomkem třídy TNasob (třída TNasob bude vypadat stejně jako v dnešním příkladu). Třída TPricti přičte ve své funkci "pricti" k odděděnému výsledku funkce "nasobek" (s dvěma předanými paramtry) číslo, které získá jako svůj třetí parametr. Dále vytvořte potomka třídy TPricti, jehož jméno bude TRovnice. Třída TRovnice ve své funkci "execute" zdědí od svého rodiče výsledek funkce nasobek a vydělí ho dvěma a zaokrouhlí jej. Celý program pracuje pouze s datovým typem integer. V projektu využijte třídu TRovnice, umožněte libovolný vstup.